@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/store/search-buttons/SearchButtonsFilters.d.ts

@@ -0,0 +1,20 @@
+import type RootStore from '../RootStore';
+import { type SearchButtonTypeConfig } from '../types';
+import { type SearchButtonsState } from './SearchButtonsState';
+export declare class SearchButtonsFilters {
+    private rootStore;
+    private state;
+    constructor(rootStore: RootStore, state: SearchButtonsState);
+    applyAllChildrenFilters(buttonConfig: SearchButtonTypeConfig): void;
+    applyChildFilters(): void;
+    clearAllChildFilters(): void;
+    clearCategoryFilters(): void;
+    clearPoiTypeFilters(): void;
+    toggleChildFilter(childId: string): void;
+    getActiveParent(): SearchButtonTypeConfig | null;
+    areAllSelected(): boolean;
+    getChildrenCount(): number;
+    private collectFilters;
+    private collectSelectedFilters;
+}
+//# sourceMappingURL=SearchButtonsFilters.d.ts.map

package/dist/esm/store/search-buttons/SearchButtonsFilters.js

@@ -0,0 +1,157 @@
+import { __decorate } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { action } from 'mobx';
+import { getButtonConfig } from './utils';
+export class SearchButtonsFilters {
+    constructor(rootStore, state) {
+        this.rootStore = rootStore;
+        this.state = state;
+    }
+    applyAllChildrenFilters(buttonConfig) {
+        if (!buttonConfig.children)
+            return;
+        const { uiState } = this.rootStore;
+        const visibleChildren = buttonConfig.children.filter((child) => child.visible);
+        const { categories, poiTypes } = this.collectFilters(visibleChildren);
+        uiState.selectedCategoryFilters = categories;
+        uiState.selectedPoiTypeFilters = poiTypes;
+        uiState.categoryFilterOpen = categories.length > 0;
+    }
+    applyChildFilters() {
+        const { uiState } = this.rootStore;
+        const activeChildren = Array.from(this.state.searchShortcutState.activeChildren);
+        uiState.selectedCategoryFilters = [];
+        uiState.selectedPoiTypeFilters = [];
+        uiState.categoryFilterOpen = false;
+        if (activeChildren.length === 0) {
+            return;
+        }
+        const buttonConfig = getButtonConfig(this.state.searchShortcutState.activeParentId);
+        if (!buttonConfig?.children)
+            return;
+        const visibleChildren = buttonConfig.children.filter((child) => child.visible);
+        const { categories, poiTypes } = this.collectSelectedFilters(visibleChildren, activeChildren);
+        uiState.selectedCategoryFilters = categories;
+        uiState.selectedPoiTypeFilters = poiTypes;
+        uiState.categoryFilterOpen = categories.length > 0;
+    }
+    clearAllChildFilters() {
+        this.state.clearChildren();
+        this.rootStore.uiState.selectedCategoryFilters = [];
+        this.rootStore.uiState.selectedPoiTypeFilters = [];
+        this.rootStore.uiState.categoryFilterOpen = false;
+    }
+    clearCategoryFilters() {
+        const { uiState } = this.rootStore;
+        uiState.selectedCategoryFilters = [];
+        this.rootStore.categoryFilterStore.state.selectedItems = [];
+        this.rootStore.categoryFilterStore.state.pendingItems = [];
+        this.rootStore.urlFilterManager.setCategories([]);
+    }
+    clearPoiTypeFilters() {
+        this.state.setPoiFilter(null);
+        this.rootStore.uiState.selectedPoiTypeFilters = [];
+        this.rootStore.urlFilterManager.setPoiType(null);
+    }
+    toggleChildFilter(childId) {
+        const buttonConfig = getButtonConfig(this.state.searchShortcutState.activeParentId);
+        if (!buttonConfig?.children)
+            return;
+        this.state.toggleChild(childId);
+        if (this.state.hasActiveChildren) {
+            this.applyChildFilters();
+        }
+        else {
+            this.applyAllChildrenFilters(buttonConfig);
+        }
+    }
+    getActiveParent() {
+        if (!this.state.searchShortcutState.activeParentId)
+            return null;
+        return getButtonConfig(this.state.searchShortcutState.activeParentId);
+    }
+    areAllSelected() {
+        if (!this.state.searchShortcutState.activeParentId)
+            return false;
+        const buttonConfig = getButtonConfig(this.state.searchShortcutState.activeParentId);
+        if (!buttonConfig?.children)
+            return false;
+        const visibleChildren = buttonConfig.children.filter((child) => child.visible);
+        const filterableChildren = visibleChildren.filter((child) => child.type !== 'link');
+        return (filterableChildren.length > 0 &&
+            filterableChildren.every((child) => {
+                const childId = child.id?.toString() || child.name;
+                return this.state.isChildActive(childId);
+            }));
+    }
+    getChildrenCount() {
+        if (!this.state.searchShortcutState.activeParentId)
+            return 0;
+        const buttonConfig = getButtonConfig(this.state.searchShortcutState.activeParentId);
+        if (!buttonConfig?.children)
+            return 0;
+        const visibleChildren = buttonConfig.children.filter((child) => child.visible);
+        return visibleChildren.filter((child) => child.type !== 'link').length;
+    }
+    collectFilters(children) {
+        const categories = [];
+        const poiTypes = [];
+        children.forEach((child) => {
+            const childNumericId = Number(child.id);
+            if (child.type === 'categories') {
+                const category = this.rootStore.categoryStore.categories.find((c) => c.id === childNumericId);
+                if (category)
+                    categories.push(category);
+            }
+            else if (child.type === 'poi_types') {
+                const poiType = this.rootStore.poiTypeStore.poiTypes.find((p) => p.id === childNumericId);
+                if (poiType)
+                    poiTypes.push(poiType);
+            }
+        });
+        return { categories, poiTypes };
+    }
+    collectSelectedFilters(children, activeChildIds) {
+        const categories = [];
+        const poiTypes = [];
+        activeChildIds.forEach((childId) => {
+            const child = children.find((c) => {
+                if (c.type === 'link')
+                    return false;
+                return (c.id?.toString() || c.name) === childId;
+            });
+            if (!child)
+                return;
+            const childNumericId = Number(child.id);
+            if (child.type === 'categories') {
+                const category = this.rootStore.categoryStore.categories.find((c) => c.id === childNumericId);
+                if (category)
+                    categories.push(category);
+            }
+            else if (child.type === 'poi_types') {
+                const poiType = this.rootStore.poiTypeStore.poiTypes.find((p) => p.id === childNumericId);
+                if (poiType)
+                    poiTypes.push(poiType);
+            }
+        });
+        return { categories, poiTypes };
+    }
+}
+__decorate([
+    action
+], SearchButtonsFilters.prototype, "applyAllChildrenFilters", null);
+__decorate([
+    action
+], SearchButtonsFilters.prototype, "applyChildFilters", null);
+__decorate([
+    action
+], SearchButtonsFilters.prototype, "clearAllChildFilters", null);
+__decorate([
+    action
+], SearchButtonsFilters.prototype, "clearCategoryFilters", null);
+__decorate([
+    action
+], SearchButtonsFilters.prototype, "clearPoiTypeFilters", null);
+__decorate([
+    action
+], SearchButtonsFilters.prototype, "toggleChildFilter", null);

