@expofp/floorplan 0.0.0-experimental.cf063fc

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

@@ -0,0 +1,53 @@
+import BaseFilterStore from './BaseFilterStore';
+import type RootStore from './RootStore';
+import { type FilterItem } from './types';
+type DateFilter = 'all' | 'today' | 'tomorrow' | 'past';
+type TimeOfDayFilter = 'all' | 'morning' | 'midday' | 'afternoon';
+type SortOrder = 'asc' | 'desc';
+interface Filter<T> {
+    value: T;
+    pending: T;
+}
+declare const DEFAULTS: {
+    selectedTracks: number[];
+    selectedVenues: number[];
+    selectedSpeakers: number[];
+    date: DateFilter;
+    timeOfDay: TimeOfDayFilter;
+    sortOrder: SortOrder;
+    use24hFormat: boolean;
+    showBookmarksOnly: boolean;
+    showLiveOnly: boolean;
+};
+type FilterKey = keyof typeof DEFAULTS;
+interface SessionsFilterState {
+    isOpen: boolean;
+    selectedItems: FilterItem[];
+    pendingItems: FilterItem[];
+    searchText: string;
+    visibleSections: string[];
+    filters: {
+        [K in FilterKey]: Filter<(typeof DEFAULTS)[K]>;
+    };
+}
+export default class SessionsFilterStore extends BaseFilterStore {
+    state: SessionsFilterState;
+    constructor(rootStore: RootStore);
+    private createInitialFilters;
+    setSearchText(text: string): void;
+    setPending<K extends FilterKey>(key: K, value: (typeof DEFAULTS)[K]): void;
+    /** The filter panel's Apply: commit the pending filters and focus the list. */
+    applyFilters(): void;
+    /** Commit the pending filters, leaving the list and the search box as they are. */
+    commitFilters(): void;
+    resetFilters(): void;
+    resetAndApplyFilters(): void;
+    openFilter(): void;
+    closeFilter(): void;
+    openFilterWithSections(sections: string[]): void;
+    get activeFiltersCount(): number;
+    protected updateUIState(): void;
+    getFilteredItems(): FilterItem[];
+}
+export {};
+//# sourceMappingURL=SessionsFilterStore.d.ts.map

package/dist/esm/store/SessionsFilterStore.js

