@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/services/url-sync.d.ts

@@ -0,0 +1,40 @@
+/** The visited-URL trail (pathname + search per entry) — analytics referrer feed. */
+export declare function getLocationHistory(): string[];
+/** The app's current search (`''` or `'?…'`) — the platform's params filtered out. */
+export declare function currentSearch(): string;
+export declare function pushQuery(search: string): void;
+/**
+ * Returns whether the write actually happened — `false` under frozen writes,
+ * for callers whose follow-up only makes sense after a real URL change (the
+ * debug-mode scrub reloads only on `true`, else `?debug=` would reload forever).
+ */
+export declare function replaceQuery(search: string): boolean;
+/**
+ * Stop writing to the history for the rest of the plan (heatmap mode). Reached
+ * in every mode, `ignoreQuery` included, so it arms the plan's reset itself
+ * rather than relying on `initUrlSync` having done so; the reset is idempotent.
+ */
+export declare function disableUrlWrites(): void;
+/**
+ * Start listening to the browser history. `onNavigate` fires on every POP
+ * (browser back/forward) so the dispatch side can replay the URL into state.
+ */
+export declare function initUrlSync(options: {
+    offHistory: boolean;
+    onNavigate: () => void;
+}): void;
+export declare function destroyUrlSync(): void;
+/**
+ * The UI back button — a real browser back. The POP it produces flows through
+ * the listener above, so the state replay (`onNavigate`) and the trail
+ * recording happen exactly as for the browser's own back button. Note the
+ * replay is therefore asynchronous (it lands with the POP event), and on a
+ * history with no in-app pushes yet the browser may leave the page — both
+ * identical to pressing the browser's back button.
+ *
+ * Writes are frozen until that POP lands (see `backPending`); the timer lifts
+ * the freeze when no POP will ever come — a back with nowhere to go (empty
+ * back stack, e.g. a deep link opened in a fresh tab) is a silent no-op.
+ */
+export declare function goBack(): void;
+//# sourceMappingURL=url-sync.d.ts.map

package/dist/esm/services/url-sync.js