package/dist/esm/store/search-buttons/SearchButtonsState.d.ts

@@ -0,0 +1,24 @@
+import { type SearchShortcutState } from '../types';
+export declare class SearchButtonsState {
+    isVisible: boolean;
+    activePoiFilterId: string | null;
+    activeSubButtonsParentId: string | null;
+    activeSubButtonId: string | null;
+    subButtonsEnabled: boolean;
+    searchShortcutState: SearchShortcutState;
+    setVisible(visible: boolean): void;
+    setSubButtonParent(parentId: string | null): void;
+    setPoiFilter(filterId: string | null): void;
+    setSubButton(buttonId: string | null): void;
+    setSubButtonsEnabled(enabled: boolean): void;
+    setActiveParentId(parentId: string | null): void;
+    showShortcuts(visible: boolean): void;
+    clearChildren(): void;
+    toggleChild(childId: string): void;
+    reset(): void;
+    get hasActiveChildren(): boolean;
+    get activeChildrenCount(): number;
+    get hasActiveParentWithChildren(): boolean;
+    isChildActive(childId: string): boolean;
+}
+//# sourceMappingURL=SearchButtonsState.d.ts.map

package/dist/esm/store/search-buttons/SearchButtonsState.js

@@ -0,0 +1,125 @@
+import { __decorate } from "tslib";
+// @ts-nocheck
+import { action, computed, observable } from 'mobx';
+export class SearchButtonsState {
+    constructor() {
+        this.isVisible = true;
+        this.activePoiFilterId = null;
+        this.activeSubButtonsParentId = null;
+        this.activeSubButtonId = null;
+        this.subButtonsEnabled = false;
+        this.searchShortcutState = {
+            activeParentId: null,
+            activeChildren: new Set(),
+            isShortcutsVisible: false,
+        };
+    }
+    setVisible(visible) {
+        this.isVisible = visible;
+    }
+    setSubButtonParent(parentId) {
+        this.activeSubButtonsParentId = parentId;
+    }
+    setPoiFilter(filterId) {
+        this.activePoiFilterId = filterId;
+    }
+    setSubButton(buttonId) {
+        this.activeSubButtonId = buttonId;
+    }
+    setSubButtonsEnabled(enabled) {
+        this.subButtonsEnabled = enabled;
+    }
+    setActiveParentId(parentId) {
+        this.searchShortcutState.activeParentId = parentId;
+    }
+    showShortcuts(visible) {
+        this.searchShortcutState.isShortcutsVisible = visible;
+    }
+    clearChildren() {
+        this.searchShortcutState.activeChildren.clear();
+    }
+    toggleChild(childId) {
+        if (this.searchShortcutState.activeChildren.has(childId)) {
+            this.searchShortcutState.activeChildren.delete(childId);
+        }
+        else {
+            this.searchShortcutState.activeChildren.add(childId);
+        }
+    }
+    reset() {
+        this.activePoiFilterId = null;
+        this.searchShortcutState.activeParentId = null;
+        this.searchShortcutState.activeChildren.clear();
+        this.searchShortcutState.isShortcutsVisible = false;
+    }
+    get hasActiveChildren() {
+        return this.searchShortcutState.activeChildren.size > 0;
+    }
+    get activeChildrenCount() {
+        return this.searchShortcutState.activeChildren.size;
+    }
+    get hasActiveParentWithChildren() {
+        return (this.searchShortcutState.isShortcutsVisible &&
+            this.searchShortcutState.activeParentId !== null);
+    }
+    isChildActive(childId) {
+        return this.searchShortcutState.activeChildren.has(childId);
+    }
+}
+__decorate([
+    observable
+], SearchButtonsState.prototype, "isVisible", void 0);
+__decorate([
+    observable
+], SearchButtonsState.prototype, "activePoiFilterId", void 0);
+__decorate([
+    observable
+], SearchButtonsState.prototype, "activeSubButtonsParentId", void 0);
+__decorate([
+    observable
+], SearchButtonsState.prototype, "activeSubButtonId", void 0);
+__decorate([
+    observable
+], SearchButtonsState.prototype, "subButtonsEnabled", void 0);
+__decorate([
+    observable
+], SearchButtonsState.prototype, "searchShortcutState", void 0);
+__decorate([
+    action
+], SearchButtonsState.prototype, "setVisible", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "setSubButtonParent", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "setPoiFilter", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "setSubButton", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "setSubButtonsEnabled", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "setActiveParentId", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "showShortcuts", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "clearChildren", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "toggleChild", null);
+__decorate([
+    action
+], SearchButtonsState.prototype, "reset", null);
+__decorate([
+    computed
+], SearchButtonsState.prototype, "hasActiveChildren", null);
+__decorate([
+    computed
+], SearchButtonsState.prototype, "activeChildrenCount", null);
+__decorate([
+    computed
+], SearchButtonsState.prototype, "hasActiveParentWithChildren", null);