@@ -0,0 +1,169 @@
+import { __decorate } from "tslib";
+import { action, computed, observable } from 'mobx';
+import BaseFilterStore from './BaseFilterStore';
+const DEFAULTS = {
+    selectedTracks: [],
+    selectedVenues: [],
+    selectedSpeakers: [],
+    date: 'all',
+    timeOfDay: 'all',
+    sortOrder: 'desc',
+    use24hFormat: false,
+    showBookmarksOnly: false,
+    showLiveOnly: false,
+};
+export default class SessionsFilterStore extends BaseFilterStore {
+    constructor(rootStore) {
+        super(rootStore);
+        this.state = {
+            isOpen: false,
+            selectedItems: [],
+            pendingItems: [],
+            searchText: '',
+            visibleSections: ['tracks', 'venues', 'speakers', 'date', 'time', 'sort', 'settings'],
+            filters: this.createInitialFilters(),
+        };
+    }
+    createInitialFilters() {
+        const filters = {};
+        Object.keys(DEFAULTS).forEach((key) => {
+            filters[key] = { value: DEFAULTS[key], pending: DEFAULTS[key] };
+        });
+        return filters;
+    }
+    setSearchText(text) {
+        this.state.searchText = text;
+    }
+    setPending(key, value) {
+        this.state.filters[key].pending = value;
+    }
+    /** The filter panel's Apply: commit the pending filters and focus the list. */
+    applyFilters() {
+        this.commitFilters();
+        this.updateUIState();
+    }
+    /** Commit the pending filters, leaving the list and the search box as they are. */
+    commitFilters() {
+        const { filters } = this.state;
+        const wasTracksActive = filters.selectedTracks.value.length > 0;
+        const wasVenuesActive = filters.selectedVenues.value.length > 0;
+        Object.keys(filters).forEach((key) => {
+            filters[key].value = filters[key].pending;
+        });
+        const isTracksActive = filters.selectedTracks.value.length > 0;
+        const isVenuesActive = filters.selectedVenues.value.length > 0;
+        if (wasTracksActive !== isTracksActive) {
+            this.rootStore.shortcutRegistry.updateActivationOrderFromState('sessions', 'tracks', wasTracksActive, isTracksActive);
+        }
+        if (wasVenuesActive !== isVenuesActive) {
+            this.rootStore.shortcutRegistry.updateActivationOrderFromState('sessions', 'venues', wasVenuesActive, isVenuesActive);
+        }
+        this.state.selectedItems = [...this.state.pendingItems];
+        this.state.isOpen = false;
+    }
+    resetFilters() {
+        const { filters } = this.state;
+        Object.keys(DEFAULTS).forEach((key) => {
+            filters[key].pending = DEFAULTS[key];
+        });
+        this.state.pendingItems = [];
+        this.state.searchText = '';
+    }
+    resetAndApplyFilters() {
+        const { filters } = this.state;
+        const wasTracksActive = filters.selectedTracks.value.length > 0;
+        const wasVenuesActive = filters.selectedVenues.value.length > 0;
+        this.resetFilters();
+        Object.keys(filters).forEach((key) => {
+            filters[key].value = filters[key].pending;
+        });
+        const isTracksActive = false;
+        const isVenuesActive = false;
+        if (wasTracksActive !== isTracksActive) {
+            this.rootStore.shortcutRegistry.updateActivationOrderFromState('sessions', 'tracks', wasTracksActive, isTracksActive);
+        }
+        if (wasVenuesActive !== isVenuesActive) {
+            this.rootStore.shortcutRegistry.updateActivationOrderFromState('sessions', 'venues', wasVenuesActive, isVenuesActive);
+        }
+        this.state.selectedItems = [];
+        this.state.isOpen = false;
+        this.rootStore.uiState.list = { type: 'sessions', text: '', focused: false };
+    }
+    openFilter() {
+        this.state.isOpen = true;
+        this.state.pendingItems = [...this.state.selectedItems];
+        const { filters } = this.state;
+        Object.keys(filters).forEach((key) => {
+            filters[key].pending = filters[key].value;
+        });
+    }
+    closeFilter() {
+        this.state.isOpen = false;
+        this.state.pendingItems = [...this.state.selectedItems];
+        const { filters } = this.state;
+        Object.keys(filters).forEach((key) => {
+            filters[key].pending = filters[key].value;
+        });
+    }
+    openFilterWithSections(sections) {
+        this.state.visibleSections = sections;
+        this.openFilter();
+    }
+    get activeFiltersCount() {
+        const { filters } = this.state;
+        let count = 0;
+        Object.keys(DEFAULTS).forEach((key) => {
+            const currentValue = filters[key].value;
+            const defaultValue = DEFAULTS[key];
+            if (Array.isArray(defaultValue) && Array.isArray(currentValue)) {
+                if (currentValue.length > 0)
+                    count++;
+            }
+            else {
+                if (currentValue !== defaultValue)
+                    count++;
+            }
+        });
+        return count;
+    }
+    updateUIState() {
+        this.rootStore.uiState.list = { type: 'sessions', text: '', focused: false };
+        this.rootStore.searchStore.setFocused(true);
+    }
+    getFilteredItems() {
+        return [];
+    }
+}
+__decorate([
+    observable
+], SessionsFilterStore.prototype, "state", void 0);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "setSearchText", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "setPending", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "applyFilters", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "commitFilters", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "resetFilters", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "resetAndApplyFilters", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "openFilter", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "closeFilter", null);
+__decorate([
+    action
+], SessionsFilterStore.prototype, "openFilterWithSections", null);
+__decorate([
+    computed
+], SessionsFilterStore.prototype, "activeFiltersCount", null);

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

