@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/store/VenueStore.d.ts

@@ -0,0 +1,254 @@
+import { Box, type Point2Like } from '@expofp/geometry';
+import { type VenuePresentationState } from '../components/Maplibre/utils/venue-zoom';
+import { type ParsedVenue, type ParsedVenueAuxLayer, type VenueDiagnostic } from '../data/venues';
+import { type Layer } from './LayerStore';
+import type RootStore from './RootStore';
+export type VenueCameraRequest = {
+    kind: 'venue';
+    intentId: number;
+    venueId: string;
+    /** The level framed — its layer name; north-up turns the map to its viewbox. */
+    layer: string;
+    rect: Box;
+} | {
+    kind: 'campus';
+    intentId: number;
+    rect: Box;
+};
+interface VenueEntryOptions {
+    fly?: boolean;
+    level?: Layer | VenueLevel | string;
+}
+export interface VenueLevel {
+    readonly layer: Layer;
+    readonly ordinal: number;
+    readonly displayName: string;
+    readonly initial: boolean;
+}
+/**
+ * What showing a level means: its authored `viewbox` together with the floor
+ * it draws (`rect`), so neither one cuts the other off — an authored viewbox
+ * can stop short of an entrance or courtyard the floor draws. A viewbox
+ * that misses the drawing entirely is not a floor extent (some multi-venue
+ * exports offset it from the artwork) and is left out. Null when the level
+ * carries neither.
+ */
+export declare function levelFrame(layer: Layer): Box | null;
+/**
+ * A door of a venue: where the building meets the outside world, plan-local on
+ * one of its own levels (contract §6.1). Cross-venue journeys target one of
+ * these instead of the venue's marker point; venues that author none keep
+ * marker-point targeting, permanently and by design.
+ */
+export interface VenueEntrance {
+    /** The level this door stands on — always one of its venue's own. */
+    readonly level: VenueLevel;
+    /** Plan-local position, the same space booths and contours use. */
+    readonly point: Point2Like;
+    /** Authored display label; the venue's own name stands in when absent. */
+    readonly name?: string;
+}
+/**
+ * A venue: a named group of levels within one plan (multi-venue data contract v1,
+ * docs/specs/multi-venue-data-contract.md). Geometry is plan-local; a future
+ * composited-plan source additionally needs a per-venue coordinate transform.
+ */
+export declare class Venue {
+    readonly id: string;
+    readonly name: string;
+    readonly order: number;
+    /** Building outline (authored, or hull of level rects), plan-local coordinates. */
+    readonly contour: Point2Like[];
+    /** Far-zoom pin anchor. */
+    readonly markerPoint: Point2Like;
+    /** Axis-aligned bounds of the contour — the venue-activation camera target. */
+    readonly bounds: Box;
+    /** This venue's rich level records in authored presentation order. */
+    readonly levels: VenueLevel[];
+    readonly initialLevel: VenueLevel;
+    /** Authored minimum projected width and height, in CSS pixels. */
+    readonly detailMinSizePx?: number;
+    /** Authored marker ⇄ scene edge, in CSS pixels (§4, Revision 5); absent means 60. */
+    readonly markerMaxSizePx?: number;
+    /** Revision 2 degraded-appearance layers with authored size bounds intact. */
+    readonly auxLayers: ParsedVenueAuxLayer[];
+    /** Authored doors, in authored order. Empty on the many plans without any. */
+    readonly entrances: VenueEntrance[];
+    private readonly _activeLevelName;
+    private readonly _lastUserActivatedLevelName;
+    private readonly _presentationState;
+    constructor(parsed: ParsedVenue, levels: VenueLevel[], initialLevel: VenueLevel);
+    /** Union of every level's frame — what fitting the whole venue on screen must show. */
+    get frame(): Box;
+    /** The single visible level of this venue (venue-scoped Radio). */
+    get activeLevel(): VenueLevel;
+    get lastUserActivatedLevel(): VenueLevel | null;
+    setActiveLevel(level: VenueLevel, userActivated: boolean): void;
+    /**
+     * What this venue shows for the current camera (R5-R9), written by the
+     * camera-tracking hook (`useVenueCameraTracking`). Null until mount-time
+     * evaluation and treated as full detail on plans without the MapLibre map.
+     */
+    get presentationState(): VenuePresentationState | null;
+    set presentationState(state: VenuePresentationState | null);
+    /** Full floor detail currently visible (R6); unevaluated counts as visible. */
+    get detailVisible(): boolean;
+}
+/**
+ * Owns the venue model of a multi-venue plan: the venue list, viewport focus,
+ * and each venue's active level. Levels stay owned by LayerStore; a venue
+ * references them. Populated by `init()` once layers are known; empty (and
+ * therefore inert) on plans without venue data.
+ */
+export default class VenueStore {
+    private readonly rootStore;
+    venues: Venue[];
+    /** Immutable load-time parser and geometry diagnostics. */
+    diagnostics: VenueDiagnostic[];
+    /** The plan's authored campus frame (contract §3, Revision 9), when usable. */
+    private readonly campusViewbox;
+    /** Context inferred from the viewport, independent of deliberate intent. */
+    automaticContextVenueId: string | null;
+    /** Deliberate destination context retained until the next manual camera action. */
+    destinationVenueId: string | null;
+    /** Semantic camera request consumed by the MapLibre camera coordinator. */
+    cameraRequest: VenueCameraRequest | null;
+    /**
+     * Effective context used by the switch and scoped floor API. A destination
+     * override wins over automatic context. Context never changes level visibility.
+     */
+    focusedVenueId: string | null;
+    private readonly levelActivationRequests;
+    private cameraIntentId;
+    private readonly floorActivatedNotifier;
+    /** Deferred one tick so `getVenues()` reflects the settled state, as for floors. */
+    private readonly venueActivatedNotifier;
+    constructor(rootStore: RootStore);
+    get hasVenueModel(): boolean;
+    get isCampusMode(): boolean;
+    /** Venue-switch order: resolved `order`, then `id` — never array position (§9). */
+    get orderedVenues(): Venue[];
+    get focusedVenue(): Venue | null;
+    /** First venue by resolved order. */
+    get defaultVenue(): Venue | null;
+    /**
+     * The whole-campus frame: the plan's authored campus viewbox, otherwise the
+     * union of every venue footprint. The initial fit, `viewAllVenues()` and a
+     * no-context Fit-to-screen all read it, so a plan opens on exactly the rect
+     * "View all venues" returns to. Null on plans without a venue model.
+     */
+    get campusBounds(): Box | null;
+    /**
+     * Whether `campusBounds` is the authored campus viewbox. An authored frame is
+     * shown as-is, with no fit padding beyond the chrome; the footprint union is
+     * bare geometry and keeps its breathing room. Every campus fit decides its
+     * padding from this one flag, so they all land on the same camera.
+     */
+    get campusBoundsAuthored(): boolean;
+    /** The context venue when available, otherwise the resolved non-MapLibre default. */
+    get fallbackVenue(): Venue | null;
+    /** Public active venue: nullable campus context, or the resolved fallback venue. */
+    get activeVenue(): Venue | null;
+    /**
+     * Aux-referenced plan layers by name → referencing venues (usually one).
+     * These layers must never behave as floors: LayerStore excludes them from
+     * `venueLayers`/`floors`, and their scene visibility is owned exclusively
+     * by the zoom sync (`useLayerVisibilitySync`, KTD-1/KTD-2).
+     */
+    get auxVenuesByLayerName(): ReadonlyMap<string, Venue[]>;
+    /**
+     * What the selector renders (KTD-5, Google Maps pattern): the focused
+     * venue's level list only while that venue shows floor detail; the venue
+     * list otherwise - in a no-context campus view, and while the focused venue
+     * has degraded below its detail cutoff (no floors to pick from at that zoom).
+     */
+    get selectorMode(): 'venues' | 'levels';
+    /**
+     * Level layer name → owning venue. The parser guarantees a layer belongs to
+     * at most one venue, so this is a plain map rather than a multimap.
+     */
+    get venuesByLevelLayerName(): ReadonlyMap<string, Venue>;
+    venueOfLayer(layerOrName: Layer | string): Venue | null;
+    /**
+     * Resolves a venue by `id` and only by `id` (contract §9): `name` is display
+     * text an organizer may localize or retype at any time, so matching it would
+     * make the fragile handle the addressable one. Only the argument is
+     * normalized — a parsed venue's `id` already matches `[a-z0-9_-]+` — so an
+     * uppercased deep link still resolves.
+     */
+    findVenue(id: string): Venue | null;
+    /**
+     * The venue whose building outline holds a plan point — the smallest one
+     * when outlines nest. Null outdoors and on plans without a venue model.
+     */
+    venueAt(point: Point2Like): Venue | null;
+    /**
+     * Builds the venue model from `data.venues` once LayerStore holds the plan's
+     * layers (called from init-layers). Malformed data yields no venues and the
+     * plan behaves exactly as today.
+     */
+    init(): void;
+    /**
+     * Venue-scoped visibility baseline: every venue shows exactly its active
+     * level; non-venue layers (pathways, frozen/technical) are untouched.
+     * Idempotent — also re-applied when the MapLibre map becomes ready.
+     */
+    applyInitialVisibility(): void;
+    /**
+     * R14 fallback for venue plans without the MapLibre map (legacy 2D renderer):
+     * the plan degrades to a single-venue-like multi-floor plan — only the
+     * focused (or default) venue's active level stays visible.
+     */
+    applyFallbackVisibility(): void;
+    /** Updates viewport-inferred context without disturbing a destination override. */
+    setAutomaticContext(venueOrId: Venue | string | null): void;
+    /** Establishes deliberate destination context and optionally moves the camera. */
+    enterVenue(venueOrId: Venue | string, { fly, level: levelOrName }?: VenueEntryOptions): Promise<void>;
+    /** Backward-compatible name for deliberate venue entry. */
+    focusVenue(venueOrId: Venue | string, options?: VenueEntryOptions): Promise<void>;
+    /** Releases deliberate intent; viewport-inferred context becomes effective immediately. */
+    releaseDestinationOverride(): void;
+    /** Clears a consumed request without discarding a newer superseding request. */
+    clearCameraRequest(request: VenueCameraRequest): void;
+    /** Requests a useful whole-campus fit while retaining context until settle. */
+    viewAllVenues(): void;
+    /**
+     * Re-frames the active venue on its active level — what Fit-to-screen does
+     * while a venue is in context, instead of pulling back to the whole plan.
+     * Returns false when no venue is active (a campus view with no context, or a
+     * plan without a venue model), leaving the plan-wide fit to the caller.
+     */
+    frameActiveVenue(): boolean;
+    /** Called when the campus camera movement settles; normal spatial context resumes. */
+    completeCampusView(request?: VenueCameraRequest): void;
+    /** No-context state: no venue has sufficient spatial confidence. */
+    clearFocus(): void;
+    /**
+     * Activates a level: venue-scoped Radio (only this venue's levels toggle),
+     * focus follows to the level's venue, the camera flies to the level, and
+     * `onFloorActivated` fires — the multi-venue counterpart of today's floor
+     * activation. No-op for layers outside any venue. `fly: false` keeps the
+     * camera untouched — the selection path uses it because the booth camera
+     * reaction owns that fly (KTD-7/KTD-8).
+     */
+    activateLayer(layer: Layer, { fly, establishDestination, cameraIntentId, userActivated, }?: {
+        fly?: boolean;
+        establishDestination?: boolean;
+        cameraIntentId?: number;
+        userActivated?: boolean;
+    }): Promise<void>;
+    private notifyVenueActivated;
+    private setEffectiveContext;
+    /**
+     * Frames a venue on one of its levels. By default the level's frame (see
+     * {@link levelFrame}) is the target, as on a single-venue plan's floor
+     * switch. `enableExperimentalVenueFraming` instead holds the venue footprint
+     * across levels — a venue's levels are one building.
+     */
+    private requestVenueCamera;
+    private nextLevelActivationRequest;
+    private resolveVenueLevel;
+    private notifyFloorActivated;
+}
+export {};
+//# sourceMappingURL=VenueStore.d.ts.map