@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/store/details-events.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Publishes the SDK's `onDetails` event from the store's `details` selection.
+ *
+ * Lifted out of the legacy `Map` component, where it lived only because everything did: nothing
+ * here touches a renderer, and the event must fire in every mode — the MapLibre embed included,
+ * which unmounts the plan's own map entirely. Bound once per `load()`, beside the rest of the
+ * SDK wiring, and disposed with it.
+ * @returns A disposer.
+ */
+export declare function bindDetailsEvents(): () => void;
+//# sourceMappingURL=details-events.d.ts.map

package/dist/esm/store/details-events.js

@@ -0,0 +1,76 @@
+import { reaction } from 'mobx';
+import store, { uiState } from '../store';
+import settings from '../tools/settings';
+import { BoothBase } from './BoothStore';
+import { Category } from './CategoryStore';
+import { Exhibitor } from './ExhibitorStore';
+import { Route } from './RouteStore';
+/**
+ * Publishes the SDK's `onDetails` event from the store's `details` selection.
+ *
+ * Lifted out of the legacy `Map` component, where it lived only because everything did: nothing
+ * here touches a renderer, and the event must fire in every mode — the MapLibre embed included,
+ * which unmounts the plan's own map entirely. Bound once per `load()`, beside the rest of the
+ * SDK wiring, and disposed with it.
+ * @returns A disposer.
+ */
+export function bindDetailsEvents() {
+    return reaction(() => uiState.details, () => {
+        if (!uiState.onDetails)
+            return;
+        if (!uiState.details) {
+            // @ts-expect-error `null` is how the SDK has always signalled "details
+            // closed", but FloorPlanDetailsEvent never modelled it. Fixing the type
+            // is a public API change, so it is left for a deliberate decision.
+            uiState.onDetails(null);
+            return;
+        }
+        let details = uiState.details;
+        // @todo clear after event is complete
+        if (settings.EXPO === 'wineparis') {
+            if (details instanceof Exhibitor)
+                details = details.booths[0];
+            if (!details)
+                return;
+        }
+        let type = null;
+        let boothsNames = [];
+        if (details instanceof Exhibitor) {
+            type = 'exhibitor';
+            boothsNames = details.booths
+                .map((b) => b.name)
+                .sort((b1, b2) => b1 == store.routeStore.tempToBooth?.name
+                ? -1
+                : b2 == store.routeStore.tempToBooth?.name
+                    ? 1
+                    : 0);
+        }
+        else if (details instanceof BoothBase) {
+            type = 'booth';
+            boothsNames = [details.name];
+        }
+        else if (details instanceof Route) {
+            type = 'route';
+            boothsNames = [details.from?.name, details.to?.name].filter((name) => !!name);
+        }
+        else if (details instanceof Category) {
+            type = 'category';
+            boothsNames = details.exhibitors.map((e) => e.booths.map((b) => b.name)).flat();
+        }
+        const named = details;
+        const data = {
+            type: type,
+            name: named?.name,
+            id: named?.id,
+            externalId: named?.externalId,
+            boothsNames: boothsNames,
+        };
+        // @ts-expect-error `type` stays null when `details` is none of the four
+        // known shapes — FloorPlanDetailsEvent requires one of them. Same public
+        // API decision as the `onDetails(null)` call above.
+        uiState.onDetails({
+            ...data,
+            ...(type === 'route' ? { routeInfo: store.routeStore.routeInfo ?? undefined } : {}),
+        });
+    });
+}

package/dist/esm/store/floor-activated-notifier.d.ts

@@ -0,0 +1,18 @@
+import type { Floor, FloorPlan } from '../types';
+/** The slice of the public FloorPlan surface the notifier reads. */
+interface FloorActivationSource {
+    getFloors(): Floor[];
+    onFloorActivated?: (floor: Floor) => void;
+}
+/**
+ * Debounced `onFloorActivated` dispatch shared by the legacy floor path
+ * (LayerStore) and the venue-model path (VenueStore) so the embedder-facing
+ * behavior cannot drift between them: both defer one tick (so `getFloors()`
+ * reflects the settled state) and both skip the callback when the activated
+ * layer is not in the reported floors (e.g. scoped away mid-switch).
+ *
+ * Each store creates its own notifier — the debounce timeout is per-path.
+ */
+export declare function createFloorActivatedNotifier(): (fp: FloorActivationSource | Partial<FloorPlan> | undefined, layerName: string) => void;
+export {};
+//# sourceMappingURL=floor-activated-notifier.d.ts.map

