@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/store/CategoryFilterStore.js

@@ -0,0 +1,60 @@
+import { __decorate } from "tslib";
+// @ts-nocheck
+import { action, computed } from 'mobx';
+import BaseFilterStore from './BaseFilterStore';
+export default class CategoryFilterStore extends BaseFilterStore {
+    get filteredExhibitors() {
+        if (this.state.selectedItems.length === 0) {
+            return this.rootStore.exhibitorStore.exhibitors;
+        }
+        return this.rootStore.exhibitorStore.exhibitors.filter((exhibitor) => this.state.selectedItems.some((category) => exhibitor.categories.some((c) => c.id === category.id)));
+    }
+    get filteredBooths() {
+        return this.rootStore.boothStore.booths.filter((booth) => this.filteredExhibitors.some((exhibitor) => exhibitor.id === booth.exhibitors[0]?.id));
+    }
+    get publicRootStore() {
+        return this.rootStore;
+    }
+    updateUIState() {
+        this.rootStore.uiState.menu = false;
+        const selectedCategories = this.state.selectedItems
+            .map((item) => this.rootStore.categoryStore.categories.find((cat) => cat.id === item.id))
+            .filter(Boolean);
+        this.rootStore.uiState.selectedCategoryFilters = selectedCategories;
+        this.rootStore.uiState.categoryFilterOpen = true;
+        this.rootStore.searchStore.setFocused(true);
+        this.rootStore.moveToList();
+        this.rootStore.showMap();
+        const categoryNames = selectedCategories.map((cat) => cat.name);
+        this.rootStore.urlFilterManager.setCategories(categoryNames);
+    }
+    getFilteredItems() {
+        return this.rootStore.exhibitorStore.exhibitors.map((exhibitor) => ({
+            id: exhibitor.id,
+            name: exhibitor.name,
+        }));
+    }
+    getMatchingExhibitorsCount() {
+        if (this.state.pendingItems.length === 0) {
+            return this.rootStore.exhibitorStore.exhibitors.length;
+        }
+        return this.rootStore.exhibitorStore.exhibitors.filter((exhibitor) => exhibitor.categories.some((category) => this.state.pendingItems.some((pendingItem) => pendingItem.id === category.id))).length;
+    }
+    resetFilter() {
+        this.state.pendingItems = [];
+        this.state.selectedItems = [];
+        this.rootStore.uiState.selectedCategoryFilters = [];
+        this.rootStore.uiState.categoryFilterOpen = false;
+        this.rootStore.uiState.list = { type: 'search', text: '', focused: false };
+        this.rootStore.urlFilterManager.setCategories([]);
+    }
+}
+__decorate([
+    computed
+], CategoryFilterStore.prototype, "filteredExhibitors", null);
+__decorate([
+    computed
+], CategoryFilterStore.prototype, "filteredBooths", null);
+__decorate([
+    action
+], CategoryFilterStore.prototype, "resetFilter", null);

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

@@ -0,0 +1,21 @@
+import { Exhibitor } from './ExhibitorStore';
+import RootStore from './RootStore';
+export default class CategoryStore {
+    private readonly rootStore;
+    readonly categories: Category[];
+    get categoryById(): Map<number, Category>;
+    get seminarsCategory(): Category | undefined;
+    constructor(rootStore: RootStore);
+}
+export declare class Category {
+    private readonly store;
+    readonly id: number;
+    readonly name: string;
+    readonly slug: string;
+    readonly sponsorship: boolean;
+    readonly exhibitors: Exhibitor[];
+    readonly entity: {
+        readonly type: 'category';
+    };
+}
+//# sourceMappingURL=CategoryStore.d.ts.map

package/dist/esm/store/CategoryStore.js

