courthive-components 3.12.2 → 3.13.0

package/dist/components/court-layout/buildCourtLayout.d.ts

@@ -0,0 +1,24 @@
+import { CourtCardConfig } from '../court-card/types';
+import { CourtLayoutCallbacks, CourtLayoutConfig, CourtLayoutCourt, CourtLayoutData } from './types';
+export interface CourtGroup {
+    key: string;
+    label: string;
+    courts: CourtLayoutCourt[];
+}
+export declare function settingOf(court: CourtLayoutCourt): string;
+export declare function surfaceOf(court: CourtLayoutCourt): string;
+/**
+ * Split courts into display groups. Order within a group is always courtOrder-first; the ORDER OF
+ * THE GROUPS follows first appearance in that sorted list, so a venue whose court 1 is outdoor
+ * leads with outdoor rather than with whatever sorts first alphabetically.
+ */
+export declare function groupCourts(courts: CourtLayoutCourt[], grouping: CourtLayoutConfig['grouping']): CourtGroup[];
+/** "8 outdoor hard, 4 indoor hard" — the breakdown, most common first. */
+export declare function summarizeCourts(courts: CourtLayoutCourt[]): string;
+export declare function buildCourtLayout(data: CourtLayoutData, config?: Partial<CourtLayoutConfig>, callbacks?: CourtLayoutCallbacks): HTMLElement;
+/**
+ * Card config for a cell, given what the group heading already says. Repeating "Outdoor" on every
+ * card inside a group headed OUTDOOR is noise, so the redundant corner badge is dropped — but only
+ * the redundant one. `floodlit` is never implied by grouping and always survives.
+ */
+export declare function cellCardConfig(grouping: CourtLayoutConfig['grouping']): Partial<CourtCardConfig> | undefined;

package/dist/components/court-layout/defaultConfig.d.ts

@@ -0,0 +1,3 @@
+import { CourtLayoutConfig } from './types';
+export declare const DEFAULT_COURT_LAYOUT_CONFIG: CourtLayoutConfig;
+export declare function mergeCourtLayoutConfig(override?: Partial<CourtLayoutConfig>): CourtLayoutConfig;

package/dist/components/court-layout/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Court Layout — public surface.
+ *
+ * A venue's courts as an ordered, grouped grid of court cards. No map, no coordinates, no optional
+ * dependency — see venue-locator for the map.
+ */
+export { buildCourtLayout, cellCardConfig, groupCourts, settingOf, summarizeCourts, surfaceOf } from './buildCourtLayout';
+export { DEFAULT_COURT_LAYOUT_CONFIG, mergeCourtLayoutConfig } from './defaultConfig';
+export type { CourtGroup } from './buildCourtLayout';
+export type { CourtLayoutCallbacks, CourtLayoutConfig, CourtLayoutCourt, CourtLayoutData, CourtLayoutGrouping } from './types';

package/dist/components/court-layout/styles.d.ts

@@ -0,0 +1,8 @@
+export declare const clRootStyle: () => string;
+export declare const clSummaryStyle: () => string;
+export declare const clSummaryCountStyle: () => string;
+export declare const clGroupStyle: () => string;
+export declare const clGroupHeadingStyle: () => string;
+export declare const clGroupCountStyle: () => string;
+export declare const clGridStyle: () => string;
+export declare const clEmptyStyle: () => string;

package/dist/components/court-layout/types.d.ts

@@ -0,0 +1,46 @@
+import { CourtSport } from '../courts/courtSvgUtil';
+/**
+ * A court as it arrives from the factory / facilities registry. Intentionally loose — it is passed
+ * to `mapCourtToCardData`, which does the normalising, so a caller can hand over a TODS `Court`
+ * untouched.
+ */
+export interface CourtLayoutCourt {
+    courtId?: string;
+    courtName: string;
+    courtAbbreviation?: string;
+    indoorOutdoor?: string;
+    surfaceCategory?: string;
+    surfaceType?: string;
+    floodlit?: boolean;
+    courtOrder?: number;
+    [key: string]: unknown;
+}
+export interface CourtLayoutData {
+    venueId?: string;
+    venueName?: string;
+    courts: CourtLayoutCourt[];
+}
+/**
+ * How the grid is divided.
+ *  'none'    — one grid, ordered by courtOrder
+ *  'setting' — indoor vs outdoor (the scheduling-relevant split: rain, lights, curfew)
+ *  'surface' — hard vs clay vs grass …
+ *  'both'    — setting, then surface within it
+ */
+export type CourtLayoutGrouping = 'none' | 'setting' | 'surface' | 'both';
+export interface CourtLayoutConfig {
+    grouping: CourtLayoutGrouping;
+    /** Sport whose court outline each card draws. */
+    sport: CourtSport;
+    /** Heading above each group, with its court count. */
+    showGroupHeadings: boolean;
+    /** One-line "12 courts · 8 outdoor hard, 4 indoor hard" summary above the grid. */
+    showSummary: boolean;
+    /** Minimum card width; the grid auto-fills to the container. Any CSS length. */
+    minCardWidth: string;
+    /** Render nothing but a message when `courts` is empty. */
+    emptyMessage: string;
+}
+export interface CourtLayoutCallbacks {
+    onCourtClick?: (court: CourtLayoutCourt) => void;
+}

