@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/components/JourneyPanel.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './JourneyPanel.scss';
+import { Button } from '@expofp/ui';
+import classNames from 'classnames';
+import { formatConnectorDistance, journeyStages, } from '../journey';
+import { t } from '../utils/i18n';
+import RouteQR from './RouteQR';
+const unescaped = { interpolation: { escapeValue: false } };
+const PROVIDER_NAMES = {
+    apple: 'Apple Maps',
+    google: 'Google Maps',
+};
+function startPlace(origin) {
+    const role = origin.kind === 'kiosk-anchor'
+        ? t('You are here')
+        : origin.kind === 'live-position'
+            ? t('Your location')
+            : t('Starting point');
+    return { name: origin.name, role, variant: 'start' };
+}
+function placeAfter(journey, leg) {
+    if (leg.kind === 'exit')
+        return { name: leg.label, role: t('Exit'), variant: 'door' };
+    if (leg.kind === 'arrival')
+        return { name: journey.destinationName, role: t('Destination'), variant: 'finish' };
+    return leg.target.kind === 'venue-entrance'
+        ? { name: leg.target.label, role: t('Entrance'), variant: 'door' }
+        : { name: journey.destinationName, role: t('Destination'), variant: 'finish' };
+}
+const indoorLegTitle = (leg) => leg.kind === 'exit' ? t('Walk to the exit') : t('Walk to your booth');
+const lineClass = ({ leg, state }, stub) => classNames('efp-journeyPanel__line', `efp-journeyPanel__line--${state}`, {
+    'efp-journeyPanel__line--street': leg.kind === 'external',
+    'efp-journeyPanel__line--stub': stub,
+});
+const PlaceRow = ({ place, state, arriving, leaving }) => (_jsxs("div", { className: "efp-journeyPanel__row", children: [_jsxs("span", { className: "efp-journeyPanel__rail", "aria-hidden": "true", children: [arriving && _jsx("i", { className: lineClass(arriving, true) }), _jsx("span", { className: classNames('efp-journeyPanel__marker', `efp-journeyPanel__marker--${place.variant}`, `efp-journeyPanel__marker--${state}`) }), leaving && _jsx("i", { className: lineClass(leaving) })] }), _jsxs("span", { className: classNames('efp-journeyPanel__place', `efp-journeyPanel__place--${state}`), children: [_jsx("span", { className: "efp-journeyPanel__placeName", children: place.name }), _jsx("span", { className: "efp-journeyPanel__placeRole", children: place.role })] })] }));
+const StreetLeg = ({ leg, state, planUnits, onHandoff }) => {
+    const distance = formatConnectorDistance(leg.connector.distanceMeters, planUnits);
+    return (_jsxs("span", { className: classNames('efp-journeyPanel__street', `efp-journeyPanel__street--${state}`), children: [_jsxs("span", { className: "efp-journeyPanel__streetMeta", children: [_jsx("i", { className: "efp-journeyPanel__legIcon efp-journeyPanel__legIcon--street", "aria-hidden": "true" }), distance && _jsx("span", { className: "efp-journeyPanel__distance", children: distance }), _jsx("span", { className: "efp-journeyPanel__provider", children: PROVIDER_NAMES[leg.provider] })] }), _jsxs(Button, { link: leg.url, target: "_blank", size: "md", onClick: onHandoff, children: [t('Continue in Maps'), _jsx("i", { className: "icon-link-external", "aria-hidden": "true" })] })] }));
+};
+/**
+ * The journey a disconnected pair of places gets instead of a dead end: the two
+ * places, the legs between them in walking order with the current one marked,
+ * and the external handoff — always a deliberate user action, never automatic
+ * (ADR-0010).
+ *
+ * Either end may be a venue or an outdoor PoI, so no sentence the visitor reads
+ * classifies an end: the note speaks only of the distance, and each place row
+ * gives a place's name and its role in the trip rather than what kind it is.
+ * The title's `{{venue}}` placeholder is the deliberate exception — it is a
+ * translation key, not text on screen.
+ *
+ * A journey of one leg is as ordinary as a journey of three: a plan that
+ * authored no doors has no indoor legs to show, and the list simply says the
+ * one thing there is to do.
+ */
+const JourneyPanel = ({ journey, stage, planUnits, legWalk, deepLinkUrl, onExternalHandoff, }) => {
+    const legs = journey.legs;
+    const stages = journeyStages(journey);
+    const current = stage && stages.includes(stage) ? stage : stages[0];
+    const currentIndex = current ? stages.indexOf(current) : 0;
+    const stateAt = (index) => index < currentIndex ? 'done' : index === currentIndex ? 'current' : 'upcoming';
+    const railLegAt = (index) => {
+        const leg = legs[index];
+        return leg && { leg, state: stateAt(index) };
+    };
+    return (_jsxs("div", { className: "efp-journeyPanel", children: [_jsxs("div", { className: "efp-journeyPanel__header", children: [_jsx("p", { className: "efp-journeyPanel__title", children: t('Your trip to {{venue}}', { venue: journey.destinationName, ...unescaped }) }), _jsx("p", { className: "efp-journeyPanel__note", children: t('This trip is too far to walk on the plan.') })] }), _jsx(PlaceRow, { place: startPlace(journey.origin), state: stateAt(0), leaving: railLegAt(0) }), _jsx("ol", { className: "efp-journeyPanel__steps", children: legs.map((leg, index) => (_jsxs("li", { className: "efp-journeyPanel__step", "aria-current": index === currentIndex ? 'step' : undefined, children: [_jsxs("div", { className: "efp-journeyPanel__row", children: [_jsx("span", { className: "efp-journeyPanel__rail", "aria-hidden": "true", children: _jsx("i", { className: lineClass({ leg, state: stateAt(index) }) }) }), leg.kind === 'external' ? (_jsx(StreetLeg, { leg: leg, state: stateAt(index), planUnits: planUnits, onHandoff: onExternalHandoff })) : (_jsxs("span", { className: classNames('efp-journeyPanel__leg', `efp-journeyPanel__leg--${stateAt(index)}`), children: [_jsx("i", { className: "efp-journeyPanel__legIcon efp-journeyPanel__legIcon--walk", "aria-hidden": "true" }), indoorLegTitle(leg), legWalk && index === currentIndex && (_jsx("span", { className: "efp-journeyPanel__legWalk", children: legWalk }))] }))] }), _jsx(PlaceRow, { place: placeAfter(journey, leg), state: stateAt(index + 1), arriving: { leg, state: stateAt(index) }, leaving: railLegAt(index + 1) })] }, leg.kind))) }), deepLinkUrl && (_jsx("div", { className: "efp-journeyPanel__handoff", children: _jsx(RouteQR, { url: deepLinkUrl, label: t('Scan to continue this journey on your phone'), ariaLabel: t('QR code to continue this journey on your phone') }) }))] }));
+};
+export default JourneyPanel;