package/dist/esm/store/floor-activated-notifier.js

@@ -0,0 +1,22 @@
+/**
+ * Debounced `onFloorActivated` dispatch shared by the legacy floor path
+ * (LayerStore) and the venue-model path (VenueStore) so the embedder-facing
+ * behavior cannot drift between them: both defer one tick (so `getFloors()`
+ * reflects the settled state) and both skip the callback when the activated
+ * layer is not in the reported floors (e.g. scoped away mid-switch).
+ *
+ * Each store creates its own notifier — the debounce timeout is per-path.
+ */
+export function createFloorActivatedNotifier() {
+    let timeout;
+    return (fp, layerName) => {
+        if (typeof fp?.onFloorActivated !== 'function' || typeof fp?.getFloors !== 'function')
+            return;
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            const floor = fp.getFloors().find((f) => f.name === layerName);
+            if (floor)
+                fp.onFloorActivated(floor);
+        });
+    };
+}

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

@@ -0,0 +1,3 @@
+export { store as default } from './live-store.js';
+export { boothStore, categoryStore, exhibitorStore, heatmapStore, intercomStore, layersStore, overlayStore, searchStore, toursStore, uiState, } from './live-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/store/index.js

@@ -0,0 +1,14 @@
+import { configure } from 'mobx';
+configure({ computedRequiresReaction: true });
+// The graph itself is built per plan by `store/create-live-plan.ts`, inside the
+// load path and strictly after the config singleton is swapped (ADR-0011). The
+// exports below forward to whichever graph is live, so importers see the fresh
+// event without changing, and see a thrown error instead of a dead one in the
+// window between `unstable_destroy()` and the next `load()`.
+//
+// Re-exported (rather than re-declared) so the bindings are live from the
+// moment `live-store` evaluates: `LayerStore` imports this barrel back, and a
+// locally declared `export default` would sit in its temporal dead zone for the
+// duration of that cycle.
+export { store as default } from './live-store.js';
+export { boothStore, categoryStore, exhibitorStore, heatmapStore, intercomStore, layersStore, overlayStore, searchStore, toursStore, uiState, } from './live-store.js';

package/dist/esm/store/init/index.d.ts

@@ -0,0 +1,3 @@
+import type RootStore from '../RootStore';
+export default function initStore(store: RootStore): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/store/init/index.js

@@ -0,0 +1,20 @@
+import { iniAllBooths } from './init-booths';
+import initCategories from './init-categories';
+import InitEvents from './init-events';
+import initExhibitors from './init-exhibitors';
+import { initHeatmap } from './init-heatmap';
+import initLayers from './init-layers';
+import { initPoiTypes } from './init-poiTypes';
+import initSpeakers from './init-speakers';
+import initUi from './init-ui';
+export default function initStore(store) {
+    initLayers(store);
+    InitEvents(store);
+    initSpeakers(store);
+    initExhibitors(store);
+    initCategories(store);
+    initPoiTypes(store);
+    iniAllBooths(store);
+    initHeatmap(store);
+    initUi(store);
+}

package/dist/esm/store/init/init-booths.d.ts

@@ -0,0 +1,6 @@
+import { type Booth } from '../BoothStore';
+import { type Layer } from '../LayerStore';
+import type RootStore from '../RootStore';
+export declare function iniAllBooths(store: RootStore): void;
+export default function initBooths(store: RootStore, layer: Layer): Booth[];
+//# sourceMappingURL=init-booths.d.ts.map

package/dist/esm/store/init/init-booths.js