@@ -0,0 +1,185 @@
+/**
+ * The single URL writer — the only module that touches the browser history.
+ * Everything that wants the address bar changed (the state→URL autorun, the
+ * filter manager, debug-mode scrubbing) goes through `pushQuery`/`replaceQuery`
+ * here; nothing else in the SDK may call `history.pushState`/`replaceState`.
+ *
+ * Also keeps `routeHistory`, the in-memory trail of visited URLs — analytics
+ * only: `getLocationHistory()` feeds the referrer of `track-event`. The UI
+ * back button (`goBack`) no longer walks that trail: it is a real browser
+ * back, whose POP replays the URL through `onNavigate` exactly like the
+ * browser's own back/forward (retirement plan §4.10, history semantics 3.2b).
+ *
+ * Store-free by design: the dispatch side (`url-dispatch.ts`) injects its
+ * navigation callback via `initUrlSync`, so this file stays a plain history
+ * adapter with no knowledge of MobX or the stores.
+ */
+import { splitPlatformParams } from '@expofp/config';
+import { createBrowserHistory } from 'history';
+import { registerPlanDisposer } from '../plan-lifecycle.js';
+import { eventScopedValue } from '../tools/event-scoped-cache.js';
+import logger from '../tools/logger';
+const history = createBrowserHistory();
+/**
+ * The page's path, read on every write rather than captured once: a host with
+ * client-side navigation moves the plan to a new path between plans, and a
+ * captured one would write the URL of the event the visitor already left
+ * (ADR-0011).
+ */
+function pathname() {
+    return window.location.pathname;
+}
+/**
+ * The visited-URL trail (pathname + search per entry) — one plan's worth: the
+ * referrer it feeds describes the event being viewed, and the previous event's
+ * URLs are not part of it.
+ */
+const routeHistory = eventScopedValue(() => []);
+/**
+ * The platform's routing params from the boot URL (`?expo=…` on sha-delivery
+ * preview URLs — `splitPlatformParams`), captured by `initUrlSync`. They are
+ * the platform's, not the floor plan's: `currentSearch` hides them from
+ * everything the app reads back, and `historyUrl` re-attaches them verbatim
+ * to every URL written — a rewrite must not eat the param that makes the
+ * preview URL reloadable and shareable.
+ */
+let platformSearch = '';
+/**
+ * When true, nothing is written to the history and navigation is not recorded.
+ * Set permanently by `offHistory` embeds and by heatmap mode (which freezes the
+ * URL for its whole session — a legacy contract).
+ */
+let writesDisabled = false;
+/**
+ * True between a `goBack()` call and its POP landing. The browser traversal is
+ * asynchronous, so reactions to the state change that triggered the back (the
+ * state→URL autorun above all) would otherwise write a fresh entry FIRST — an
+ * orphan the queued traversal then walks back onto, undoing the back itself.
+ */
+let backPending = false;
+let backPendingTimer = 0;
+let onNavigate = () => undefined;
+let unlisten;
+/** The visited-URL trail (pathname + search per entry) — analytics referrer feed. */
+export function getLocationHistory() {
+    return routeHistory();
+}
+function historyUrl(search) {
+    if (!platformSearch)
+        return pathname() + search;
+    // normalize first: a caller may hand back a search that still carries the
+    // platform half (handleDebugMode rebuilds it from window.location) — the
+    // captured boot value is attached exactly once either way
+    const app = splitPlatformParams(search).search;
+    const base = app === '?' ? '' : app;
+    return pathname() + (base ? `${base}&${platformSearch}` : `?${platformSearch}`);
+}
+/** The app's current search (`''` or `'?…'`) — the platform's params filtered out. */
+export function currentSearch() {
+    return splitPlatformParams(history.location.search).search;
+}
+export function pushQuery(search) {
+    if (!writesDisabled && !backPending) {
+        history.push(historyUrl(search));
+    }
+}
+/**
+ * Returns whether the write actually happened — `false` under frozen writes,
+ * for callers whose follow-up only makes sense after a real URL change (the
+ * debug-mode scrub reloads only on `true`, else `?debug=` would reload forever).
+ */
+export function replaceQuery(search) {
+    if (writesDisabled || backPending) {
+        return false;
+    }
+    history.replace(historyUrl(search));
+    return true;
+}
+/**
+ * Stop writing to the history for the rest of the plan (heatmap mode). Reached
+ * in every mode, `ignoreQuery` included, so it arms the plan's reset itself
+ * rather than relying on `initUrlSync` having done so; the reset is idempotent.
+ */
+export function disableUrlWrites() {
+    registerPlanDisposer(destroyUrlSync);
+    writesDisabled = true;
+}
+/**
+ * Start listening to the browser history. `onNavigate` fires on every POP
+ * (browser back/forward) so the dispatch side can replay the URL into state.
+ */
+export function initUrlSync(options) {
+    // `||=` — a one-way ratchet: heatmap mode freezes the writes from the
+    // declarative-config application (`disableUrlWrites`), which runs before
+    // this init, and must stay frozen
+    registerPlanDisposer(destroyUrlSync);
+    writesDisabled ||= options.offHistory;
+    onNavigate = options.onNavigate;
+    platformSearch = splitPlatformParams(history.location.search).platform;
+    // Seeded unconditionally. The trail starts empty for each plan, and the next
+    // `load()` in the same document almost always starts on a URL that already
+    // carries a query — so the old `!history.location.search` guard left the
+    // second plan with no trail at all, and an empty `referrer` on every event
+    // until the visitor had navigated twice.
+    if (!writesDisabled) {
+        routeHistory().push(pathname() + history.location.search);
+    }
+    unlisten = history.listen((location, action) => {
+        // the traversal (or any competing navigation) landed — writes are safe again
+        clearBackPending();
+        if (writesDisabled)
+            return;
+        // the URL as it really is — platform params included
+        const trail = routeHistory();
+        const url = pathname() + location.search;
+        // the seed above can name the same URL the first navigation reports, and a
+        // duplicate entry would make an event its own referrer
+        if (trail[trail.length - 1] !== url)
+            trail.push(url);
+        logger.log('history', action, location);
+        if (action === 'POP') {
+            onNavigate();
+        }
+    });
+}
+export function destroyUrlSync() {
+    // the freeze is per floor-plan session — a destroyed instance ends it, and
+    // the next `load()` in this document must ratchet up from a clean state
+    writesDisabled = false;
+    platformSearch = '';
+    // the callback closes over the dispatch side of the plan being destroyed:
+    // left in place, a POP landing in the dead window would replay the URL into
+    // a store graph nobody owns any more
+    onNavigate = () => undefined;
+    // the trail feeds the `referrer` of every stat, so a leftover entry would
+    // credit the next plan's first events to a URL from the previous one — and on
+    // a long-lived kiosk it would grow without bound. The next `load()` starts a
+    // fresh trail anyway; emptying it here closes the window in between, where a
+    // late write would still find the dead plan's URLs.
+    routeHistory().length = 0;
+    clearBackPending();
+    unlisten?.();
+    unlisten = undefined;
+}
+function clearBackPending() {
+    backPending = false;
+    window.clearTimeout(backPendingTimer);
+}
+/**
+ * The UI back button — a real browser back. The POP it produces flows through
+ * the listener above, so the state replay (`onNavigate`) and the trail
+ * recording happen exactly as for the browser's own back button. Note the
+ * replay is therefore asynchronous (it lands with the POP event), and on a
+ * history with no in-app pushes yet the browser may leave the page — both
+ * identical to pressing the browser's back button.
+ *
+ * Writes are frozen until that POP lands (see `backPending`); the timer lifts
+ * the freeze when no POP will ever come — a back with nowhere to go (empty
+ * back stack, e.g. a deep link opened in a fresh tab) is a silent no-op.
+ */
+export function goBack() {
+    backPending = true;
+    window.clearTimeout(backPendingTimer);
+    backPendingTimer = window.setTimeout(clearBackPending, 1000);
+    history.goBack();
+}

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