package/dist/esm/components/Kiosk/KioskStore.d.ts

@@ -0,0 +1,60 @@
+import { type AlertProps } from '@expofp/ui';
+import { type Kiosk, type StatusMessage } from './SetKiosk';
+import { type SetKioskChangeEvent } from './SetKiosk/types';
+declare class KioskStore {
+    get kiosk(): Kiosk | null;
+    setKiosk(kiosk: Kiosk | null): void;
+    private getCameraState;
+    savedKiosk: Kiosk | null;
+    get hasUnsavedChanges(): boolean;
+    statusMessages: StatusMessage[];
+    addStatusMessage(message: Omit<AlertProps, 'closeLabel'>): void;
+    clearStatusMessages(): void;
+    statusMessageTimer: number;
+    startCleanupMessages(): void;
+    private isResettingCamera;
+    /**
+     * Set while a restore's own camera movement is still to be heard about, and consumed by the settle
+     * it ends with — see {@link handleNavigationChange}. Assigned from what the restore reports it
+     * moved, so a panel opened with no camera at all does not read the operator's first move as the
+     * restore's.
+     */
+    private isRestoringFraming;
+    resetCamera(): Promise<void>;
+    /**
+     * Restores the home framing in map mode. The kiosk is integrated at page load,
+     * well before the map has finished loading, so wait for the camera port rather
+     * than giving up on the first miss. Returns false when there was no map camera
+     * to restore through.
+     */
+    private resetMaplibreCamera;
+    private waitForMaplibreCameraPort;
+    /**
+     * Restores the home framing on the floor plan. The plan's own camera takes it whenever it is up;
+     * without one mounted there is nothing to move.
+     * @returns Whether there was a camera to move.
+     */
+    private resetPlanCamera;
+    restoreData(): void;
+    handleSetupReady(): void;
+    handleClose(): void;
+    handleDelete(): void;
+    handleSave(): void;
+    delayChange(cb: () => void): void;
+    handleChange(event: SetKioskChangeEvent): void;
+    initialPtScale?: number;
+    /**
+     * Records the pixel size the plan booted at in this session. Not written into the saved record
+     * here: `getCameraState` saves it together with `mapPtScale`, so the two always share a unit.
+     * @param ptscale - The plan's pixel size.
+     */
+    setInitialPtScale(ptscale: number): void;
+    handleClick(point: {
+        x: number;
+        y: number;
+    }): void;
+    handleNavigationChange(): void;
+}
+declare const _default: KioskStore;
+export default _default;
+//# sourceMappingURL=KioskStore.d.ts.map