package/dist/esm/store/search-buttons/SearchButtonsStore.d.ts

@@ -0,0 +1,73 @@
+import type RootStore from '../RootStore';
+import type { SearchButtonConfig, SearchButtonTypeConfig, SearchShortcutState, SearchSubButtonConfig } from '../types';
+export default class SearchButtonsStore {
+    private readonly rootStore;
+    private _subButtonRegistry?;
+    private readonly state;
+    private readonly filters;
+    private readonly actions;
+    private readonly factory;
+    private poiTypeCountsCache;
+    /** Set by `keepFiltersOnNextNavigation`, spent by the next entry into navigation. */
+    private keepFiltersOnNextEntry;
+    private lastPoiTypeCountUpdate;
+    constructor(rootStore: RootStore);
+    private setupReactions;
+    /**
+     * Lets the next entry into navigation keep the active filter. For a deep
+     * link that opens with both a filter and a route or planner: that is not a
+     * switch into navigation, so its filter stays. Call it only right before
+     * opening navigation that is sure to land, or the hold outlives it and
+     * spares the user's own next entry.
+     */
+    keepFiltersOnNextNavigation(): void;
+    /**
+     * Navigation is the route planner or the directions panel. The planner opens
+     * before its route is drawn, so a planner session counts as one entry.
+     */
+    private get isNavigationOpen();
+    private get subButtonRegistry();
+    private registerSubButtonProviders;
+    private invalidatePoiTypeCounts;
+    get isVisible(): boolean;
+    get shouldShow(): boolean;
+    get activePoiFilterId(): string | null;
+    get activeSubButtonsParentId(): string | null;
+    get activeSubButtonId(): string | null;
+    get subButtonsEnabled(): boolean;
+    get searchShortcutState(): SearchShortcutState;
+    get searchButtons(): SearchButtonConfig[];
+    get hasAnySearchButtons(): boolean;
+    get hasActiveSearchButton(): boolean;
+    get activeSearchButtonLabel(): string | null;
+    get activeSubButtons(): SearchSubButtonConfig[];
+    get shouldShowSubButtons(): boolean;
+    get hasActiveParentWithChildren(): boolean;
+    get areAllSelected(): boolean;
+    get activeChildrenCount(): number;
+    get totalChildrenCount(): number;
+    get poiTypeCounts(): Map<number, number>;
+    get totalPoiTypeCount(): number;
+    get activePoiTypeId(): number | null;
+    handleSearchButtonClick(searchButtonId: string, caption?: string): void;
+    handleExtendedSearchButtonClick(buttonId: string): void;
+    handleMainButtonClick(buttonId: string): void;
+    handleSessionsClick(caption?: string): void;
+    togglePoiType(poiTypeId: number): void;
+    clearAllFilters(): void;
+    showSubButtons(parentButtonId: string): void;
+    hideSubButtons(): void;
+    handleSubButtonClick(subButtonId: string): void;
+    toggleChildFilter(childId: string): void;
+    clearPoiTypeFilters(): void;
+    clearAllChildFilters(): void;
+    setActiveParentId(parentId: string | null): void;
+    showShortcuts(visible: boolean): void;
+    clearChildren(): void;
+    setSubButtonId(buttonId: string | null): void;
+    setPoiFilterId(filterId: string | null): void;
+    getPoiTypeTotalCount(poiTypeId: number): number;
+    isChildActive(childId: string): boolean;
+    getActiveParent(): SearchButtonTypeConfig | null;
+}
+//# sourceMappingURL=SearchButtonsStore.d.ts.map