@@ -0,0 +1,17 @@
+import type RootStore from './RootStore';
+import { type FilterItem, type FilterState, type FilterStore } from './types';
+export default abstract class BaseFilterStore implements FilterStore {
+    protected readonly rootStore: RootStore;
+    state: FilterState;
+    get publicRootStore(): RootStore;
+    constructor(rootStore: RootStore);
+    openFilter(): void;
+    closeFilter(): void;
+    applyFilter(): void;
+    resetFilter(): void;
+    clearPendingItems(): void;
+    setPendingItems(items: FilterItem[]): void;
+    protected abstract updateUIState(): void;
+    abstract getFilteredItems(): any[];
+}
+//# sourceMappingURL=BaseFilterStore.d.ts.map

package/dist/esm/store/BaseFilterStore.js

@@ -0,0 +1,63 @@
+import { __decorate } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// @ts-nocheck
+import { action, observable } from 'mobx';
+export default class BaseFilterStore {
+    get publicRootStore() {
+        return this.rootStore;
+    }
+    constructor(rootStore) {
+        this.state = {
+            isOpen: false,
+            selectedItems: [],
+            pendingItems: [],
+        };
+        this.rootStore = rootStore;
+    }
+    openFilter() {
+        this.state.isOpen = true;
+        this.state.pendingItems = [...this.state.selectedItems];
+    }
+    closeFilter() {
+        this.state.isOpen = false;
+        this.state.pendingItems = [];
+        if (this.rootStore.urlFilterManager && this.rootStore.urlFilterManager.isInitialized) {
+            this.rootStore.urlFilterManager.clearAllFilters();
+        }
+    }
+    applyFilter() {
+        this.state.selectedItems = [...this.state.pendingItems];
+        this.closeFilter();
+        this.updateUIState();
+    }
+    resetFilter() {
+        this.state.pendingItems = [];
+    }
+    clearPendingItems() {
+        this.state.pendingItems = [];
+    }
+    setPendingItems(items) {
+        this.state.pendingItems = items;
+    }
+}
+__decorate([
+    observable
+], BaseFilterStore.prototype, "state", void 0);
+__decorate([
+    action
+], BaseFilterStore.prototype, "openFilter", null);
+__decorate([
+    action
+], BaseFilterStore.prototype, "closeFilter", null);
+__decorate([
+    action
+], BaseFilterStore.prototype, "applyFilter", null);
+__decorate([
+    action
+], BaseFilterStore.prototype, "resetFilter", null);
+__decorate([
+    action
+], BaseFilterStore.prototype, "clearPendingItems", null);
+__decorate([
+    action
+], BaseFilterStore.prototype, "setPendingItems", null);

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

@@ -0,0 +1,9 @@
+import type RootStore from './RootStore';
+export default class BookmarksStore {
+    private readonly rootStore;
+    constructor(rootStore: RootStore);
+    get bookmarkedBooths(): import("./BoothStore").Booth[];
+    get total(): number;
+    get hasRoutableBookmarks(): boolean;
+}
+//# sourceMappingURL=BookmarksStore.d.ts.map