@@ -0,0 +1,26 @@
+export interface ShortcutConfig {
+    id: string;
+    label?: string;
+    icon?: string;
+    enabled: boolean;
+    active: boolean;
+    action: 'toggle' | 'custom';
+    tooltip?: string;
+    badge?: string | number;
+    variant?: 'default' | 'primary' | 'secondary';
+    showResetButton?: boolean;
+}
+export interface ShortcutProvider {
+    readonly id: string;
+    createShortcuts(): ShortcutConfig[];
+    handleShortcutClick(shortcutId: string): void;
+    handleShortcutReset?(shortcutId: string): void;
+    shouldShowShortcuts?(): boolean;
+}
+export declare abstract class BaseShortcutProvider implements ShortcutProvider {
+    abstract readonly id: string;
+    abstract createShortcuts(): ShortcutConfig[];
+    abstract handleShortcutClick(shortcutId: string): void;
+    shouldShowShortcuts?(): boolean;
+}
+//# sourceMappingURL=ShortcutProvider.d.ts.map

package/dist/esm/store/ShortcutProvider.js

@@ -0,0 +1,5 @@
+export class BaseShortcutProvider {
+    shouldShowShortcuts() {
+        return true;
+    }
+}

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

@@ -0,0 +1,33 @@
+import { type ShortcutConfig, type ShortcutProvider } from './ShortcutProvider';
+export declare class ShortcutRegistry {
+    private providers;
+    private activationOrder;
+    register(provider: ShortcutProvider): void;
+    unregister(providerId: string): void;
+    getShortcuts(interfaceId: string): ShortcutConfig[];
+    private sortShortcuts;
+    handleShortcutClick(interfaceId: string, shortcutId: string): void;
+    /**
+     * Reports a chip click to stats, using the `action` each provider already
+     * declares rather than guessing from `active`:
+     *
+     * - `toggle` — `active` IS the filter, so only the click that turns it on is
+     *   a view of it; turning it off is not.
+     * - `custom` — opens a panel or a list on every click, while `active` says
+     *   whether a filter happens to be set. Reading `active` here would drop
+     *   every re-open made after the first selection.
+     *
+     * Tagged `shortcut` so these stay separable from the main button row, whose
+     * `sbtnview` carries no subtype.
+     */
+    private reportClick;
+    private isShortcutActive;
+    handleShortcutReset(interfaceId: string, shortcutId: string): void;
+    private updateActivationOrder;
+    updateActivationOrderFromState(interfaceId: string, shortcutId: string, wasActive: boolean, isActive: boolean): void;
+    shouldShowShortcuts(interfaceId: string): boolean;
+    getRegisteredProviders(): string[];
+    isProviderRegistered(providerId: string): boolean;
+    clear(): void;
+}
+//# sourceMappingURL=ShortcutRegistry.d.ts.map

package/dist/esm/store/ShortcutRegistry.js