package/dist/components/venue-locator/buildVenueLocator.d.ts

@@ -0,0 +1,23 @@
+import { VenueLocatorCallbacks, VenueLocatorConfig, VenueLocatorCourt, VenueLocatorData, VenueLocatorTileLayer, VenueLocatorView } from './types';
+export declare function hasVenueGeo(data: VenueLocatorData): boolean;
+/** Re-exported so the locator's public surface stays stable; the comparator is shared with court-layout. */
+export declare function sortVenueCourts(courts: VenueLocatorCourt[]): VenueLocatorCourt[];
+export declare function describeCourt(court: VenueLocatorCourt): string;
+export declare function buildVenueLocator(data: VenueLocatorData, config?: Partial<VenueLocatorConfig>, callbacks?: VenueLocatorCallbacks): HTMLElement;
+/** Remove the Leaflet instance and observers for a locator built by buildVenueLocator. */
+export declare function destroyVenueLocator(root: HTMLElement): void;
+/**
+ * Leaflet ships its own stylesheet, and this component deliberately does not import it (leaflet is
+ * an optional peerDependency, so a static CSS import would make it mandatory). Without it Leaflet's
+ * panes are unpositioned and the map paints as a broken band of tiles — a failure that looks like a
+ * component bug and is silent otherwise. `.leaflet-container` is `position: relative` in that
+ * stylesheet, so anything else means it never loaded.
+ */
+export declare function leafletCssMissing(containerPosition: string | undefined): boolean;
+export declare function isDarkTheme(): boolean;
+/**
+ * Which tile source a given view should render right now. The street view swaps to a real dark
+ * basemap under a dark theme — filtering light tiles to fake one produces a false-colour negative.
+ * Satellite never swaps: there is no dark equivalent of a photograph.
+ */
+export declare function resolveTileLayer(cfg: VenueLocatorConfig, view: VenueLocatorView, dark: boolean): VenueLocatorTileLayer;

package/dist/components/venue-locator/defaultConfig.d.ts

@@ -0,0 +1,3 @@
+import { VenueLocatorConfig } from './types';
+export declare const DEFAULT_VENUE_LOCATOR_CONFIG: VenueLocatorConfig;
+export declare function mergeVenueLocatorConfig(override?: Partial<VenueLocatorConfig>): VenueLocatorConfig;

package/dist/components/venue-locator/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Venue Locator — public surface.
+ *
+ * Requires the optional peerDependency `leaflet` (and its stylesheet) in the host:
+ *   pnpm add leaflet
+ *   import 'leaflet/dist/leaflet.css';
+ * Without it the component still renders — header + court list, with a "Map unavailable" zone.
+ */
+export { buildVenueLocator, destroyVenueLocator, describeCourt, hasVenueGeo, isDarkTheme, leafletCssMissing, resolveTileLayer, sortVenueCourts } from './buildVenueLocator';
+export { mapVenueToLocatorData } from './mapVenue';
+export { DEFAULT_VENUE_LOCATOR_CONFIG, mergeVenueLocatorConfig } from './defaultConfig';
+export type { VenueLocatorCallbacks, VenueLocatorConfig, VenueLocatorCourt, VenueLocatorData, VenueLocatorLayout, VenueLocatorTileLayer, VenueLocatorView } from './types';

package/dist/components/venue-locator/mapVenue.d.ts

@@ -0,0 +1,2 @@
+import { VenueLocatorData } from './types';
+export declare function mapVenueToLocatorData(venue: any): VenueLocatorData;

package/dist/components/venue-locator/styles.d.ts

@@ -0,0 +1,25 @@
+export declare const vlRootStyle: () => string;
+export declare const vlHeaderStyle: () => string;
+export declare const vlTitleStyle: () => string;
+export declare const vlAddressStyle: () => string;
+export declare const vlNotesStyle: () => string;
+export declare const vlBodyStyle: () => string;
+export declare const vlBodyBelowStyle: () => string;
+export declare const vlMapWrapStyle: () => string;
+export declare const vlMapStyle: () => string;
+export declare const vlMapInvertibleStyle: () => string;
+export declare const vlToggleStyle: () => string;
+export declare const vlToggleButtonStyle: () => string;
+export declare const vlFallbackStyle: () => string;
+export declare const vlFallbackIconStyle: () => string;
+export declare const vlCourtsStyle: () => string;
+export declare const vlCourtsTitleStyle: () => string;
+export declare const vlCourtListStyle: () => string;
+export declare const vlCourtStyle: () => string;
+export declare const vlCourtClickableStyle: () => string;
+export declare const vlCourtNameStyle: () => string;
+export declare const vlCourtMetaStyle: () => string;
+export declare const vlPipStyle: () => string;
+export declare const vlMarkerStyle: () => string;
+export declare const vlPopupTitleStyle: () => string;
+export declare const vlPopupAddressStyle: () => string;