@@ -0,0 +1,306 @@
+import { Box, degToRad, radToDeg } from '@expofp/geometry';
+import Color from 'color';
+import * as d3 from 'd3-selection';
+import data from '../../data';
+import { getLayerSvg, getTrianglesFromFpPaths } from '../../data/svg';
+import { eventScopedCache } from '../../tools/event-scoped-cache.js';
+import { getNextId } from '../../tools/id';
+import logger from '../../tools/logger';
+import settings from '../../tools/settings';
+import { generateUniqueSlug } from '../../tools/slug';
+import { sortByName } from '../../utils';
+import { areLayersEnabled } from '../../utils/areLayersEnabled';
+import { getStorage, saveStorage } from '../../utils/entity-storage';
+import { extractMetaFromString } from '../../utils/extractMetaFromString';
+import { planAutorun } from '../../utils/plan-reactions.js';
+import { RegularBooth, SpecialBooth } from '../BoothStore';
+import { uiState } from '../index';
+// The name index `iniAllBooths` fills and `initBooths` matches SVG elements
+// against. Per event: it holds the live plan's booths, which a plain Map would
+// carry into the next event (ADR-0011).
+const boothsByName = eventScopedCache();
+export function iniAllBooths(store) {
+    boothsByName().clear();
+    const booths = [];
+    // let baseUrl = "https://expofp.github.io/expofp-assets/icons";
+    // let xhr = new XMLHttpRequest();
+    // xhr.open("GET", baseUrl + "/icons.json", false); // `false` делает запрос синхронным
+    // xhr.send();
+    // const poiIcons = JSON.parse(xhr.responseText).icons as { id: string; name: string }[];
+    // const poiTypes = store.poiTypeStore.poiTypes;
+    for (const raw of data.booths || []) {
+        const { text, meta } = extractMetaFromString(raw.name);
+        const b = (raw.special ? new SpecialBooth() : new RegularBooth());
+        Object.assign(b, raw);
+        b.meta = meta; // onto the store copy — the config's raw booth is frozen
+        b.slug = generateUniqueSlug(b.name);
+        boothsByName().set(b.name.toLowerCase(), b);
+        fixCbre(b);
+        const boothReg = b;
+        boothReg.exhibitors = [];
+        for (const exhibitorId of raw.exhibitors ?? []) {
+            const exhibitor = store.exhibitorStore.exhibitorById.get(exhibitorId);
+            if (exhibitor) {
+                boothReg.exhibitors.push(exhibitor);
+                exhibitor.booths.push(boothReg);
+            }
+        }
+        b.schedule = store.eventStore.eventItems.filter((s) => s.boothId === b.id);
+        // b.poiType = store.poiTypeStore.poiTypes.find((p) => p.id === raw.poiTypeId);
+        // if (b.poiType) {
+        //     b.poiIcon =
+        //         baseUrl +
+        //         "/" +
+        //         poiIcons.find((p) => p.name == poiTypes.find((pt) => pt.name === b.poiType.name)?.name)?.id +
+        //         ".svg";
+        //     console.info("poiIcon", b.poiIcon);
+        // }
+        b.name = text;
+        booths.push(b);
+    }
+    // sort booths by name
+    booths.sort((a, b) => {
+        return a.name.localeCompare(b.name, undefined, { sensitivity: 'base', numeric: true });
+    });
+    // sort booths of exhibitors
+    for (const e of store.exhibitorStore.exhibitors) {
+        sortByName(e.booths);
+    }
+    store.boothStore.booths = booths;
+    // (the old `delete data.booths` disposal is gone — the config is frozen and
+    // stays the single retained copy of the document either way)
+    logger.log('initBooths', store.boothStore.booths.length);
+    initBookmarked(store);
+}
+function initBookmarked(store) {
+    const bookmarks = getStorage('bookmarked');
+    const boothIds = bookmarks.booths || [];
+    const emptyBoothIds = boothIds.filter((id) => {
+        const booth = store.boothStore.boothById.get(id);
+        return booth && booth.exhibitors.length === 0;
+    });
+    store.boothStore.replaceBookmarked(emptyBoothIds);
+    planAutorun(() => {
+        const currentBookmarks = getStorage('bookmarked');
+        const bookmarkedBoothIds = store.boothStore.booths
+            .filter((b) => b.exhibitors.length === 0 && b.bookmarkedDirectly)
+            .map((x) => x.id);
+        saveStorage('bookmarked', {
+            exhibitors: currentBookmarks.exhibitors,
+            events: currentBookmarks.events,
+            speakers: currentBookmarks.speakers,
+            booths: bookmarkedBoothIds,
+        });
+    });
+}
+export default function initBooths(store, layer) {
+    const layerID = layer.name;
+    const { boothStore, layerStore } = store;
+    const layerBooths = [];
+    const layersEnabled = areLayersEnabled();
+    const d3Nodes = d3
+        .select(getLayerSvg(layer))
+        .selectAll(`[data-layer='${layerID}'] > [data-tagname='efp-booth'], [data-layer='${layerID}'] > g[id^=b], [data-layer='${layerID}'] > rect[id^=b]`)
+        .nodes();
+    for (const el of d3Nodes) {
+        const topLayerName = el.closest('svg > [data-layer]').getAttribute('data-layer');
+        if (!topLayerName)
+            continue;
+        let rect;
+        let pathsWithRect = false;
+        if (el.tagName === 'rect') {
+            rect = el;
+        }
+        else {
+            // find any rect
+            rect = Array.from(el.children).find((x) => x.tagName === 'rect');
+            pathsWithRect = rect === el.firstElementChild;
+            //if (!rect) continue;
+            // // expect rect to be last child
+            // rect = el.lastElementChild as SVGRectElement;
+            // if (!rect || rect.tagName !== 'rect') continue;
+        }
+        // An element with neither id nor data-name names no booth. Skipped rather
+        // than carried as an empty name: the "not found in the event data" path
+        // below would fabricate a booth under the `''` key, and a second such
+        // element would then find and re-push that same instance.
+        const boothName = el.id || el.getAttribute('data-name');
+        if (!boothName) {
+            logger.error('SVG booth element has neither id nor data-name:', el);
+            continue;
+        }
+        const idInSvg = boothName.substring(1).toLowerCase();
+        let booth = boothsByName().get(idInSvg);
+        let boothReg = booth instanceof RegularBooth ? booth : null;
+        const boothSpec = booth instanceof SpecialBooth ? booth : null;
+        if (!booth) {
+            logger.error('SVG booth rect not found in the event data:', idInSvg);
+            // create fake booth
+            booth = boothReg = new RegularBooth();
+            booth.id = getNextId();
+            booth.name = idInSvg.toUpperCase();
+            booth.slug = generateUniqueSlug(idInSvg);
+            booth.error = true;
+            booth.exhibitors = [];
+            boothsByName().set(idInSvg, booth);
+            layerBooths.push(booth);
+        }
+        else
+            layerBooths.push(booth);
+        // `layer` is declared non-nullable on the booth, but a layers-disabled plan
+        // (and an SVG layer with no matching store layer) has always assigned none
+        // set before the observable `layer`, so nothing reacting to that write
+        // reads a booth whose own layer is still unset
+        booth.innermostLayer = layersEnabled ? layer : undefined;
+        booth.layer = (layersEnabled ? layerStore.layers.find((l) => l.name === topLayerName) : null);
+        booth.borderColor =
+            rect?.getAttribute('stroke') || rect?.style.stroke || settings.boothBorderColor || '#FFFFFF';
+        booth.borderWidth = parseFloat(rect?.getAttribute('stroke-width') || rect?.style.strokeWidth);
+        if (isNaN(booth.borderWidth))
+            booth.borderWidth = boothStore.borderWidth;
+        if (!uiState.heatmap) {
+            booth.labelColor = rect?.getAttribute('data-label-color');
+        }
+        else {
+            const totalClicks = store.heatmapStore.getTotalClicksByBooth(booth);
+            const heatmapColor = Color(store.heatmapStore.getColorByClicks(totalClicks));
+            booth.labelColor = heatmapColor.darken(0.3).isLight() ? '#555' : '#fff';
+        }
+        // a booth with no rect is dropped further down ("not found in SVG")
+        booth.rect = (rect ? Box.fromSvg(rect) : null);
+        // Height of the booth's top surface, authored as a positive number. Plan space reads
+        // positive-up (the renderer's scene carries the z mirror), so it is stored as written — the
+        // single place `data-elev` is read. A booth built from paths rather than a <rect> has no
+        // attribute to read and stays at 0.
+        booth.elevation = parseFloat(rect?.dataset.elev ?? '') || 0;
+        booth.noLabels = !!rect?.dataset.nolabel || rect?.id.startsWith('no');
+        if (boothReg) {
+            boothReg.availColor =
+                el.getAttribute('data-avail-color') ||
+                    rect?.getAttribute('data-avail-color') ||
+                    boothReg.availColor;
+            boothReg.soldColor =
+                el.getAttribute('data-sold-color') ||
+                    rect?.getAttribute('data-sold-color') ||
+                    boothReg.soldColor;
+            boothReg.holdColor =
+                el.getAttribute('data-hold-color') ||
+                    rect?.getAttribute('data-hold-color') ||
+                    boothReg.holdColor;
+            // svg size is legacy, TODO: remove data-size attribute at 01-01-2022
+            boothReg.size = (data.dimensionless ? null : boothReg.size || el.getAttribute('data-size'));
+            //boothReg.price = boothReg.price; //el.getAttribute("data-price") ||
+            if (boothReg.status === 'reserved') {
+                boothReg.reserved = true;
+            }
+            else if (boothReg.status === 'onhold') {
+                boothReg.onHold = true;
+            }
+            //if (boothReg.reserved && boothReg.onHold) boothReg.reserved = false;
+        }
+        else if (boothSpec) {
+            // not a regular booth ⇒ a special one: the pair is exhaustive by
+            // construction (a booth missing from the event data is faked as regular)
+            boothSpec.color =
+                (parseInt(rect.getAttribute('data-poi-type') ?? '') > 0
+                    ? rect.style?.fill
+                    : el.getAttribute('data-color') || rect.getAttribute('data-color')) || boothSpec.color;
+        }
+        const transform = rect?.getAttribute('transform');
+        if (transform) {
+            const mt = transform.match(/translate\(([-0-9.]+) ([-0-9.]+)\) rotate\(([-0-9.]+)\)/);
+            if (mt) {
+                const rotate = parseFloat(mt[3]);
+                booth.rotate = degToRad(rotate);
+            }
+            else {
+                const mt = transform.match(/rotate\(([-0-9.]+).*\)/);
+                if (mt) {
+                    const rotate = parseFloat(mt[1]);
+                    booth.rotate = degToRad(rotate);
+                }
+                else {
+                    const mm = transform.match(/matrix\(\s*([-0-9.]+)\s*(?:,|\s)\s*([-0-9.]+)\s*(?:,|\s)\s*([-0-9.]+)\s*(?:,|\s)\s*([-0-9.]+)\s*(?:,|\s)\s*([-0-9.]+)\s*(?:,|\s)\s*([-0-9.]+)\s*\)/);
+                    if (mm) {
+                        booth.rotate = Math.asin(parseFloat(mm[2]));
+                    }
+                }
+            }
+            // ET: this is a fix for Illustrator re-save (it can have large rotates)
+            const maxDegree = 180;
+            if (Math.abs(radToDeg(booth.rotate)) > maxDegree) {
+                // booth.rotate is now stored positive-clockwise (Task 4). Before
+                // the sign unification this subtracted 90° on the negated value;
+                // negated again at the render seam that was a net +90°, so under
+                // the positive convention the equivalent adjustment adds 90°.
+                booth.rotate += degToRad(90);
+                // also swap width and height of rect (about its center) — the
+                // Box equivalent of the legacy Rect.getRotated90().
+                const box = booth.rect;
+                booth.rect = new Box(box.center.x - box.size.height / 2, box.center.y - box.size.width / 2, box.size.height, box.size.width);
+            }
+        }
+        if (el.tagName === 'g') {
+            booth.paths = [];
+            booth.pathsWithRect = pathsWithRect;
+            const triangles = [];
+            for (const kid of d3.select(el).selectAll('path, rect').nodes()) {
+                if (kid.tagName === 'path') {
+                    const path = kid;
+                    if (path.tagName !== 'path')
+                        continue;
+                    const d = parseInt(path.getAttribute('data-index') ?? '');
+                    const unblinking = !!path.getAttribute('data-unblinking');
+                    booth.paths.push({
+                        index: d,
+                        color: path.style.fill,
+                        unblinking,
+                    });
+                    if (!rect) {
+                        triangles.push(...getTrianglesFromFpPaths(d, layerID));
+                    }
+                }
+            }
+            if (triangles.length) {
+                const allVertices = triangles.flatMap((t) => t.map((p) => ({ x: p[0], y: p[1] })));
+                booth.rect = Box.fromPoints(allVertices);
+                booth.noLabels = true;
+            }
+        }
+    }
+    // Filtered, not spliced in place: splicing the array being iterated skipped
+    // the element after every removal, so a run of rect-less booths left some of
+    // them in the layer — unwired (`store` never assigned) and with a null rect
+    // the Booth type declares non-null, which the first reader dereferences.
+    const placedBooths = layerBooths.filter((b) => {
+        if (b.rect)
+            return true;
+        logger.error('event data booth not found in SVG:', b.name, b);
+        return false;
+    });
+    for (const b of placedBooths) {
+        // `store` is protected on Booth — init wires it from outside on purpose
+        b.store = boothStore;
+    }
+    return placedBooths;
+}
+function fixCbre(b) {
+    if (settings.EXPO === 'cbresupplypartner') {
+        if (b instanceof RegularBooth && !b.availColor && b.type) {
+            if (b.type.indexOf('Premium A - 2m height restriction Passport') !== -1)
+                b.availColor = '#939393';
+            else if (b.type.indexOf('No free-standing') !== -1)
+                b.availColor = '#BA3DC8';
+            else if (b.type.endsWith('Passport'))
+                b.availColor = '#939393';
+            else if (b.type.startsWith('Premium A - 2m'))
+                b.availColor = '#FF9E4E';
+            else if (b.type.startsWith('Premium A - 4m'))
+                b.availColor = '#EA4335';
+            else if (b.type.startsWith('Premium B - 2m'))
+                b.availColor = '#523BC0';
+            else if (b.type.startsWith('Premium C - 2.4m'))
+                b.availColor = '#3ECC78';
+        }
+    }
+}