@@ -0,0 +1,130 @@
+import trackEvent from '../tools/track-event';
+export class ShortcutRegistry {
+    constructor() {
+        this.providers = new Map();
+        this.activationOrder = new Map();
+    }
+    register(provider) {
+        if (!provider?.id) {
+            throw new Error('Provider must have a valid id');
+        }
+        this.providers.set(provider.id, provider);
+    }
+    unregister(providerId) {
+        this.providers.delete(providerId);
+        this.activationOrder.delete(providerId);
+    }
+    getShortcuts(interfaceId) {
+        const provider = this.providers.get(interfaceId);
+        if (!provider)
+            return [];
+        const shortcuts = provider.createShortcuts();
+        const order = this.activationOrder.get(interfaceId);
+        return order ? this.sortShortcuts(shortcuts, order) : shortcuts;
+    }
+    sortShortcuts(shortcuts, order) {
+        const orderMap = new Map(order.map((id, index) => [id, index]));
+        return shortcuts.sort((a, b) => {
+            if (a.active !== b.active) {
+                return a.active ? -1 : 1;
+            }
+            if (a.active && b.active) {
+                const orderA = orderMap.get(a.id);
+                const orderB = orderMap.get(b.id);
+                if (orderA !== undefined && orderB !== undefined) {
+                    return orderA - orderB;
+                }
+                return (orderA !== undefined ? -1 : 0) - (orderB !== undefined ? -1 : 0);
+            }
+            return 0;
+        });
+    }
+    handleShortcutClick(interfaceId, shortcutId) {
+        const provider = this.providers.get(interfaceId);
+        if (!provider)
+            return;
+        const shortcut = provider.createShortcuts().find((s) => s.id === shortcutId);
+        const wasActive = shortcut?.active ?? false;
+        provider.handleShortcutClick(shortcutId);
+        const isActive = this.isShortcutActive(provider, shortcutId);
+        this.reportClick(shortcut, wasActive, isActive);
+        if (wasActive !== isActive) {
+            this.updateActivationOrder(interfaceId, shortcutId, wasActive, isActive);
+        }
+    }
+    /**
+     * Reports a chip click to stats, using the `action` each provider already
+     * declares rather than guessing from `active`:
+     *
+     * - `toggle` — `active` IS the filter, so only the click that turns it on is
+     *   a view of it; turning it off is not.
+     * - `custom` — opens a panel or a list on every click, while `active` says
+     *   whether a filter happens to be set. Reading `active` here would drop
+     *   every re-open made after the first selection.
+     *
+     * Tagged `shortcut` so these stay separable from the main button row, whose
+     * `sbtnview` carries no subtype.
+     */
+    reportClick(shortcut, wasActive, isActive) {
+        if (!shortcut)
+            return;
+        const activated = shortcut.action === 'custom' || (!wasActive && isActive);
+        if (!activated)
+            return;
+        // `label` is the provider's own caption and is not run through `t()`, so it
+        // is the same string in every locale; icon-only chips fall back to the id.
+        const caption = shortcut.label || shortcut.id;
+        if (caption)
+            trackEvent('sbtnview', caption, 'shortcut');
+    }
+    isShortcutActive(provider, shortcutId) {
+        const shortcuts = provider.createShortcuts();
+        return shortcuts.find((s) => s.id === shortcutId)?.active ?? false;
+    }
+    handleShortcutReset(interfaceId, shortcutId) {
+        const provider = this.providers.get(interfaceId);
+        if (!provider?.handleShortcutReset)
+            return;
+        provider.handleShortcutReset(shortcutId);
+        const order = this.activationOrder.get(interfaceId);
+        if (order?.includes(shortcutId)) {
+            this.updateActivationOrder(interfaceId, shortcutId, true, false);
+        }
+    }
+    updateActivationOrder(interfaceId, shortcutId, wasActive, isActive) {
+        const order = this.activationOrder.get(interfaceId) || [];
+        let newOrder;
+        if (!wasActive && isActive) {
+            newOrder = order.includes(shortcutId) ? order : [...order, shortcutId];
+        }
+        else if (wasActive && !isActive) {
+            newOrder = order.filter((id) => id !== shortcutId);
+        }
+        else {
+            return;
+        }
+        if (newOrder.length > 0) {
+            this.activationOrder.set(interfaceId, newOrder);
+        }
+        else {
+            this.activationOrder.delete(interfaceId);
+        }
+    }
+    updateActivationOrderFromState(interfaceId, shortcutId, wasActive, isActive) {
+        this.updateActivationOrder(interfaceId, shortcutId, wasActive, isActive);
+    }
+    shouldShowShortcuts(interfaceId) {
+        const provider = this.providers.get(interfaceId);
+        return provider?.shouldShowShortcuts?.() ?? true;
+    }
+    getRegisteredProviders() {
+        return Array.from(this.providers.keys());
+    }
+    isProviderRegistered(providerId) {
+        return this.providers.has(providerId);
+    }
+    clear() {
+        this.providers.clear();
+        this.activationOrder.clear();
+    }
+}

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

