JavaScript API Reference ​

class FloorPlan {
    constructor(options?: FloorPlanOptions);

    readonly ready: Promise<void>;
    readonly element: HTMLDivElement;
    readonly eventId: string;
    readonly dataUrl: string;
    readonly noOverlay: boolean;
    readonly offHistory: boolean;
    readonly allowConsent: boolean;
    readonly onInit: (fp: FloorPlan) => void;

    onBoothClick(e: FloorPlanBoothClickEvent): void;

    onBookmarkClick(e: FloorPlanBookmarkClickEvent): void;

    onCategoryClick(e: FloorPlanCategoryClickEvent): void;

    /**
     * @deprecated
     * The onFpConfigured method is deprecated. Use onInit instead.
     */
    onFpConfigured(): void;

    onDirection(e: FloorPlanDirectionEvent): void;

    onDetails(e: FloorPlanDetailsEvent): void;

    onExhibitorCustomButtonClick(e: FloorPlanCustomButtonEvent): void;

    onGetCoordsClick(e: FloorPlanGetCoordsEvent): void;

    onMarkerClick(e: FloorPlanMarkerEvent): void;

    selectBooth(nameOrExternalId: string): void;

    selectExhibitor(nameOrExternalId: string): void;

    selectRoute(from: RouteWaypoint, to: RouteWaypoint): void;

    /**
     * @note
     * Max 8 waypoints allowed (total: from + 8 waypoints + to = 10).
     */
    selectRoute(waypoints: RouteWaypoint[]): void;

    /**
     * @note
     * Experimental feature: functionality may be unstable or subject to change.
     */
    getOptimizedRoutes(waypoints: RouteWaypoint[]): RouteInfo[];

    selectCurrentPosition(point: CurrentPosition, focus: boolean, icon?: number): void;

    setBookmarks(bookmarks: { name?: string; externalId?: string; bookmarked: boolean }[]): void;

    setMarkers(markersData: MarkersData): void;

    updateLayerVisibility(layer: string, visible: boolean): void;

    getCenterCoordinates(): FloorPlanGetCoordsEvent;

    applyParameters(queryRaw: string): void;

    exhibitorsList(): FloorPlanExhibitor[];

    boothsList(): FloorPlanBooth[];

    categoriesList(): FloorPlanCategory[];

    selectCategory(nameOrSlug?: string): void;

    getVisibility(): Visibility;

    setVisibility(visibility: Visibility): void;

    findLocation(): void;

    zoomIn(): void;

    zoomOut(): void;

    switchView(): void;

    fitBounds(): void;

    getBoothRect(name: string): Rect;

    convertToGeo(x: number, y: number): [number, number] | never;

    unstable_destroy(): void;

    highlightExhibitors(externalIds: string[]): void;

    highlightBooths(externalIds: string[]): void;

    onCurrentPositionChanged(point: CurrentPosition): void;

    /**
     * Performs a fuzzy search.
     * @param term Search query
     * @returns Promise with [{ item, score }] (lower score = better match)
     */
    search(term: string): Promise<{ item: unknown; score: number }[]>;

    getFloors(): Floor[];

    onFloorActivated(floor: Floor): void;

    activateFloor(floorId: { name?: string; index?: number }): void;
}

const ExpoFP: {
    FloorPlan: FloorPlanOptions;
};

interface FloorPlanOptions {
    element?: HTMLDivElement;
    eventId?: string;
    previewMode?: boolean;
    dataUrl?: string;
    noOverlay?: boolean;
    offHistory?: boolean;
    allowConsent?: boolean;
    onBoothClick?: (e: FloorPlanBoothClickEvent) => void;
    onBookmarkClick?: (e: FloorPlanBookmarkClickEvent) => void;
    onCategoryClick?: (e: FloorPlanCategoryClickEvent) => void;
    /**
     * @deprecated
     * The onFpConfigured method is deprecated. Use onInit instead.
     */
    onFpConfigured?: () => void;
    onDirection?: (e: FloorPlanDirectionEvent) => void;
    onDetails?: (e: FloorPlanDetailsEvent) => void;
    onExhibitorCustomButtonClick?: (e: FloorPlanCustomButtonEvent) => void;
    onMarkerClick?: (e: FloorPlanMarkerEvent | undefined) => void;
    onGetCoordsClick?: (e: FloorPlanGetCoordsEvent) => void;
    onInit?: (fp: FloorPlan) => void;
    onCurrentPositionChanged?: (point: CurrentPosition) => void;
    onFloorActivated?: (floor: Floor) => void;
}

interface Layer {
    name: string;
    description: string;
}