package/dist/esm/store/init/init-categories.d.ts

@@ -0,0 +1,3 @@
+import type RootStore from '../RootStore';
+export default function initCategories(store: RootStore): void;
+//# sourceMappingURL=init-categories.d.ts.map

package/dist/esm/store/init/init-categories.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+/* eslint-disable import/no-duplicates -- default type-only import can't be inline-merged with the value import */
+import data from '../../data';
+import logger from '../../tools/logger';
+import { generateUniqueSlug } from '../../tools/slug';
+import { Category } from '../CategoryStore';
+export default function initCategories(store) {
+    const { categoryStore, exhibitorStore } = store;
+    for (const b of data.categories || []) {
+        const c = new Category();
+        Object.assign(c, b);
+        c.exhibitors = [];
+        c.slug = generateUniqueSlug(c.name);
+        for (const e of data.exhibitors || []) {
+            if (e.categories.filter((ec) => ec === b.id)[0]) {
+                const ex = exhibitorStore.exhibitorById.get(e.id);
+                ex.categories.push(c);
+                c.exhibitors.push(ex);
+            }
+        }
+        c['store'] = categoryStore;
+        categoryStore.categories.push(c);
+    }
+    // (categoryStore.categoryById as Map<number, Category>) = new Map<number, Category>(categoryStore.categories.map(c => [c.id, c]));
+    // (the old `delete data.categories/exhibitors` disposal is gone — the config
+    // is frozen and stays the single retained copy of the document either way)
+    logger.log('initCategories', categoryStore.categories.length);
+}