@@ -0,0 +1,39 @@
+import type RootStore from './RootStore';
+declare class Filter<T> {
+    value: T;
+    pending: T;
+    constructor(initialValue: T);
+    setValue(value: T): void;
+    apply(): void;
+    reset(): void;
+}
+export interface SpeakerFilterState {
+    isOpen: boolean;
+    filters: {
+        selectedCompanies: Filter<string[]>;
+        selectedJobTitles: Filter<string[]>;
+    };
+    visibleSections: ('companies' | 'jobTitles')[];
+}
+export default class SpeakerFilterStore {
+    private readonly rootStore;
+    state: SpeakerFilterState;
+    constructor(rootStore: RootStore);
+    get activeFiltersCount(): number;
+    applyFilters(): void;
+    resetFilters(): void;
+    resetAndApplyFilters(): void;
+    clearAllFilters(): void;
+    openFilter(): void;
+    closeFilter(): void;
+    openFilterWithSections(sections: ('companies' | 'jobTitles')[]): void;
+    setPending<K extends keyof SpeakerFilterState['filters']>(key: K, value: SpeakerFilterState['filters'][K]['pending']): void;
+    toggleCompanyFilter(company: string): void;
+    toggleJobTitleFilter(jobTitle: string): void;
+    getDefaultValues(): {
+        selectedCompanies: never[];
+        selectedJobTitles: never[];
+    };
+}
+export {};
+//# sourceMappingURL=SpeakerFilterStore.d.ts.map

package/dist/esm/store/SpeakerFilterStore.js

@@ -0,0 +1,152 @@
+import { __decorate } from "tslib";
+// @ts-nocheck
+import { action, computed, observable } from 'mobx';
+class Filter {
+    constructor(initialValue) {
+        this.value = initialValue;
+        this.pending = initialValue;
+    }
+    setValue(value) {
+        this.pending = value;
+    }
+    apply() {
+        this.value = this.pending;
+    }
+    reset() {
+        this.pending = this.value;
+    }
+}
+__decorate([
+    observable
+], Filter.prototype, "value", void 0);
+__decorate([
+    observable
+], Filter.prototype, "pending", void 0);
+__decorate([
+    action
+], Filter.prototype, "setValue", null);
+__decorate([
+    action
+], Filter.prototype, "apply", null);
+__decorate([
+    action
+], Filter.prototype, "reset", null);
+export default class SpeakerFilterStore {
+    constructor(rootStore) {
+        this.state = {
+            isOpen: false,
+            filters: {
+                selectedCompanies: new Filter([]),
+                selectedJobTitles: new Filter([]),
+            },
+            visibleSections: ['companies', 'jobTitles'],
+        };
+        this.rootStore = rootStore;
+    }
+    get activeFiltersCount() {
+        let count = 0;
+        const { filters } = this.state;
+        if (filters.selectedCompanies.value.length > 0)
+            count++;
+        if (filters.selectedJobTitles.value.length > 0)
+            count++;
+        return count;
+    }
+    applyFilters() {
+        const { filters } = this.state;
+        filters.selectedCompanies.apply();
+        filters.selectedJobTitles.apply();
+        this.closeFilter();
+    }
+    resetFilters() {
+        const { filters } = this.state;
+        filters.selectedCompanies.pending = [];
+        filters.selectedJobTitles.pending = [];
+    }
+    resetAndApplyFilters() {
+        this.resetFilters();
+        this.applyFilters();
+    }
+    clearAllFilters() {
+        const { filters } = this.state;
+        filters.selectedCompanies.pending = [];
+        filters.selectedJobTitles.pending = [];
+        filters.selectedCompanies.value = [];
+        filters.selectedJobTitles.value = [];
+    }
+    openFilter() {
+        this.state.isOpen = true;
+    }
+    closeFilter() {
+        this.state.isOpen = false;
+    }
+    openFilterWithSections(sections) {
+        this.state.visibleSections = sections;
+        this.openFilter();
+    }
+    setPending(key, value) {
+        this.state.filters[key].setValue(value);
+    }
+    toggleCompanyFilter(company) {
+        const { selectedCompanies } = this.state.filters;
+        const currentCompanies = selectedCompanies.value;
+        if (currentCompanies.includes(company)) {
+            selectedCompanies.setValue(currentCompanies.filter((c) => c !== company));
+        }
+        else {
+            selectedCompanies.setValue([...currentCompanies, company]);
+        }
+    }
+    toggleJobTitleFilter(jobTitle) {
+        const { selectedJobTitles } = this.state.filters;
+        const currentJobTitles = selectedJobTitles.value;
+        if (currentJobTitles.includes(jobTitle)) {
+            selectedJobTitles.setValue(currentJobTitles.filter((jt) => jt !== jobTitle));
+        }
+        else {
+            selectedJobTitles.setValue([...currentJobTitles, jobTitle]);
+        }
+    }
+    getDefaultValues() {
+        return {
+            selectedCompanies: [],
+            selectedJobTitles: [],
+        };
+    }
+}
+__decorate([
+    observable
+], SpeakerFilterStore.prototype, "state", void 0);
+__decorate([
+    computed
+], SpeakerFilterStore.prototype, "activeFiltersCount", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "applyFilters", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "resetFilters", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "resetAndApplyFilters", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "clearAllFilters", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "openFilter", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "closeFilter", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "openFilterWithSections", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "setPending", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "toggleCompanyFilter", null);
+__decorate([
+    action
+], SpeakerFilterStore.prototype, "toggleJobTitleFilter", null);

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