package/dist/components/venue-locator/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Venue Locator — Type Definitions
+ *
+ * Flat data + JSON-serializable config consumed by buildVenueLocator.
+ * Mirrors the venue-card / court-card pattern.
+ *
+ * Scope: ONE venue on a real map — "where is this club". Courts are LISTED beside the
+ * map rather than plotted on it, because the facility registry carries coordinates on the
+ * facility, not per court (`facility_courts` has no latitude/longitude). If per-court geo
+ * ever lands, `VenueLocatorCourt.latitude/longitude` is where it plugs in.
+ */
+export interface VenueLocatorCourt {
+    courtId: string;
+    courtName: string;
+    /** INDOOR / OUTDOOR / undefined (unknown). */
+    indoorOutdoor?: 'INDOOR' | 'OUTDOOR';
+    /** Surface category (HARD/CLAY/GRASS/CARPET/...) — raw upper-case. */
+    surfaceCategory?: string;
+    /** True when the court has floodlights. */
+    floodlit?: boolean;
+    /** Ordering within the venue (TODS courtOrder). Sorted ascending when present. */
+    courtOrder?: number;
+    /**
+     * Per-court coordinates. Unused today — the registry stores geo on the facility only.
+     * When present the court is plotted as its own marker instead of folding into the venue pin.
+     */
+    latitude?: number;
+    longitude?: number;
+}
+export interface VenueLocatorData {
+    venueId: string;
+    venueName: string;
+    venueAbbreviation?: string;
+    /** Pre-formatted "123 Main St, City, REGION" — rendered under the title and in the popup. */
+    addressFormatted?: string;
+    /** Venue coordinates. Without both, the component renders its no-geo state. */
+    latitude?: number;
+    longitude?: number;
+    /** Courts at this venue, listed beside the map. */
+    courts?: VenueLocatorCourt[];
+    /** Free-form note rendered under the address. */
+    notes?: string;
+}
+/**
+ * A tile layer definition. Deliberately the same shape TMX already uses in
+ * `config/locationConfig.ts` so a consumer can pass `env.leaflet.map` /
+ * `env.leaflet.satellite` straight through without translation.
+ */
+export interface VenueLocatorTileLayer {
+    tileLayer: string;
+    attribution: string;
+    maxZoom?: number;
+}
+export type VenueLocatorView = 'map' | 'satellite';
+/** Where the court list sits relative to the map. */
+export type VenueLocatorLayout = 'side' | 'below' | 'none';
+export interface VenueLocatorConfig {
+    /** Tile sources. Defaults mirror TMX's leafletConfig defaults (OSM + Esri imagery). */
+    tiles: Record<VenueLocatorView, VenueLocatorTileLayer>;
+    /**
+     * Street tiles used under a dark theme. Kept OUT of `tiles` on purpose: `tiles` is keyed by
+     * VenueLocatorView and drives the view toggle, and a dark basemap is the same view rendered
+     * differently, not a third thing to choose. Set to `null` to force the CSS-filter path.
+     */
+    darkTileLayer: VenueLocatorTileLayer | null;
+    /** Which tile source to show first. */
+    view: VenueLocatorView;
+    /** Render the map/satellite toggle. Hidden when only one tile source is configured. */
+    showViewToggle: boolean;
+    /** Initial zoom on the venue. */
+    zoom: number;
+    /** Map height as any CSS length. */
+    height: string;
+    /** Court list placement. */
+    courtsLayout: VenueLocatorLayout;
+    /** Show the venue title + address block above the map. */
+    showHeader: boolean;
+    /** Open a popup on the venue marker with name + address. */
+    showPopup: boolean;
+    /** Allow scroll-wheel zoom. Off by default so the map doesn't hijack page scroll. */
+    scrollWheelZoom: boolean;
+    /**
+     * Dark-theme handling for the street view.
+     *  'auto'  — swap to `darkTileLayer` when the theme is dark; if no dark layer is configured,
+     *            fall back to inverting the street tiles in CSS (legible, but not pretty).
+     *  'never' — always render the light street tiles.
+     * Satellite is never darkened either way: inverting imagery yields a false-colour photo, and
+     * there is no dark equivalent of a photograph.
+     */
+    darkTiles: 'auto' | 'never';
+}
+export interface VenueLocatorCallbacks {
+    /** Venue marker (or its popup) clicked. */
+    onVenueClick?: (data: VenueLocatorData) => void;
+    /** A court in the list was clicked. */
+    onCourtClick?: (court: VenueLocatorCourt, data: VenueLocatorData) => void;
+    /** Tile view switched. */
+    onViewChange?: (view: VenueLocatorView) => void;
+    /**
+     * Leaflet could not be loaded or the map failed to initialize. The component has already
+     * rendered its fallback (header + court list) by the time this fires — it is a signal for
+     * the host to log, not an error the host must handle to keep the UI coherent.
+     */
+    onMapUnavailable?: (reason: Error) => void;
+}