@@ -0,0 +1,30 @@
+import { __decorate } from "tslib";
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+// import { observable } from 'mobx';
+import { computed } from 'mobx';
+export default class CategoryStore {
+    get categoryById() {
+        return new Map(this.categories.map((c) => [c.id, c]));
+    }
+    get seminarsCategory() {
+        return this.categories.find((c) => c.slug === 'seminars');
+    }
+    constructor(rootStore) {
+        this.categories = [];
+        this.rootStore = rootStore;
+    }
+}
+__decorate([
+    computed({ keepAlive: true })
+], CategoryStore.prototype, "categoryById", null);
+__decorate([
+    computed
+], CategoryStore.prototype, "seminarsCategory", null);
+export class Category {
+    constructor() {
+        this.entity = { type: 'category' };
+        // populated
+        // readonly exhibitors: Exhibitor[];
+    }
+}

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

@@ -0,0 +1,56 @@
+import RootStore from './RootStore';
+import { Speaker } from './SpeakerStore';
+export interface Track {
+    id: number;
+    externalId: string;
+    name: string;
+    color: string;
+}
+export default class EventStore {
+    private readonly rootStore;
+    readonly eventItems: EventItem[];
+    constructor(rootStore: RootStore);
+    findByNameOrSlug(str: string): EventItem | undefined;
+    get bookmarked(): EventItem[];
+    get visited(): EventItem[];
+    get tracks(): Track[];
+    getEventsByTrack(trackId: number): EventItem[];
+    getEventsBySpeaker(speakerId: number): EventItem[];
+    get venues(): any[];
+    getEventsByVenue(venueId: number): EventItem[];
+    get pastEvents(): EventItem[];
+    get futureEvents(): EventItem[];
+    get liveEvents(): EventItem[];
+    get todayEvents(): EventItem[];
+    get tomorrowEvents(): EventItem[];
+    replaceBookmarked(ids: number[]): void;
+    replaceVisited(ids: number[]): void;
+}
+export declare class EventItem {
+    readonly id: number;
+    readonly externalId: string;
+    readonly boothId: number;
+    readonly name: string;
+    readonly description: string;
+    readonly startDate: string;
+    readonly endDate: string;
+    readonly logoFile?: string | undefined;
+    readonly speakers: Speaker[];
+    readonly tracks: Track[];
+    readonly entity: {
+        readonly type: 'event';
+    };
+    readonly slug: string;
+    bookmarked: boolean;
+    visited: boolean;
+    constructor(id: number, externalId: string, boothId: number, name: string, description: string, startDate: string, endDate: string, logoFile?: string | undefined, speakers?: Speaker[], tracks?: Track[], entity?: {
+        readonly type: 'event';
+    });
+    get isEnded(): boolean;
+    get hasSpeakers(): boolean;
+    get hasTracks(): boolean;
+    get primaryTrack(): Track | null;
+    get speakerNames(): string;
+    get trackNames(): string;
+}
+//# sourceMappingURL=EventStore.d.ts.map

package/dist/esm/store/EventStore.js