package/dist/esm/store/init/init-events.d.ts

@@ -0,0 +1,3 @@
+import RootStore from '../RootStore';
+export default function initEvents(store: RootStore): void;
+//# sourceMappingURL=init-events.d.ts.map

package/dist/esm/store/init/init-events.js

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// @ts-nocheck
+import data from '../../data';
+import logger from '../../tools/logger';
+import { getStorage, saveStorage } from '../../utils/entity-storage';
+import { planAutorun } from '../../utils/plan-reactions.js';
+import { EventItem } from '../EventStore';
+export default function initEvents(store) {
+    data.events?.forEach((e) => {
+        // speaker photos / event logos arrive already resolved by @expofp/config;
+        // spread each (frozen) speaker into a store-owned copy
+        const processedSpeakers = (e.speakers || []).map((speaker) => store.speakerStore.addSpeaker({ ...speaker }));
+        const eI = new EventItem(e.id, e.externalId || e.id.toString(), e.boothId, e.name || `Event ${e.id}`, e.description || '', e.startDate, e.endDate, e.logoFile, processedSpeakers, e.tracks || []);
+        store.eventStore.eventItems.push(eI);
+    });
+    logger.log('initEvents', store.eventStore.eventItems.length);
+    logger.log('initSpeakers', store.speakerStore.speakersMap.size);
+    initBookmarked(store.eventStore);
+    initVisited(store.eventStore);
+}
+function initVisited(eventStore) {
+    const visitedStorage = getStorage('visited');
+    eventStore.replaceVisited(visitedStorage.events);
+    planAutorun(() => {
+        const currentData = getStorage('visited');
+        saveStorage('visited', {
+            exhibitors: currentData.exhibitors,
+            events: eventStore.visited.map((x) => x.id),
+        });
+    });
+}
+function initBookmarked(eventStore) {
+    const bookmarks = getStorage('bookmarked');
+    eventStore.replaceBookmarked(bookmarks.events);
+    planAutorun(() => {
+        const currentBookmarks = getStorage('bookmarked');
+        saveStorage('bookmarked', {
+            exhibitors: currentBookmarks.exhibitors,
+            events: eventStore.bookmarked?.map((x) => x.id),
+            speakers: currentBookmarks.speakers,
+            booths: currentBookmarks.booths,
+        });
+    });
+}