package/dist/esm/components/Kiosk/KioskStore.js

@@ -0,0 +1,411 @@
+import { __decorate } from "tslib";
+import { getConfig } from '@expofp/config';
+import { action, computed, observable, toJS, when } from 'mobx';
+import { KIOSK_ENABLE_KEY } from '../../constants';
+import store from '../../store';
+import { areLayersEnabled } from '../../utils/areLayersEnabled';
+import { t } from '../../utils/i18n';
+import { isLocalStorageAvailable } from '../../utils/localStorage';
+import { mapCamera } from '../Map/camera';
+import { mapViewport } from '../Map/viewport';
+import { storedKioskMode } from './kiosk-mode';
+import { getPtScaleZoomRatio, toFiniteNumber } from './kiosk-record';
+import { updateKiosk } from './kioskApi';
+import { getSavedKiosk, removeKiosk, saveKiosk, } from './SetKiosk';
+import { KIOSK_STORAGE_KEY } from './SetKiosk/constants';
+// How long a map-mode camera restore waits for the map to finish loading before
+// giving up. Generous: the first load fetches a style and tiles over the venue's
+// network, and a kiosk that restores late still beats one that never restores.
+const MAP_CAMERA_PORT_TIMEOUT_MS = 20000;
+class KioskStore {
+    constructor() {
+        this.savedKiosk = null;
+        this.statusMessages = [];
+        this.statusMessageTimer = 0;
+        this.isResettingCamera = false;
+        /**
+         * Set while a restore's own camera movement is still to be heard about, and consumed by the settle
+         * it ends with — see {@link handleNavigationChange}. Assigned from what the restore reports it
+         * moved, so a panel opened with no camera at all does not read the operator's first move as the
+         * restore's.
+         */
+        this.isRestoringFraming = false;
+    }
+    get kiosk() {
+        return store.uiState.kioskData;
+    }
+    setKiosk(kiosk) {
+        store.uiState.setKioskData(kiosk);
+    }
+    getCameraState() {
+        // In map mode the plan renders in external mode and mounts no camera of its
+        // own — capture the map's camera instead and leave the plan fields on
+        // whatever they already held.
+        if (store.maplibreStore.showMaplibre) {
+            const mapCamera = store.maplibreStore.cameraPort?.getCameraState();
+            if (!mapCamera)
+                return {};
+            return {
+                mapCenterLng: mapCamera.lng,
+                mapCenterLat: mapCamera.lat,
+                mapZoom: mapCamera.zoom,
+                mapBearingDegrees: mapCamera.bearing,
+                mapPitchDegrees: mapCamera.pitch,
+            };
+        }
+        const cameraState = mapCamera()?.state();
+        if (!cameraState)
+            return {};
+        return {
+            mapInitialPtScale: this.initialPtScale,
+            mapPtScale: cameraState.pixelSize,
+            mapCenterX: cameraState.center.x,
+            mapCenterY: cameraState.center.y,
+            mapRollDegrees: cameraState.roll,
+            mapPitch: cameraState.pitch,
+        };
+    }
+    get hasUnsavedChanges() {
+        const savedKiosk = this.savedKiosk;
+        const kiosk = toJS(this.kiosk);
+        if (!kiosk || !savedKiosk) {
+            return !!kiosk !== !!savedKiosk;
+        }
+        const savedKeys = Object.keys(savedKiosk);
+        const currentKeys = Object.keys(kiosk);
+        if (savedKeys.length !== currentKeys.length) {
+            return true;
+        }
+        for (const key of savedKeys) {
+            if (!(key in kiosk) || savedKiosk[key] !== kiosk[key]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    addStatusMessage(message) {
+        this.statusMessages = [{ ...message, id: Date.now() }];
+        this.startCleanupMessages();
+    }
+    clearStatusMessages() {
+        this.statusMessages = [];
+    }
+    startCleanupMessages() {
+        clearTimeout(this.statusMessageTimer);
+        this.statusMessageTimer = window.setTimeout(() => this.clearStatusMessages(), 1000);
+    }
+    async resetCamera() {
+        if (this.isResettingCamera)
+            return;
+        this.isResettingCamera = true;
+        try {
+            // Not `else` — the map branch reports back when it could not restore (the
+            // map never came up, or a style error dropped the view back to the plan
+            // renderer while we waited), and the plan branch takes over rather than
+            // the reset being lost. In map mode the plan mounts no camera, so the
+            // fall-through is a no-op if we are still on the map.
+            if (store.maplibreStore.showMaplibre && (await this.resetMaplibreCamera())) {
+                this.isRestoringFraming = true;
+                return;
+            }
+            this.isRestoringFraming = await this.resetPlanCamera();
+        }
+        finally {
+            this.isResettingCamera = false;
+        }
+    }
+    /**
+     * Restores the home framing in map mode. The kiosk is integrated at page load,
+     * well before the map has finished loading, so wait for the camera port rather
+     * than giving up on the first miss. Returns false when there was no map camera
+     * to restore through.
+     */
+    async resetMaplibreCamera() {
+        const port = await this.waitForMaplibreCameraPort();
+        if (!port)
+            return false;
+        const kiosk = this.kiosk;
+        if (kiosk?.z != null) {
+            store.fp.activateFloor({ name: String(kiosk.z) });
+        }
+        const lng = toFiniteNumber(kiosk?.mapCenterLng);
+        const lat = toFiniteNumber(kiosk?.mapCenterLat);
+        const zoom = toFiniteNumber(kiosk?.mapZoom);
+        if (lng === undefined || lat === undefined || zoom === undefined) {
+            // Set up on the plan renderer, or saved by a build that could not capture
+            // the map camera at all — there is no map framing to go home to, so fit
+            // the venue. That path moves center/zoom/bearing only, so level the pitch
+            // first; a map3d kiosk would otherwise keep the visitor's tilt.
+            port.resetPitch();
+            store.uiState.fitBounds();
+            return true;
+        }
+        port.applyCameraState({
+            lng,
+            lat,
+            zoom,
+            bearing: toFiniteNumber(kiosk?.mapBearingDegrees),
+            pitch: toFiniteNumber(kiosk?.mapPitchDegrees),
+        });
+        return true;
+    }
+    async waitForMaplibreCameraPort() {
+        const { maplibreStore } = store;
+        if (maplibreStore.cameraPort)
+            return maplibreStore.cameraPort;
+        try {
+            // Raced against the view leaving map mode: a style error flips back to the
+            // plan renderer (handleMapLoadError), after which the port never arrives —
+            // waiting out the full timeout there would swallow the reset for 20s and
+            // then drop it.
+            await when(() => !!maplibreStore.cameraPort || !maplibreStore.showMaplibre, {
+                timeout: MAP_CAMERA_PORT_TIMEOUT_MS,
+            });
+        }
+        catch {
+            // Timed out: still in map mode, but the map never finished loading.
+            return null;
+        }
+        return maplibreStore.cameraPort;
+    }
+    /**
+     * Restores the home framing on the floor plan. The plan's own camera takes it whenever it is up;
+     * without one mounted there is nothing to move.
+     * @returns Whether there was a camera to move.
+     */
+    async resetPlanCamera() {
+        const camera = mapCamera();
+        if (!camera)
+            return false;
+        const kiosk = this.kiosk;
+        await camera.api.reset({ pan: true, zoom: true, roll: true, pitch: true }, { immediate: true });
+        if (kiosk?.z != null) {
+            store.fp.activateFloor({ name: String(kiosk.z) });
+        }
+        const zoomRatio = getPtScaleZoomRatio(kiosk);
+        if (zoomRatio !== undefined) {
+            await camera.api.zoomBy(zoomRatio, { immediate: true });
+        }
+        const centerX = toFiniteNumber(kiosk?.mapCenterX);
+        const centerY = toFiniteNumber(kiosk?.mapCenterY);
+        if (centerX !== undefined && centerY !== undefined) {
+            await camera.api.panTo({ x: centerX, y: centerY }, { immediate: true });
+        }
+        const roll = toFiniteNumber(kiosk?.mapRollDegrees);
+        if (roll !== undefined) {
+            await camera.api.rollTo(roll, { immediate: true });
+        }
+        // `reset` above levelled the plan to `minPitch`, which is the flattest the camera may lie and
+        // not the framing this kiosk was set up at. `handleSave` captures the tilt as `mapPitch`, in
+        // degrees like the roll beside it, so put it back. A kiosk saved before this was restored, or
+        // one set up face on, carries nothing here and stays level.
+        const pitch = toFiniteNumber(kiosk?.mapPitch);
+        if (pitch !== undefined) {
+            await camera.api.pitchTo(pitch, { immediate: true });
+        }
+        return true;
+    }
+    restoreData() {
+        const savedKiosk = getSavedKiosk();
+        // Assigned either way: a stale baseline would report a kiosk placed again as already saved.
+        this.savedKiosk = savedKiosk ?? null;
+        if (savedKiosk) {
+            this.setKiosk(savedKiosk);
+            store.uiState.kiosk = true;
+        }
+    }
+    handleSetupReady() {
+        this.restoreData();
+        store.uiState.kiosk = true;
+        store.uiState.hideFreeOrDemo = true;
+        store.uiState.setForceDim(true);
+        store.searchStore.setSearchText('');
+        store.searchStore.setFocused(false);
+        this.resetCamera();
+    }
+    handleClose() {
+        // The panel only previewed kiosk mode and the UI scale: go back to what the
+        // device says — the same question ShowKiosk answers when it mounts again a
+        // commit later. Asked without usable storage too: `storedKioskMode` still
+        // has the config anchor to answer from, and a device that cannot store a
+        // thing must not be the one device the panel is a one-way door on.
+        if (!storedKioskMode(getConfig())) {
+            store.uiState.kiosk = false;
+        }
+        store.uiState.restoreUIScale();
+        this.setKiosk(null);
+        store.uiState.setForceDim(false);
+        store.uiState.enableSetKioskMode(false);
+        store.searchStore.closeSearch();
+    }
+    handleDelete() {
+        // A deleted kiosk takes the stored `kiosk=1` with it; a `kiosk=0` opt-out stays. The record is
+        // read raw, so one too corrupt for getSavedKiosk() to parse still counts as one.
+        if (isLocalStorageAvailable &&
+            localStorage.getItem(KIOSK_STORAGE_KEY) !== null &&
+            localStorage.getItem(KIOSK_ENABLE_KEY) === '1') {
+            localStorage.removeItem(KIOSK_ENABLE_KEY);
+        }
+        removeKiosk();
+        this.savedKiosk = null;
+        this.setKiosk(null);
+        store.uiState.resetMapSettings();
+        store.uiState.resetUIScale();
+        this.addStatusMessage({ variant: 'success', title: t('Deleted') });
+    }
+    handleSave() {
+        // The plan's conversions, in whichever mode drew it: `getCameraState` below saves a kiosk from
+        // the MapLibre map as readily as from the plain plan, so the visibility check has to answer in
+        // both — which it does, the map's mount publishing these the same way the plan's does.
+        const viewport = mapViewport();
+        if (!viewport)
+            return;
+        const kiosk = toJS(this.kiosk);
+        if (!kiosk)
+            return;
+        const cameraState = this.getCameraState();
+        const newKiosk = {
+            ...kiosk,
+            ...cameraState,
+        };
+        // Named coordinates rather than the kiosk itself: a kiosk's `z` is the floor it stands on, a
+        // name, where a plan point's `z` is an elevation.
+        if (!viewport.isVisible({ x: newKiosk.x, y: newKiosk.y })) {
+            this.addStatusMessage({ variant: 'error', title: t('Kiosk not visible') });
+            return;
+        }
+        this.setKiosk(newKiosk);
+        saveKiosk(newKiosk);
+        // init-ui stores nothing from the panel, so the new kiosk's mode is stored here.
+        if (isLocalStorageAvailable) {
+            localStorage.setItem(KIOSK_ENABLE_KEY, '1');
+        }
+        updateKiosk(newKiosk, 'https://app.expofp.com/');
+        store.uiState.setKioskUIScale(newKiosk.uiScale, true);
+        this.addStatusMessage({ variant: 'success', title: t('Saved') });
+        this.savedKiosk = newKiosk;
+    }
+    delayChange(cb) {
+        requestAnimationFrame(() => cb?.());
+    }
+    handleChange(event) {
+        const kiosk = toJS(this.kiosk);
+        if (!kiosk) {
+            return;
+        }
+        if (Number.isFinite(event.angle)) {
+            this.setKiosk({ ...kiosk, heading: event.angle });
+        }
+        if (Number.isFinite(event.scale)) {
+            this.setKiosk({ ...kiosk, uiScale: event.scale });
+            this.delayChange(() => store.uiState.setKioskUIScale(event.scale, false));
+        }
+        if (Number.isFinite(event.percent)) {
+            this.setKiosk({ ...kiosk, iconSizePercent: event.percent });
+        }
+    }
+    /**
+     * Records the pixel size the plan booted at in this session. Not written into the saved record
+     * here: `getCameraState` saves it together with `mapPtScale`, so the two always share a unit.
+     * @param ptscale - The plan's pixel size.
+     */
+    setInitialPtScale(ptscale) {
+        if (this.initialPtScale) {
+            return;
+        }
+        this.initialPtScale = ptscale;
+    }
+    handleClick(point) {
+        const kiosk = toJS(this.kiosk);
+        const floors = store.fp.getFloors();
+        const z = areLayersEnabled() ? (floors.find((f) => f.active)?.name ?? null) : null;
+        const uiScale = store.uiState.uiScale;
+        this.setKiosk({
+            ...kiosk,
+            x: point.x,
+            y: point.y,
+            z,
+            uiScale: kiosk?.uiScale || uiScale,
+            heading: kiosk?.heading || 0,
+            iconSizePercent: kiosk?.iconSizePercent || 100,
+            ...this.getCameraState(),
+        });
+    }
+    handleNavigationChange() {
+        // Consumed here whatever else this settle turns out to be, so a restore that moved the camera
+        // while no kiosk was placed cannot leave the flag set for a later movement to trip over.
+        const isRestore = this.isRestoringFraming;
+        this.isRestoringFraming = false;
+        const kiosk = toJS(this.kiosk);
+        if (!kiosk) {
+            return;
+        }
+        const framing = this.getCameraState();
+        this.setKiosk({ ...kiosk, ...framing });
+        // A restore's own settle is the baseline the Save button measures against, not an edit: a
+        // restored kiosk does not report the numbers it was saved with — the reference pt-scale is
+        // captured afresh each session, and the plan restore levels the pitch — so comparing against the
+        // record as stored would open the panel claiming changes the operator never made. Only the first
+        // settle counts, so an operator quick enough to interrupt a restore mid-animation has that
+        // gesture read as the baseline and must move again; the alternative is every restore reading as
+        // an edit, every time.
+        if (isRestore && this.savedKiosk) {
+            this.savedKiosk = { ...this.savedKiosk, ...framing };
+        }
+    }
+}
+__decorate([
+    computed({ keepAlive: true })
+], KioskStore.prototype, "kiosk", null);
+__decorate([
+    action
+], KioskStore.prototype, "setKiosk", null);
+__decorate([
+    observable
+], KioskStore.prototype, "savedKiosk", void 0);
+__decorate([
+    computed({ keepAlive: true })
+], KioskStore.prototype, "hasUnsavedChanges", null);
+__decorate([
+    observable
+], KioskStore.prototype, "statusMessages", void 0);
+__decorate([
+    action
+], KioskStore.prototype, "addStatusMessage", null);
+__decorate([
+    action
+], KioskStore.prototype, "clearStatusMessages", null);
+__decorate([
+    action
+], KioskStore.prototype, "startCleanupMessages", null);
+__decorate([
+    action
+], KioskStore.prototype, "resetCamera", null);
+__decorate([
+    action
+], KioskStore.prototype, "restoreData", null);
+__decorate([
+    action
+], KioskStore.prototype, "handleSetupReady", null);
+__decorate([
+    action
+], KioskStore.prototype, "handleClose", null);
+__decorate([
+    action
+], KioskStore.prototype, "handleDelete", null);
+__decorate([
+    action
+], KioskStore.prototype, "handleSave", null);
+__decorate([
+    action
+], KioskStore.prototype, "handleChange", null);
+__decorate([
+    action
+], KioskStore.prototype, "setInitialPtScale", null);
+__decorate([
+    action
+], KioskStore.prototype, "handleClick", null);
+__decorate([
+    action
+], KioskStore.prototype, "handleNavigationChange", null);
+export default new KioskStore();

package/dist/esm/components/Kiosk/SetKiosk/Confirm/ConfirmDialog.d.ts

@@ -0,0 +1,5 @@
+import './ConfirmDialog.scss';
+import React from 'react';
+import { ConfirmDialogProps } from '../types';
+export declare function ConfirmDialog({ isDisabled, content, confirmLabel, cancelLabel, onConfirm, onCancel, confirmVariant, cancelVariant, }: ConfirmDialogProps): React.JSX.Element;
+//# sourceMappingURL=ConfirmDialog.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/Confirm/ConfirmDialog.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable  */
+// @ts-nocheck
+import './ConfirmDialog.scss';
+import { Button } from '@expofp/ui';
+export function ConfirmDialog({ isDisabled, content, confirmLabel, cancelLabel, onConfirm, onCancel, confirmVariant, cancelVariant, }) {
+    return (_jsxs("div", { className: "efp-confirm-dialog", children: [content && _jsx("div", { className: "efp-confirm-dialog__content", children: content }), _jsxs("div", { className: "efp-confirm-dialog__controls", children: [_jsx(Button, { size: "md", text: confirmLabel, onClick: onConfirm, disabled: isDisabled, variant: confirmVariant }), onCancel && (_jsx(Button, { size: "md", text: cancelLabel, variant: cancelVariant, onClick: onCancel, disabled: isDisabled }))] })] }));
+}

package/dist/esm/components/Kiosk/SetKiosk/FormInput/RangeInput.d.ts

@@ -0,0 +1,5 @@
+import './RangeInput.scss';
+import React from 'react';
+import { RangeInputProps } from '../types';
+export declare function RangeInput({ value, name, min, max, step, onChange, isDisabled, symbol, }: RangeInputProps): React.JSX.Element;
+//# sourceMappingURL=RangeInput.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/FormInput/RangeInput.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable  */
+// @ts-nocheck
+import './RangeInput.scss';
+import { t } from '../../../../utils/i18n';
+export function RangeInput({ value, name, min, max, step, onChange, isDisabled, symbol, }) {
+    const increase = () => onChange(Math.min(value + step, max));
+    const decrease = () => onChange(Math.max(value - step, min));
+    let percent = 0;
+    if (max !== min) {
+        percent = ((value - min) / (max - min)) * 100;
+    }
+    let translateX = '-50%';
+    if (percent === 0) {
+        translateX = '0';
+    }
+    else if (percent === 100) {
+        translateX = '-100%';
+    }
+    return (_jsxs("div", { className: "efp-range-input", children: [_jsxs("span", { className: "efp-range-input__header", children: [_jsx("button", { type: "button", className: "efp-range-input__control", draggable: "false", onClick: decrease, disabled: isDisabled, "aria-label": t('Decrease'), children: _jsx("i", { className: "icon-minus" }) }), _jsxs("span", { className: "efp-no-select", children: [name, ' ', _jsxs("strong", { children: [value, symbol ?? ''] })] }), _jsx("button", { type: "button", className: "efp-range-input__control", draggable: "false", onClick: increase, disabled: isDisabled, "aria-label": t('Increase'), children: _jsx("i", { className: "icon-plus" }) })] }), _jsxs("label", { className: "efp-range-input__input-block", children: [_jsx("input", { className: "efp-range-input__input", name: name, type: "range", min: min, max: max, step: step, value: value, disabled: isDisabled, onChange: (e) => onChange(Number(e.target.value)) }), _jsxs("span", { className: "efp-range-input__custom-input", children: [_jsx("span", { className: "efp-range-input__progress", style: { width: `${percent}%` } }), _jsx("span", { className: "efp-range-input__thumb", style: {
+                                    insetInlineStart: `${percent}%`,
+                                    transform: `translateX(${translateX}) translateY(-50%)`,
+                                } })] })] })] }));
+}

package/dist/esm/components/Kiosk/SetKiosk/Message/InfoMessage.d.ts

@@ -0,0 +1,5 @@
+import './InfoMessage.scss';
+import React from 'react';
+import { InfoMessageProps } from '../types';
+export declare function InfoMessage({ list }: InfoMessageProps): React.JSX.Element | null;
+//# sourceMappingURL=InfoMessage.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/Message/InfoMessage.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import './InfoMessage.scss';
+export function InfoMessage({ list }) {
+    return list?.length ? (_jsx("div", { className: "efp-info-message", children: list.map(({ id, image, content }) => (_jsxs("div", { className: "efp-info-message__item", children: [_jsx("img", { className: "efp-info-message__img", src: image.src, alt: image.alt, width: "30", height: "30" }), _jsx("span", { children: content })] }, id))) })) : null;
+}

package/dist/esm/components/Kiosk/SetKiosk/SetKioskComponent.d.ts

@@ -0,0 +1,5 @@
+import './SetKioskComponent.scss';
+import React from 'react';
+import { SetKioskProps } from './types';
+export default function SetKioskComponent({ isSaveDisabled, isDeleteDisabled, areControlsDisabled, confirmOnClose, angle, uiScale, minUiScale, maxUiScale, uiScaleStep, iconSizePercent, isInfoVisible, statusMessages, onClose, onDelete, onSave, onChange, }: SetKioskProps): React.JSX.Element;
+//# sourceMappingURL=SetKioskComponent.d.ts.map