@@ -0,0 +1,188 @@
+import { __decorate } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-imports, @typescript-eslint/no-inferrable-types */
+// @ts-nocheck
+import { action, computed, observable } from 'mobx';
+import { generateUniqueSlug } from '../tools/slug';
+export default class EventStore {
+    constructor(rootStore) {
+        this.eventItems = [];
+        this.rootStore = rootStore;
+    }
+    findByNameOrSlug(str) {
+        return this.eventItems.find((e) => e.name === str || e.slug === str || e.externalId === str);
+    }
+    get bookmarked() {
+        return this.eventItems.filter((x) => x.bookmarked);
+    }
+    get visited() {
+        return this.eventItems.filter((x) => x.visited);
+    }
+    get tracks() {
+        const trackMap = new Map();
+        this.eventItems.forEach((event) => {
+            event.tracks.forEach((track) => {
+                trackMap.set(track.id, track);
+            });
+        });
+        return Array.from(trackMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    getEventsByTrack(trackId) {
+        return this.eventItems.filter((event) => event.tracks.some((track) => track.id === trackId));
+    }
+    getEventsBySpeaker(speakerId) {
+        return this.eventItems.filter((event) => event.speakers.some((speaker) => speaker.id === speakerId));
+    }
+    get venues() {
+        const venueMap = new Map();
+        this.eventItems.forEach((event) => {
+            if (event.boothId) {
+                const booth = this.rootStore.boothStore.booths.find((b) => b.id === event.boothId);
+                if (booth) {
+                    venueMap.set(booth.id, booth);
+                }
+            }
+        });
+        return Array.from(venueMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    getEventsByVenue(venueId) {
+        return this.eventItems.filter((event) => event.boothId === venueId);
+    }
+    get pastEvents() {
+        const now = new Date();
+        return this.eventItems.filter((event) => {
+            const eventEnd = new Date(event.endDate);
+            return eventEnd < now;
+        });
+    }
+    get futureEvents() {
+        const now = new Date();
+        return this.eventItems.filter((event) => {
+            const eventStart = new Date(event.startDate);
+            return eventStart > now;
+        });
+    }
+    get liveEvents() {
+        const now = new Date();
+        return this.eventItems.filter((event) => {
+            const start = new Date(event.startDate);
+            const end = new Date(event.endDate);
+            return start <= now && now <= end;
+        });
+    }
+    get todayEvents() {
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        return this.eventItems.filter((event) => {
+            const eventDate = new Date(event.startDate);
+            eventDate.setHours(0, 0, 0, 0);
+            return eventDate.getTime() === today.getTime();
+        });
+    }
+    get tomorrowEvents() {
+        const tomorrow = new Date();
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        tomorrow.setHours(0, 0, 0, 0);
+        return this.eventItems.filter((event) => {
+            const eventDate = new Date(event.startDate);
+            eventDate.setHours(0, 0, 0, 0);
+            return eventDate.getTime() === tomorrow.getTime();
+        });
+    }
+    replaceBookmarked(ids) {
+        const ar = (ids || []).map((x) => this.eventItems.find((e) => e.id === x)).filter((x) => x);
+        const set = new Set(ar);
+        const toRemove = this.bookmarked.filter((e) => !set.has(e));
+        for (const e of toRemove) {
+            e.bookmarked = false;
+        }
+        for (const e of ar) {
+            e.bookmarked = true;
+        }
+    }
+    replaceVisited(ids) {
+        const ar = (ids || []).map((x) => this.eventItems.find((e) => e.id === x)).filter((x) => x);
+        const set = new Set(ar);
+        const toRemove = this.visited.filter((e) => !set.has(e));
+        for (const e of toRemove) {
+            e.visited = false;
+        }
+        for (const e of ar) {
+            e.visited = true;
+        }
+    }
+}
+__decorate([
+    computed
+], EventStore.prototype, "bookmarked", null);
+__decorate([
+    computed
+], EventStore.prototype, "visited", null);
+__decorate([
+    computed
+], EventStore.prototype, "tracks", null);
+__decorate([
+    computed
+], EventStore.prototype, "venues", null);
+__decorate([
+    computed
+], EventStore.prototype, "pastEvents", null);
+__decorate([
+    computed
+], EventStore.prototype, "futureEvents", null);
+__decorate([
+    computed
+], EventStore.prototype, "liveEvents", null);
+__decorate([
+    computed
+], EventStore.prototype, "todayEvents", null);
+__decorate([
+    computed
+], EventStore.prototype, "tomorrowEvents", null);
+__decorate([
+    action
+], EventStore.prototype, "replaceBookmarked", null);
+__decorate([
+    action
+], EventStore.prototype, "replaceVisited", null);
+export class EventItem {
+    constructor(id, externalId, boothId, name, description, startDate, endDate, logoFile, speakers = [], tracks = [], entity = { type: 'event' }) {
+        this.id = id;
+        this.externalId = externalId;
+        this.boothId = boothId;
+        this.name = name;
+        this.description = description;
+        this.startDate = startDate;
+        this.endDate = endDate;
+        this.logoFile = logoFile;
+        this.speakers = speakers;
+        this.tracks = tracks;
+        this.entity = entity;
+        this.bookmarked = false;
+        this.visited = false;
+        this.slug = generateUniqueSlug(name || `event-${id}`);
+    }
+    get isEnded() {
+        return this.endDate && new Date(this.endDate).getTime() < new Date().getTime();
+    }
+    get hasSpeakers() {
+        return this.speakers.length > 0;
+    }
+    get hasTracks() {
+        return this.tracks.length > 0;
+    }
+    get primaryTrack() {
+        return this.tracks.length > 0 ? this.tracks[0] : null;
+    }
+    get speakerNames() {
+        return this.speakers.map((speaker) => speaker.name).join(', ');
+    }
+    get trackNames() {
+        return this.tracks.map((track) => track.name).join(', ');
+    }
+}
+__decorate([
+    observable
+], EventItem.prototype, "bookmarked", void 0);
+__decorate([
+    observable
+], EventItem.prototype, "visited", void 0);

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

@@ -0,0 +1,86 @@
+import { Logo, MarketMaterial, RawExhibitor } from '@expofp/schema';
+import { Booth } from './BoothStore';
+import { Category } from './CategoryStore';
+import { EventItem } from './EventStore';
+import RootStore from './RootStore';
+export declare enum RebookingState {
+    Unasked = 0,
+    Accepted = 1,
+    Rejected = 2,
+    Undecided = 3
+}
+export default class ExhibitorStore {
+    private readonly rootStore;
+    readonly exhibitors: Exhibitor[];
+    private timeout;
+    constructor(rootStore: RootStore);
+    highlightedByExternalIds: never[];
+    rebookingStateChangeRequested: boolean;
+    rebookingStateSaved: boolean;
+    get exhibitorById(): Map<number, Exhibitor>;
+    get exhibitorByExternalId(): Map<string, Exhibitor>;
+    get exhibitorByName(): Map<string, Exhibitor>;
+    get exhibitorBySlug(): Map<string, Exhibitor>;
+    get bookmarked(): Exhibitor[];
+    get visited(): Exhibitor[];
+    get advertised(): Exhibitor[];
+    replaceBookmarked(ids: number[]): void;
+    replaceVisited(ids: number[]): void;
+    setRebookingState(exhibitor: Exhibitor, state: RebookingState, rebookingNote: string): void;
+    findExhibitor(str: string): Exhibitor | undefined;
+}
+export declare class Exhibitor implements Omit<RawExhibitor, 'categories' | 'booths'> {
+    private readonly store;
+    readonly id: number;
+    readonly name: string;
+    readonly externalId: string;
+    featured: boolean;
+    readonly advertise: boolean;
+    readonly description: string;
+    readonly address: string;
+    readonly address2: string;
+    readonly city: string;
+    readonly state: string;
+    readonly zip: string;
+    readonly country: string;
+    readonly phone1: string;
+    readonly website: string;
+    readonly facebook: string;
+    readonly instagram: string;
+    readonly linkedin: string;
+    readonly twitter: string;
+    readonly googlePlus: string;
+    readonly xing: string;
+    readonly youtube: string;
+    readonly email: string;
+    readonly privateEmail: string;
+    readonly customButtonTitle: string;
+    readonly customButtonUrl: string;
+    readonly customButton2Title: string;
+    readonly customButton2Url: string;
+    readonly customButton3Title: string;
+    readonly customButton3Url: string;
+    readonly leadingImageUrl: string;
+    readonly leadingImageLinkUrl: string;
+    readonly videoUrl: string;
+    readonly order: number;
+    /** Always the object form — `normalizeLegacyData` converts legacy string logos. */
+    readonly logo?: Logo;
+    readonly logoInBooth: boolean;
+    /** The logo's width divided by its height, when the event data states it. */
+    readonly logoAspectRatio?: number;
+    readonly gallery: string[];
+    readonly marketMaterials: MarketMaterial[];
+    readonly slug: string;
+    bookmarked: boolean;
+    visited: boolean;
+    rebookingState: RebookingState;
+    rebookingNote: string;
+    readonly booths: Booth[];
+    readonly categories: Category[];
+    readonly schedule: EventItem[];
+    readonly entity: {
+        readonly type: 'exhibitor';
+    };
+}
+//# sourceMappingURL=ExhibitorStore.d.ts.map

package/dist/esm/store/ExhibitorStore.js

@@ -0,0 +1,175 @@
+import { __decorate } from "tslib";
+import { action, computed, observable } from 'mobx';
+import { buildRebookingUrl, getRebookingToken } from '../tools/rebookingUrl';
+import settings from '../tools/settings';
+import isDebug from '../utils/is-debug';
+export var RebookingState;
+(function (RebookingState) {
+    RebookingState[RebookingState["Unasked"] = 0] = "Unasked";
+    RebookingState[RebookingState["Accepted"] = 1] = "Accepted";
+    RebookingState[RebookingState["Rejected"] = 2] = "Rejected";
+    RebookingState[RebookingState["Undecided"] = 3] = "Undecided";
+})(RebookingState || (RebookingState = {}));
+export default class ExhibitorStore {
+    constructor(rootStore) {
+        this.exhibitors = [];
+        this.highlightedByExternalIds = [];
+        this.rebookingStateChangeRequested = false;
+        this.rebookingStateSaved = false;
+        this.rootStore = rootStore;
+    }
+    get exhibitorById() {
+        return new Map(this.exhibitors.map((c) => [c.id, c]));
+    }
+    get exhibitorByExternalId() {
+        return new Map(this.exhibitors.map((e) => [e.externalId, e]));
+    }
+    get exhibitorByName() {
+        return new Map(this.exhibitors.map((e) => [e.name.toLowerCase(), e]));
+    }
+    get exhibitorBySlug() {
+        return new Map(this.exhibitors.map((e) => [e.slug, e]));
+    }
+    get bookmarked() {
+        return this.exhibitors.filter((x) => x.bookmarked);
+    }
+    get visited() {
+        return this.exhibitors.filter((x) => x.visited);
+    }
+    get advertised() {
+        return this.exhibitors.filter((x) => x.advertise && x.logo?.url);
+    }
+    replaceBookmarked(ids) {
+        if (!Array.isArray(ids)) {
+            return;
+        }
+        //const current = new Set(this.bookmarked);
+        const ar = (ids || []).map((x) => this.exhibitorById.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.bookmarked = false;
+        }
+        for (const e of ar) {
+            e.bookmarked = true;
+        }
+    }
+    replaceVisited(ids) {
+        if (!Array.isArray(ids)) {
+            return;
+        }
+        const ar = (ids || []).map((x) => this.exhibitorById.get(x)).filter((x) => x);
+        const set = new Set(ar);
+        const toRemove = this.visited.filter((e) => !set.has(e));
+        for (const e of toRemove) {
+            e.visited = false;
+        }
+        for (const e of ar) {
+            e.visited = true;
+        }
+    }
+    setRebookingState(exhibitor, state, rebookingNote) {
+        clearTimeout(this.timeout);
+        this.rebookingStateChangeRequested = false;
+        exhibitor.rebookingState = state;
+        exhibitor.rebookingNote = rebookingNote;
+        const url = buildRebookingUrl('api/v1/set-rebooking-state', {
+            rt: getRebookingToken(),
+            expoKey: this.rootStore.fp.eventId,
+        });
+        fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                expoKey: settings.EXPO,
+                exhibitorId: exhibitor.id,
+                rebookingState: state,
+                rebookingNote,
+            }),
+        })
+            .then((r) => {
+            if (r.ok)
+                this.rebookingStateSaved = true;
+            if (!r.ok && !isDebug) {
+                exhibitor.rebookingState = RebookingState.Unasked;
+                this.rebookingStateSaved = false;
+            }
+        })
+            .catch(() => {
+            exhibitor.rebookingState = RebookingState.Unasked;
+            this.rebookingStateSaved = false;
+        })
+            .finally(() => {
+            this.rebookingStateChangeRequested = true;
+            this.timeout = setTimeout(() => {
+                this.rebookingStateChangeRequested = false;
+            }, 5000);
+        });
+    }
+    findExhibitor(str) {
+        return (this.exhibitorByExternalId.get(str) ||
+            this.exhibitorByName.get(str.toLowerCase()) ||
+            this.exhibitorBySlug.get(str));
+    }
+}
+__decorate([
+    observable
+], ExhibitorStore.prototype, "highlightedByExternalIds", void 0);
+__decorate([
+    observable
+], ExhibitorStore.prototype, "rebookingStateChangeRequested", void 0);
+__decorate([
+    observable
+], ExhibitorStore.prototype, "rebookingStateSaved", void 0);
+__decorate([
+    computed({ keepAlive: true })
+], ExhibitorStore.prototype, "exhibitorById", null);
+__decorate([
+    computed({ keepAlive: true })
+], ExhibitorStore.prototype, "exhibitorByExternalId", null);
+__decorate([
+    computed({ keepAlive: true })
+], ExhibitorStore.prototype, "exhibitorByName", null);
+__decorate([
+    computed({ keepAlive: true })
+], ExhibitorStore.prototype, "exhibitorBySlug", null);
+__decorate([
+    computed
+], ExhibitorStore.prototype, "bookmarked", null);
+__decorate([
+    computed
+], ExhibitorStore.prototype, "visited", null);
+__decorate([
+    computed({ keepAlive: true })
+], ExhibitorStore.prototype, "advertised", null);
+__decorate([
+    action
+], ExhibitorStore.prototype, "replaceBookmarked", null);
+__decorate([
+    action
+], ExhibitorStore.prototype, "replaceVisited", null);
+__decorate([
+    action
+], ExhibitorStore.prototype, "setRebookingState", null);
+export class Exhibitor {
+    constructor() {
+        this.entity = { type: 'exhibitor' };
+    }
+}
+__decorate([
+    observable
+], Exhibitor.prototype, "featured", void 0);
+__decorate([
+    observable
+], Exhibitor.prototype, "bookmarked", void 0);
+__decorate([
+    observable
+], Exhibitor.prototype, "visited", void 0);
+__decorate([
+    observable
+], Exhibitor.prototype, "rebookingState", void 0);
+__decorate([
+    observable
+], Exhibitor.prototype, "rebookingNote", void 0);

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