package/dist/esm/store/init/init-exhibitors.d.ts

@@ -0,0 +1,3 @@
+import RootStore from '../RootStore';
+export default function initExhibitors(store: RootStore): void;
+//# sourceMappingURL=init-exhibitors.d.ts.map

package/dist/esm/store/init/init-exhibitors.js

@@ -0,0 +1,71 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import data from '../../data';
+import logger from '../../tools/logger';
+import { generateUniqueSlug } from '../../tools/slug';
+import { getStorage, saveStorage } from '../../utils/entity-storage';
+import { planAutorun } from '../../utils/plan-reactions.js';
+import getPreviewExhibitor from '../../utils/preview-exhibitor.js';
+import { Exhibitor, RebookingState } from '../ExhibitorStore';
+export default function initExhibitors(store) {
+    /// TODO: remove this
+    // data.exhibitors.sort(function (a: RawExhibitor, b: RawExhibitor) {
+    //     var x = (a.featured ? "0" : "1") + a.name.toLowerCase();
+    //     var y = (b.featured ? "0" : "1") + b.name.toLowerCase();
+    //     return x < y ? -1 : x > y ? 1 : 0;
+    // });
+    const { exhibitorStore } = store;
+    // the config's document is frozen — sort (and preview-splice) a copy
+    const rawExhibitors = [...(data.exhibitors || [])];
+    const previewExhibitor = getPreviewExhibitor();
+    if (previewExhibitor) {
+        const i = rawExhibitors.findIndex((e) => e.id === previewExhibitor.id);
+        if (i !== -1)
+            rawExhibitors.splice(i, 1, previewExhibitor);
+        else
+            rawExhibitors.push(previewExhibitor);
+    }
+    rawExhibitors.sort((a, b) => Number(b.featured) - Number(a.featured));
+    for (const raw of rawExhibitors) {
+        const e = new Exhibitor();
+        Object.assign(e, raw);
+        e.slug = generateUniqueSlug(e.name);
+        e.rebookingState = e.rebookingState || RebookingState.Unasked;
+        // asset URLs (logo, gallery, marketMaterials, leadingImageUrl) arrive
+        // already resolved by @expofp/config
+        e.categories = [];
+        e.booths = [];
+        //e.logoInBooth = true;
+        e['store'] = exhibitorStore;
+        exhibitorStore.exhibitors.push(e);
+        e.schedule = null;
+    }
+    // dispose
+    logger.log('initExhibitors', exhibitorStore.exhibitors.length);
+    initBookmarked(exhibitorStore);
+    initVisited(exhibitorStore);
+}
+function initBookmarked(exhibitorStore) {
+    const bookmarks = getStorage('bookmarked');
+    exhibitorStore.replaceBookmarked(bookmarks.exhibitors);
+    planAutorun(() => {
+        const currentBookmarks = getStorage('bookmarked');
+        saveStorage('bookmarked', {
+            exhibitors: exhibitorStore.bookmarked?.map((x) => x.id),
+            events: currentBookmarks.events,
+            speakers: currentBookmarks.speakers,
+            booths: currentBookmarks.booths,
+        });
+    });
+}
+function initVisited(exhibitorStore) {
+    const visitedStorage = getStorage('visited');
+    exhibitorStore.replaceVisited(visitedStorage.exhibitors);
+    planAutorun(() => {
+        const currentData = getStorage('visited');
+        saveStorage('visited', {
+            exhibitors: exhibitorStore.visited.map((x) => x.id),
+            events: currentData.events,
+        });
+    });
+}

package/dist/esm/store/init/init-heatmap.d.ts

@@ -0,0 +1,3 @@
+import type RootStore from '../RootStore';
+export declare function initHeatmap(store: RootStore): void;
+//# sourceMappingURL=init-heatmap.d.ts.map