@@ -0,0 +1,45 @@
+import { EventItem } from './EventStore';
+import RootStore from './RootStore';
+export declare class SpeakerItem {
+    readonly id: number;
+    readonly externalId: string;
+    readonly name: string;
+    readonly company: string;
+    readonly jobTitle: string;
+    readonly photoFile?: string | undefined;
+    readonly entity: {
+        readonly type: 'speaker';
+    };
+    readonly slug: string;
+    bookmarked: boolean;
+    constructor(id: number, externalId: string, name: string, company: string, jobTitle: string, photoFile?: string | undefined, entity?: {
+        readonly type: 'speaker';
+    });
+    get displayName(): string;
+    get fullTitle(): string;
+    get hasPhoto(): boolean;
+    get hasCompany(): boolean;
+    get hasJobTitle(): boolean;
+}
+export type Speaker = SpeakerItem;
+export default class SpeakerStore {
+    private readonly rootStore;
+    readonly speakersMap: Map<number, SpeakerItem>;
+    selectedSpeaker: Speaker | null;
+    constructor(rootStore: RootStore);
+    get speakers(): Speaker[];
+    getSpeakerById(id: number): SpeakerItem | undefined;
+    getSpeakerBySlug(slug: string): SpeakerItem | undefined;
+    addSpeaker(speakerData: any): SpeakerItem;
+    get companies(): string[];
+    get jobTitles(): string[];
+    getSpeakersByCompany(company: string): Speaker[];
+    getSpeakersByJobTitle(jobTitle: string): Speaker[];
+    getEventsBySpeaker(speakerId: number): EventItem[];
+    findBySlug(slug: string): Speaker | undefined;
+    selectSpeaker(speaker: Speaker, focus?: boolean): void;
+    get bookmarked(): Speaker[];
+    replaceBookmarked(ids: number[]): void;
+    clearSelectedSpeaker(): void;
+}
+//# sourceMappingURL=SpeakerStore.d.ts.map