package/dist/esm/store/BookmarksStore.js

@@ -0,0 +1,28 @@
+import { __decorate } from "tslib";
+import { computed } from 'mobx';
+export default class BookmarksStore {
+    constructor(rootStore) {
+        this.rootStore = rootStore;
+    }
+    get bookmarkedBooths() {
+        return this.rootStore.boothStore.booths.filter((booth) => booth.exhibitors.length === 0 && booth.bookmarkedDirectly);
+    }
+    get total() {
+        return (this.rootStore.exhibitorStore.bookmarked.length +
+            this.rootStore.eventStore.bookmarked.length +
+            this.rootStore.speakerStore.bookmarked.length +
+            this.bookmarkedBooths.length);
+    }
+    get hasRoutableBookmarks() {
+        return this.rootStore.exhibitorStore.bookmarked.length > 0 || this.bookmarkedBooths.length > 0;
+    }
+}
+__decorate([
+    computed
+], BookmarksStore.prototype, "bookmarkedBooths", null);
+__decorate([
+    computed
+], BookmarksStore.prototype, "total", null);
+__decorate([
+    computed
+], BookmarksStore.prototype, "hasRoutableBookmarks", null);

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

@@ -0,0 +1,105 @@
+import { Box } from '@expofp/geometry';
+import { ImageDef } from '@expofp/renderer';
+import { RawPoiType, RawRegularBooth } from '@expofp/schema';
+import { PathInfo, ShapeBgDef } from '../types/drawing.types';
+import { EventItem } from './EventStore';
+import { Exhibitor } from './ExhibitorStore';
+import { Layer } from './LayerStore';
+import RootStore from './RootStore';
+export default class BoothStore {
+    readonly rootStore: RootStore;
+    booths: Booth[];
+    highlightedByExternalIds: never[];
+    get boothById(): Map<number, Booth>;
+    get boothByExternalId(): Map<string, Booth>;
+    get boothByName(): Map<string, Booth>;
+    get boothBySlug(): Map<string, Booth>;
+    get borderWidth(): number;
+    constructor(rootStore: RootStore);
+    get bookmarked(): Booth[];
+    getNearestBooth(point: Point): Booth;
+    getBoothAtPoint(point: Point): Booth;
+    findBooth(str: string): Booth | undefined;
+    replaceBookmarked(ids: number[]): void;
+}
+export declare abstract class BoothBase {
+    protected readonly store: BoothStore;
+    readonly id: number;
+    readonly name: string;
+    readonly externalId: string;
+    readonly title: string;
+    /**
+     * Unrotated, axis-aligned footprint of the booth (a geometry {@link Box}).
+     * The booth's orientation is stored SEPARATELY in {@link rotate}; the two are
+     * intentionally kept apart. The dominant access pattern is the unrotated
+     * footprint (center, width/height, bounds-union, axis-aligned hit-test), so
+     * `rect` stays an AABB and the rotation is only combined with it at the few
+     * rotation-sensitive render/geometry sites (a rotated `Rect` is built there
+     * from `rect` + `rotate` on demand).
+     */
+    readonly rect: Box;
+    readonly borderWidth: number;
+    readonly borderColor: string;
+    noLabels: boolean;
+    /** Booth orientation in radians, positive = clockwise. Applied to {@link rect}
+     *  only at the rotation-sensitive render/geometry sites; the footprint
+     *  itself ({@link rect}) is axis-aligned and never carries this rotation. */
+    readonly rotate: number;
+    /**
+     * Height of the booth's top surface above the floor, from the `data-elev` attribute on its
+     * `<rect>`; `0` when the attribute is absent. Held apart from {@link rect} for the same reason as
+     * {@link rotate} — a `Box` is pure 2D with no elevation — and combined into a geometry `Rect` as
+     * its fourth argument wherever something is drawn *on* the booth: its fill, labels, badges,
+     * bookmarks, borders and logo. That is what places those on the roof rather than on the floor.
+     *
+     * Stored as authored, with no sign flip: the renderer's scene mirrors z, so plan space reads
+     * positive-up and a booth 50 units tall simply has `elevation: 50`.
+     */
+    readonly elevation: number;
+    readonly paths: PathInfo[];
+    readonly pathsWithRect: boolean;
+    readonly slug: string;
+    readonly error: boolean;
+    readonly description: string;
+    readonly exhibitors: Exhibitor[];
+    readonly labelColor: string;
+    readonly schedule: EventItem[];
+    readonly poiTypeId: number;
+    readonly poiType: RawPoiType;
+    readonly poiIcon: string;
+    readonly meta: Record<string, string>;
+    layer: Layer;
+    /** The layer the booth is drawn in — `layer` is its top-level ancestor. Unset
+     *  until the layer is configured, and on a layers-disabled plan. */
+    innermostLayer: Layer | undefined;
+    bookmarkedDirectly: boolean;
+    get bookmarked(): boolean;
+    private get uiState();
+    get fullName(): string;
+    get visible(): boolean;
+    get hover(): boolean;
+    get selected(): boolean;
+    get skipDim(): boolean;
+}
+export type Booth = RegularBooth | SpecialBooth;
+export declare class RegularBooth extends BoothBase implements Omit<RawRegularBooth, 'exhibitors'> {
+    readonly buyUrl: string;
+    readonly reserveUrl: string;
+    readonly type: string;
+    readonly status: 'onhold' | 'reserved';
+    readonly price: string;
+    readonly entity: Entity;
+    readonly size: string;
+    readonly availColor: string;
+    readonly soldColor: string;
+    readonly holdColor: string;
+    readonly onHold: boolean;
+    readonly reserved: boolean;
+    shapes: (ShapeBgDef | ImageDef)[];
+}
+export declare class SpecialBooth extends BoothBase {
+    readonly color: string;
+    shapes: (ShapeBgDef | ImageDef)[];
+    readonly entity: Entity;
+}
+//# sourceMappingURL=BoothStore.d.ts.map