interface FloorPlanBoothBase {
    id: number;
    externalId: string;
    name: string;
    layer: Layer;
}

interface FloorPlanBooth extends FloorPlanBoothBase {
    id: number;
    name: string;
    externalId: string;
    isSpecial: boolean;
    exhibitors: number[];
    layer: Layer;
    meta: Record<string, string>;
    description: string;
    entity: Entity;
}

interface FloorPlanBoothClickEvent {
    target: FloorPlanBoothBase;
}

interface Point {
    x: number;
    y: number;
}

interface FloorPlanBookmarkClickEvent {
    name: string;
    bookmarked: boolean;
    externalId: string;
}

interface FloorPlanVisitedClickEvent {
    name: string;
    visited: boolean;
    externalId: string;
}

interface FloorPlanCategoryClickEvent extends FloorPlanCategory {}

interface FloorPlanDirectionEvent {
    from: FloorPlanBoothBase;
    to: FloorPlanBoothBase;
    lines: { p0: Point; p1: Point }[];
    distance: string;
    units: string;
    time: number; // in seconds
}

interface FloorPlanDetailsEvent {
    type: "booth" | "exhibitor" | "route" | "category";
    id: string;
    name: string;
    externalId: string;
    /// Value depends on the type of event
    /// if the type is 'booth' this value contains the same value as 'name'
    /// if the type is 'exhibitor' this value contains the  assigned booths names (the first booth name takes from the onBoothClick event)
    /// if the the type is 'route' this value contains "from" and "to" booths name.
    boothsNames: string[];
}

interface FloorPlanCustomButtonEvent {
    externalId: string;
    buttonNumber: number;
    buttonUrl: string;
    preventDefault: () => void;
}

interface FloorPlanGetCoordsEvent extends Point {
    z: string | null;
}

interface FloorPlanMarkerEvent extends Point {
    id: string;
    z?: number | string;
}

interface FloorPlanExhibitor {
    id: number;
    name: string;
    externalId: string;
    booths: number[];
    entity: Entity;
    slug: string;
}

interface FloorPlanCategory {
    id: number;
    name: string;
    exhibitors: number[];
    entity: Entity;
    slug: string;
}

interface ExpoData {
    booths: FloorPlanBooth[];
    exhibitors: FloorPlanExhibitor[];
    categories: FloorPlanCategory[];
}

interface CurrentPosition {
    x: number;
    y: number;
    z?: string | number;
}

interface Visibility {
    controls?: boolean;
    levels?: boolean;
    header?: boolean;
    overlay?: boolean;
}

interface Rect {
    x1: number;
    x2: number;
    y1: number;
    y2: number;
    h: number;
    w: number;
    cx: number;
    cy: number;
    contains(r: Rect): boolean;
    intersects(r: Rect): boolean;
    getIntersection(r: Rect): Rect;
    getRotated90(): Rect;
    normalize(width: number, height: number): Rect;
    withPadding(x: number, y: number): Rect;
    scale(s: number): Rect;
    getArea(): number;
    clone(): Rect;
    translate(dx: number, dy: number): Rect;
    equals(r: Rect): boolean;
    toString(): string;
    containsPoint(x: number, y: number): boolean;
}

type RouteWaypoint = string | CurrentPosition;

interface RouteInfo {
    waypoints: RouteWaypoint[];
}

type FloorPlanIcon =
    | "departure"
    | "destination"
    | "direction"
    | "transition"
    | "transition_up"
    | "transition_down"
    | "kiosk-arrow"
    | "kiosk-label";

interface LayerPoint extends Point {
    layer: string;
}

interface Entity {
    type: "booth" | "category" | "exhibitor" | "schedule" | "language" | "heatmap-yah" | "route-cut-in";
    variant?: "regular" | "special";
}

interface FloorPlanSchedule {
    id: number;
    externalId: string;
    boothId: number;
    exhibitorId: number;
    name: string;
    description: string;
    startDate: string;
    endDate: string;
    link: string;
    entity: Entity;
    isEnded: boolean;
}

interface FloorPlanLanguage {
    id: number;
    name: string;
    entity: Entity;
    selected: boolean;
}

interface FloorPlanHeatmapYah {
    id: string;
    name: string;
    viewCount: number;
    x: number;
    y: number;
    z: number | string;
    entity: Entity;
}

type FloorPlanEntity =
    | FloorPlanBooth
    | FloorPlanCategory
    | FloorPlanExhibitor
    | FloorPlanSchedule
    | FloorPlanLanguage
    | FloorPlanHeatmapYah;

interface Floor {
    name: string;
    shortName: string;
    description: string;
    active: boolean;
    disabled: boolean;
    index: number;
}