@@ -0,0 +1,15 @@
+export interface FuzzySearchResult<T> {
+    item: T;
+    score: number;
+}
+export default class FuzzySearchEngineStore {
+    private readonly keys;
+    engine: any;
+    private enginePromise;
+    private lastCollection;
+    constructor(keys: string[]);
+    loadEngine(): Promise<void>;
+    private buildEngine;
+    search<T>(list: T[], text: string): FuzzySearchResult<T>[];
+}
+//# sourceMappingURL=FuzzySearchEngineStore.d.ts.map

package/dist/esm/store/FuzzySearchEngineStore.js

@@ -0,0 +1,45 @@
+import { __decorate } from "tslib";
+// @ts-nocheck
+import { observable, runInAction } from 'mobx';
+export default class FuzzySearchEngineStore {
+    constructor(keys) {
+        this.keys = keys;
+        this.enginePromise = null;
+        this.lastCollection = null;
+    }
+    loadEngine() {
+        if (!this.enginePromise)
+            this.enginePromise = this.buildEngine();
+        return this.enginePromise;
+    }
+    async buildEngine() {
+        try {
+            const { default: Fuse } = await import('fuse.js');
+            runInAction(() => {
+                this.engine = new Fuse([], {
+                    keys: this.keys,
+                    ignoreFieldNorm: true,
+                    includeScore: true,
+                    threshold: 0.3,
+                    ignoreLocation: true,
+                });
+            });
+        }
+        catch (err) {
+            console.error(err);
+            this.enginePromise = null;
+        }
+    }
+    search(list, text) {
+        if (!this.engine || !list?.length || !text)
+            return [];
+        if (this.lastCollection !== list) {
+            this.engine.setCollection(list);
+            this.lastCollection = list;
+        }
+        return this.engine.search(text);
+    }
+}
+__decorate([
+    observable
+], FuzzySearchEngineStore.prototype, "engine", void 0);