package/dist/esm/store/BoothStore.js

@@ -0,0 +1,194 @@
+import { __decorate } from "tslib";
+/* eslint-disable no-var, @typescript-eslint/consistent-type-imports, @typescript-eslint/no-inferrable-types */
+// @ts-nocheck
+import { pointDistance } from '@expofp/geometry';
+import { action, computed, observable } from 'mobx';
+import settings from '../tools/settings';
+import { uiState } from './index';
+// interface BoothState {
+//     hover: boolean;
+//     selected: boolean;
+//     skipDim: boolean;
+//     error: boolean;
+//     empty: boolean;
+//     onhold: boolean;
+//     bookmarked: boolean;
+// }
+export default class BoothStore {
+    get boothById() {
+        return new Map(this.booths.map((c) => [c.id, c]));
+    }
+    get boothByExternalId() {
+        return new Map(this.booths.map((b) => [b.externalId, b]));
+    }
+    get boothByName() {
+        return new Map(this.booths.map((b) => [b.name.toLowerCase(), b]));
+    }
+    get boothBySlug() {
+        return new Map(this.booths.map((b) => [b.slug, b]));
+    }
+    get borderWidth() {
+        if (settings.boothBorderWidth)
+            return settings.boothBorderWidth;
+        if (settings.EXPO === 'groomexpo')
+            return 0.4;
+        const ar = this.booths.filter((b) => b.rect).map((x) => x.rect.size.width + x.rect.size.height);
+        return ar.reduce((a, b) => a + b, 0) / ar.length / 80;
+    }
+    constructor(rootStore) {
+        this.booths = [];
+        this.highlightedByExternalIds = [];
+        this.rootStore = rootStore;
+    }
+    get bookmarked() {
+        return this.booths.filter((x) => x.bookmarkedDirectly);
+    }
+    getNearestBooth(point) {
+        var booth = null;
+        // NOTE: this method is currently UNUSED (no in-tree callers). It sorts by
+        // distance to each booth's footprint CENTRE. The legacy implementation
+        // measured distance to the first edge-intersection of the ray point→center
+        // against the AABB; for booths of DIFFERENT sizes that can rank booths
+        // differently (see the divergence pin in store-geometry.spec.ts), so this
+        // is a deliberate simplification, not an exact port — acceptable only
+        // because the method is unused (the live nearest-booth path,
+        // RouteStore.getNearestBooth, already used centre distance). The footprint
+        // is axis-aligned — booth.rotate is intentionally NOT applied.
+        const booths = this.booths.map((b) => {
+            return {
+                lineLength: pointDistance(point, b.rect.center),
+                name: b.name,
+            };
+        });
+        const nearest = booths.sort((b1, b2) => b1.lineLength - b2.lineLength)[0];
+        booth = this.booths.find((b) => b.name === nearest.name);
+        return booth;
+    }
+    getBoothAtPoint(point) {
+        // Axis-aligned hit-test against the booth footprint — booth.rotate is
+        // intentionally NOT applied (a point inside the AABB but outside the
+        // rotated quad counts as a hit). boxContainsPoint is boundary-inclusive.
+        return this.booths.find((b) => b.rect.containsPoint(point));
+    }
+    findBooth(str) {
+        return (this.boothByExternalId.get(str) ||
+            this.boothByName.get(str.toLowerCase()) ||
+            this.boothBySlug.get(str));
+    }
+    replaceBookmarked(ids) {
+        const ar = (ids || []).map((x) => this.boothById.get(x)).filter((x) => x);
+        const set = new Set(ar);
+        const toRemove = this.bookmarked.filter((e) => !set.has(e));
+        for (const e of toRemove) {
+            e.bookmarkedDirectly = false;
+        }
+        for (const e of ar) {
+            e.bookmarkedDirectly = true;
+        }
+    }
+}
+__decorate([
+    observable
+], BoothStore.prototype, "booths", void 0);
+__decorate([
+    observable
+], BoothStore.prototype, "highlightedByExternalIds", void 0);
+__decorate([
+    computed({ keepAlive: true })
+], BoothStore.prototype, "boothById", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothStore.prototype, "boothByExternalId", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothStore.prototype, "boothByName", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothStore.prototype, "boothBySlug", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothStore.prototype, "borderWidth", null);
+__decorate([
+    computed
+], BoothStore.prototype, "bookmarked", null);
+__decorate([
+    action
+], BoothStore.prototype, "replaceBookmarked", null);
+export class BoothBase {
+    constructor() {
+        this.bookmarkedDirectly = false;
+    }
+    get bookmarked() {
+        if (uiState.disableBookmarked)
+            return false;
+        if (this.schedule?.some((e) => e.bookmarked))
+            return true;
+        if (this.exhibitors.length > 0) {
+            return !!this.exhibitors.find((x) => x.bookmarked);
+        }
+        return this.bookmarkedDirectly;
+    }
+    get uiState() {
+        return this.store.rootStore.uiState;
+    }
+    get fullName() {
+        const meta = this.meta
+            ? Object.entries(this.meta)
+                .filter(([key]) => !key.startsWith('_'))
+                .map(([key, value]) => `${key} ${value}`)
+                .join(' ')
+            : '';
+        return `${this.name} ${meta}`.replace(/\s+/g, ' ').trim();
+    }
+    get visible() {
+        return this.layer?.visible ?? true;
+    }
+    get hover() {
+        return this.uiState.hoveredBooths.has(this);
+    }
+    get selected() {
+        return this.uiState.selectedBooths.has(this);
+    }
+    get skipDim() {
+        return this.uiState.highlightedBooths.has(this.id.toString());
+    }
+}
+__decorate([
+    observable
+], BoothBase.prototype, "layer", void 0);
+__decorate([
+    observable
+], BoothBase.prototype, "bookmarkedDirectly", void 0);
+__decorate([
+    computed({ keepAlive: true })
+], BoothBase.prototype, "bookmarked", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothBase.prototype, "uiState", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothBase.prototype, "fullName", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothBase.prototype, "visible", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothBase.prototype, "hover", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothBase.prototype, "selected", null);
+__decorate([
+    computed({ keepAlive: true })
+], BoothBase.prototype, "skipDim", null);
+export class RegularBooth extends BoothBase {
+    constructor() {
+        super(...arguments);
+        this.entity = { type: 'booth', variant: 'regular' };
+    }
+}
+export class SpecialBooth extends BoothBase {
+    constructor() {
+        super(...arguments);
+        this.entity = { type: 'booth', variant: 'special' };
+    }
+}

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

@@ -0,0 +1,13 @@
+import BaseFilterStore from './BaseFilterStore';
+import { type Exhibitor } from './ExhibitorStore';
+import { type FilterItem } from './types';
+export default class CategoryFilterStore extends BaseFilterStore {
+    get filteredExhibitors(): Exhibitor[];
+    get filteredBooths(): import("./BoothStore").Booth[];
+    get publicRootStore(): import("./RootStore").default;
+    updateUIState(): void;
+    getFilteredItems(): FilterItem[];
+    getMatchingExhibitorsCount(): number;
+    resetFilter(): void;
+}
+//# sourceMappingURL=CategoryFilterStore.d.ts.map