@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/components/Kiosk/SetKiosk/SetKioskComponent.js

@@ -0,0 +1,78 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable  */
+// @ts-nocheck
+import './SetKioskComponent.scss';
+import { useState } from 'react';
+import baseRuntimeUrl from '../../../tools/base-runtime-url';
+import { Draggable } from '@expofp/ui';
+import { t } from '../../../utils/i18n';
+import { ConfirmDialog } from './Confirm/ConfirmDialog';
+import { InfoMessage } from './Message/InfoMessage';
+import { SetKioskForm } from './SetKioskForm';
+import SetKioskStatusMessages from './SetKioskStatusMessages';
+export default function SetKioskComponent({ isSaveDisabled, isDeleteDisabled, areControlsDisabled, confirmOnClose, angle, uiScale, minUiScale, maxUiScale, uiScaleStep, iconSizePercent, isInfoVisible, statusMessages, onClose, onDelete, onSave, onChange, }) {
+    const [confirmDialog, setConfirmDialog] = useState(null);
+    return (_jsx("div", { className: "efp-set-kiosk-mode-anchor", children: _jsxs(Draggable, { className: "efp-set-kiosk-mode", children: [_jsxs("div", { className: "efp-set-kiosk-mode__header", children: [_jsx("img", { src: `${baseRuntimeUrl}icons/dragdrop-solid.svg`, alt: t('Drag and Drop Icon'), width: "24", height: "24" }), _jsx("span", { className: "efp-no-select", children: confirmDialog ? confirmDialog.title : t('Set Kiosk') }), _jsx("button", { type: "button", draggable: "false", className: "efp-set-kiosk-mode__close", "aria-label": t('Close'), onClick: () => {
+                                const keepEditing = () => {
+                                    setConfirmDialog(null);
+                                };
+                                const close = () => {
+                                    onClose?.();
+                                    setConfirmDialog(null);
+                                };
+                                if (confirmDialog) {
+                                    keepEditing();
+                                }
+                                else if (confirmOnClose) {
+                                    setConfirmDialog({
+                                        title: t('Leave without saving?'),
+                                        content: (_jsxs("span", { children: [t('You have changes that '), _jsx("strong", { children: t("haven't been saved.") })] })),
+                                        confirmLabel: t('Keep editing'),
+                                        cancelLabel: t('Leave'),
+                                        onCancel: close,
+                                        onConfirm: keepEditing,
+                                        confirmVariant: 'primary',
+                                        cancelVariant: 'danger',
+                                    });
+                                }
+                                else {
+                                    close();
+                                }
+                            }, children: _jsx("i", { className: "icon-close" }) })] }), !confirmDialog && _jsx(SetKioskStatusMessages, { messages: statusMessages }), isInfoVisible ? (_jsx(InfoMessage, { list: [
+                        {
+                            id: '1',
+                            image: {
+                                src: `${baseRuntimeUrl}icons/tap.svg`,
+                                alt: t('Tap to set or move kiosk.'),
+                            },
+                            content: (_jsxs("span", { children: [t('Tap to '), _jsx("strong", { children: t('set or move') }), t(' kiosk.')] })),
+                        },
+                        {
+                            id: '2',
+                            image: {
+                                src: `${baseRuntimeUrl}icons/rotate.svg`,
+                                alt: t('Zoom and rotate the map before saving.'),
+                            },
+                            content: (_jsxs("span", { children: [_jsx("strong", { children: t('Zoom and rotate') }), t(' the map before saving.')] })),
+                        },
+                    ] })) : (_jsx(_Fragment, { children: confirmDialog ? (_jsx(ConfirmDialog, { ...confirmDialog })) : (_jsx(SetKioskForm, { isSaveDisabled: isSaveDisabled, isDeleteDisabled: isDeleteDisabled, areControlsDisabled: areControlsDisabled, onSave: () => {
+                            onSave?.();
+                            setConfirmDialog(null);
+                        }, onDelete: () => {
+                            setConfirmDialog({
+                                title: t('Delete kiosk?'),
+                                content: (_jsxs("span", { children: [t('Are you sure you want to '), _jsx("strong", { children: t('delete this kiosk?') })] })),
+                                confirmLabel: t('Cancel'),
+                                cancelLabel: t('Delete'),
+                                onConfirm: () => {
+                                    setConfirmDialog(null);
+                                },
+                                onCancel: () => {
+                                    onDelete?.();
+                                    setConfirmDialog(null);
+                                },
+                                confirmVariant: 'gray',
+                                cancelVariant: 'danger',
+                            });
+                        }, angle: angle, onRotateIcon: (angle) => onChange?.({ angle }), uiScale: uiScale, minUiScale: minUiScale, maxUiScale: maxUiScale, uiScaleStep: uiScaleStep, onUiScaleChange: (scale) => onChange?.({ scale }), iconSizePercent: iconSizePercent, onChangeIconSizePercent: (percent) => onChange?.({ percent }) })) }))] }) }));
+}

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

@@ -0,0 +1,5 @@
+import './SetKioskForm.scss';
+import React from 'react';
+import { SetKioskFormProps } from './types';
+export declare function SetKioskForm({ onSave, onDelete, isSaveDisabled, isDeleteDisabled, areControlsDisabled, angle, onRotateIcon, uiScale, minUiScale, maxUiScale, uiScaleStep, onUiScaleChange, iconSizePercent, onChangeIconSizePercent, }: SetKioskFormProps): React.JSX.Element;
+//# sourceMappingURL=SetKioskForm.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/SetKioskForm.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable  */
+// @ts-nocheck
+import './SetKioskForm.scss';
+import { Button } from '@expofp/ui';
+import { t } from '../../../utils/i18n';
+import { RangeInput } from './FormInput/RangeInput';
+export function SetKioskForm({ onSave, onDelete, isSaveDisabled, isDeleteDisabled, areControlsDisabled, angle, onRotateIcon, uiScale, minUiScale, maxUiScale, uiScaleStep, onUiScaleChange, iconSizePercent, onChangeIconSizePercent, }) {
+    return (_jsx("div", { className: "efp-set-kiosk-form", children: _jsxs("div", { className: "efp-set-kiosk-form__content", children: [_jsxs("div", { className: "efp-set-kiosk-form__inputs", children: [_jsx(RangeInput, { value: angle, name: t('Icon rotation'), min: 0, max: 360, step: 1, symbol: "\u00B0", isDisabled: areControlsDisabled, onChange: onRotateIcon }), _jsx(RangeInput, { value: iconSizePercent, name: t('Icon size'), min: 100, max: 300, step: 1, symbol: "%", isDisabled: areControlsDisabled, onChange: onChangeIconSizePercent }), _jsx(RangeInput, { value: Math.round(uiScale * 100), name: t('UI scale'), min: minUiScale * 100, max: maxUiScale * 100, step: uiScaleStep * 100, symbol: "%", isDisabled: areControlsDisabled, onChange: (percent) => onUiScaleChange(percent / 100) })] }), _jsxs("div", { className: "efp-set-kiosk-form__controls", children: [_jsx(Button, { size: "md", variant: "gray", text: t('Delete kiosk'), onClick: onDelete, disabled: isDeleteDisabled }), _jsx(Button, { size: "md", variant: "primary", text: t('Save'), onClick: onSave, disabled: isSaveDisabled })] })] }) }));
+}

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

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

package/dist/esm/components/Kiosk/SetKiosk/SetKioskStatusMessages.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import './SetKioskStatusMessages.scss';
+import classNames from 'classnames';
+export default function SetKioskStatusMessages({ messages }) {
+    return messages?.length ? (_jsx("div", { className: "efp-status-messages", children: messages.map(({ id, variant, title }) => {
+            const isSuccess = variant === 'success';
+            const isError = variant === 'error';
+            return (_jsxs("div", { className: classNames('efp-status-messages__message', {
+                    'efp-status-messages__message--success': isSuccess,
+                    'efp-status-messages__message--error': isError,
+                }), children: [isSuccess ? _jsx("i", { className: "icon-checkmark" }) : null, isError ? _jsx("i", { className: "icon-warning-solid" }) : null, title] }, id));
+        }) })) : null;
+}

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

@@ -0,0 +1,6 @@
+export declare const KIOSK_STORAGE_KEY = "expofp-kiosk";
+export declare const KIOSK_STATS_ID_STORAGE_KEY = "expofp-kiosk-stats-id";
+export declare const KIOSK_SLUG = "interactive-kiosk";
+export declare const KIOSK_NAME = "Your Location";
+export declare const KIOSK_URL_PARAM_PREFIX = "kiosk_";
+//# sourceMappingURL=constants.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/constants.js

@@ -0,0 +1,6 @@
+export const KIOSK_STORAGE_KEY = 'expofp-kiosk';
+// Backend id of the kiosk record, cached after `POST /api/kiosks`. Reused as the path id for updates.
+export const KIOSK_STATS_ID_STORAGE_KEY = 'expofp-kiosk-stats-id';
+export const KIOSK_SLUG = 'interactive-kiosk';
+export const KIOSK_NAME = 'Your Location';
+export const KIOSK_URL_PARAM_PREFIX = 'kiosk_';

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

@@ -0,0 +1,2 @@
+export declare function getKioskUrlParamKey(prop: string): string;
+//# sourceMappingURL=getKioskUrlParamKey.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/getKioskUrlParamKey.js

@@ -0,0 +1,4 @@
+import { KIOSK_URL_PARAM_PREFIX } from './constants';
+export function getKioskUrlParamKey(prop) {
+    return `${KIOSK_URL_PARAM_PREFIX}${prop}`;
+}

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

@@ -0,0 +1,2 @@
+export declare const getName: () => string;
+//# sourceMappingURL=getName.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/getName.js

@@ -0,0 +1,2 @@
+import { KIOSK_NAME } from './constants';
+export const getName = () => KIOSK_NAME;

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

@@ -0,0 +1,2 @@
+export declare const getSlug: () => string;
+//# sourceMappingURL=getSlug.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/getSlug.js

@@ -0,0 +1,2 @@
+import { KIOSK_SLUG } from './constants';
+export const getSlug = () => KIOSK_SLUG;

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

@@ -0,0 +1,7 @@
+export { default } from './SetKioskComponent';
+export type { Kiosk, StatusMessage, KioskMapState } from './types';
+export { getName } from './getName';
+export { getSlug } from './getSlug';
+export { getKioskUrlParamKey } from './getKioskUrlParamKey';
+export { saveKiosk, removeKiosk, getSavedKiosk } from './storage';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/index.js

@@ -0,0 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
+export { default } from './SetKioskComponent';
+export { getName } from './getName';
+export { getSlug } from './getSlug';
+export { getKioskUrlParamKey } from './getKioskUrlParamKey';
+export { saveKiosk, removeKiosk, getSavedKiosk } from './storage';

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

@@ -0,0 +1,5 @@
+import { Kiosk } from './types';
+export declare function saveKiosk(kiosk: Kiosk): Promise<void>;
+export declare function removeKiosk(): Promise<void>;
+export declare function getSavedKiosk(): Kiosk | undefined;
+//# sourceMappingURL=storage.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/storage.js

@@ -0,0 +1,21 @@
+/* eslint-disable  */
+import { KIOSK_STORAGE_KEY } from './constants';
+export async function saveKiosk(kiosk) {
+    localStorage.setItem(KIOSK_STORAGE_KEY, JSON.stringify(kiosk));
+}
+export async function removeKiosk() {
+    localStorage.removeItem(KIOSK_STORAGE_KEY);
+}
+export function getSavedKiosk() {
+    const savedKiosk = localStorage.getItem(KIOSK_STORAGE_KEY);
+    if (savedKiosk) {
+        try {
+            return JSON.parse(savedKiosk);
+        }
+        catch (err) {
+            console.warn(err);
+            return;
+        }
+    }
+    return;
+}

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

@@ -0,0 +1,109 @@
+import { type Kiosk as KioskData } from '@expofp/schema';
+import type { AlertProps, ButtonVariant } from '@expofp/ui';
+import { type ReactNode } from 'react';
+/**
+ * The saved camera framing — the camera subset of the kiosk record. The field
+ * shapes are not declared here: `KioskSchema` (@expofp/schema) is the single
+ * definition of kiosk input data, and a kiosk reaches us from localStorage,
+ * from `config.kiosk` or from the legacy `kiosk_*` params through that same
+ * shape. Every field is optional there because every one of those sources can
+ * omit it — guard with `Number.isFinite` rather than assuming.
+ */
+export type KioskMapState = Pick<KioskData, 'mapRollDegrees' | 'mapInitialPtScale' | 'mapPtScale' | 'mapCenterX' | 'mapCenterY' | 'mapPitch' | 'mapCenterLng' | 'mapCenterLat' | 'mapZoom' | 'mapBearingDegrees' | 'mapPitchDegrees'>;
+/**
+ * A kiosk as the on-device SetKiosk flow writes it: same shape as `KioskData`,
+ * narrowed to the anchor fields that flow always fills in.
+ */
+export interface Kiosk extends KioskData {
+    x: number;
+    y: number;
+    z: string | null;
+    heading: number;
+    iconSizePercent: number;
+    uiScale: number;
+}
+export interface StatusMessage extends Omit<AlertProps, 'closeLabel'> {
+    id: number;
+    created?: number;
+}
+export interface ConfirmDialogProps {
+    title: string;
+    isDisabled?: boolean;
+    content?: ReactNode;
+    confirmLabel: string;
+    cancelLabel?: string;
+    onConfirm(): void;
+    onCancel?(): void;
+    confirmVariant: ButtonVariant;
+    cancelVariant: ButtonVariant;
+}
+export interface SetKioskStatusMessagesProps {
+    messages: StatusMessage[];
+}
+export interface SetKioskControlsProps {
+    isSaveDisabled: boolean;
+    isDeleteDisabled: boolean;
+    onSave(): void;
+    onDelete(): void;
+    onClose(): void;
+}
+export interface SetKioskControl {
+    id: string;
+    title: string;
+    iconName?: string;
+    variant: ButtonVariant;
+    onClick: () => void;
+    isDisabled?: boolean;
+    isRound?: boolean;
+}
+export interface SetKioskFormProps {
+    isSaveDisabled?: boolean;
+    isDeleteDisabled?: boolean;
+    areControlsDisabled?: boolean;
+    onSave(): void;
+    onDelete(): void;
+    angle: number;
+    onRotateIcon(angle: number): void;
+    uiScale: number;
+    minUiScale: number;
+    maxUiScale: number;
+    uiScaleStep: number;
+    onUiScaleChange(scale: number): void;
+    iconSizePercent: number;
+    onChangeIconSizePercent(percent: number): void;
+}
+export interface SetKioskChangeEvent {
+    angle?: number;
+    scale?: number;
+    percent?: number;
+}
+export interface SetKioskProps extends Pick<SetKioskFormProps, 'isSaveDisabled' | 'isDeleteDisabled' | 'areControlsDisabled' | 'angle' | 'uiScale' | 'iconSizePercent' | 'minUiScale' | 'maxUiScale' | 'uiScaleStep'> {
+    isInfoVisible: boolean;
+    statusMessages: StatusMessage[];
+    onClose(): void;
+    onDelete(): void;
+    onSave(): void;
+    onChange(event: SetKioskChangeEvent): void;
+    confirmOnClose: boolean;
+}
+export interface RangeInputProps {
+    value: number;
+    name: string;
+    min: number;
+    max: number;
+    step: number;
+    onChange(value: number): void;
+    isDisabled?: boolean;
+    symbol?: string;
+}
+export interface InfoMessageProps {
+    list: {
+        id: string;
+        image: {
+            src: string;
+            alt: string;
+        };
+        content: ReactNode;
+    }[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/components/Kiosk/SetKiosk/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+declare const SetKioskMode: import("react").FunctionComponent<object>;
+export default SetKioskMode;
+//# sourceMappingURL=SetKioskMode.d.ts.map

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

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { observer } from 'mobx-react-lite';
+import { useEffect } from 'react';
+import store from '../../store';
+import { useInit } from '../../utils/mobx';
+import { mapCamera } from '../Map/camera';
+import { onCameraMoved } from '../Map/camera-events';
+import { setPlanClickListener } from '../Map/pointer';
+import kioskStore from './KioskStore';
+import SetKioskComponent from './SetKiosk';
+const SetKioskMode = observer(() => {
+    useInit(() => {
+        Promise.resolve().then(() => kioskStore.handleSetupReady());
+    });
+    // The reference scale kiosk zoom ratios are computed against. The imperative path recorded the
+    // first `viewport:ptscale` event after this screen mounted; the camera handle reports the same
+    // number on demand, so it is simply read once — `setInitialPtScale` keeps only the first value
+    // either way.
+    useEffect(() => {
+        const state = mapCamera()?.state();
+        if (state)
+            kioskStore.setInitialPtScale(state.pixelSize);
+    }, []);
+    // Where the operator clicked is where the kiosk stands. Every plan click reaches the listener —
+    // the selection path deliberately reports before it bails out for kiosk mode.
+    useEffect(() => {
+        setPlanClickListener((point) => kioskStore.handleClick(point));
+        return () => setPlanClickListener();
+    }, []);
+    // A camera move while placing means the operator is framing the kiosk's home view.
+    useEffect(() => onCameraMoved(() => kioskStore.handleNavigationChange()), []);
+    const hasKiosk = Boolean(kioskStore.kiosk);
+    return (_jsx(SetKioskComponent, { isSaveDisabled: hasKiosk ? !kioskStore.hasUnsavedChanges : true, isDeleteDisabled: !hasKiosk, areControlsDisabled: !hasKiosk, confirmOnClose: hasKiosk ? kioskStore.hasUnsavedChanges : false, angle: kioskStore.kiosk?.heading || 0, uiScale: kioskStore.kiosk?.uiScale || store.uiState.uiScale, minUiScale: store.uiState.minUIScale, maxUiScale: store.uiState.maxUIScale, uiScaleStep: 0.01, iconSizePercent: kioskStore.kiosk?.iconSizePercent || 100, isInfoVisible: !hasKiosk, statusMessages: kioskStore.statusMessages, onClose: () => kioskStore.handleClose(), onDelete: () => kioskStore.handleDelete(), onSave: () => kioskStore.handleSave(), onChange: (event) => kioskStore.handleChange(event) }));
+});
+export default SetKioskMode;

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

@@ -0,0 +1,3 @@
+declare const ShowKiosk: import("react").FunctionComponent<object>;
+export default ShowKiosk;
+//# sourceMappingURL=ShowKiosk.d.ts.map

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

@@ -0,0 +1,72 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getConfig } from '@expofp/config';
+import { TouchHand } from '@expofp/ui';
+import { observer } from 'mobx-react-lite';
+import { KIOSK_ENABLE_KEY } from '../../constants';
+import store from '../../store';
+import { useInit } from '../../utils/mobx';
+import { integrateKioskIntoMap, integrateKioskIntoWf } from './integrateKiosk';
+import kioskStore from './KioskStore';
+const ShowKiosk = observer(() => {
+    useInit(() => {
+        if (localStorage.getItem(KIOSK_ENABLE_KEY) === '0') {
+            return;
+        }
+        kioskStore.restoreData();
+        // The device's own kiosk: the one saved on it, else the config anchor below.
+        // Not whatever `uiState.kioskData` holds — a scanned route QR parks its anchor
+        // in that same slot (`recoverKioskFromUrlPrams`, which runs first), and
+        // adopting it from there is what used to turn the scanning device into a
+        // kiosk. That anchor stays as it is: a marker and the route's FROM are all a
+        // QR hands over.
+        //
+        // `Partial`, as both integrate calls take: a config anchor fills in only what
+        // the venue configured, where the store's `Kiosk` is the full record the
+        // on-device SetKiosk flow writes.
+        let ownKiosk = kioskStore.savedKiosk;
+        if (!ownKiosk) {
+            // the deploy-time kiosk anchor from the config (manifest / options /
+            // ?kiosk[x]=… — retirement plan §4.7). A device-saved kiosk (the
+            // SetKiosk flow, restored above) wins over it; the localStorage
+            // 'kiosk'='0' device switch above disables both.
+            const configKiosk = getConfig().kiosk;
+            if (Object.keys(configKiosk).length) {
+                // the schema lets a floor name arrive as a number, the store's `Kiosk`
+                // does not. The cast is the one the config path already had (it went
+                // through `setKiosk(configKiosk as Kiosk)`), not a new claim: a numeric
+                // `z` still reaches `setMapSettings` unstringified, where `MapSettings.z`
+                // is typed `string` and `activateFloor` compares it by identity.
+                ownKiosk = configKiosk;
+                // a device-saved kiosk gets its scale from the efp-uiScale seed the
+                // SetKiosk save wrote; the config anchor applies its scale per-session
+                // instead (no sticky write — the config re-applies on every boot)
+                if (Number.isFinite(configKiosk.uiScale)) {
+                    store.uiState.setKioskUIScale(configKiosk.uiScale, false);
+                }
+            }
+        }
+        if (ownKiosk) {
+            integrateKioskIntoMap(ownKiosk, true);
+            integrateKioskIntoWf(ownKiosk);
+            // The home framing belongs to kiosk mode, which a phone never enters
+            // (`uiState.kiosk`). There the kiosk is a marker and a route's starting
+            // point, and the camera stays where the visit put it.
+            if (store.uiState.kiosk) {
+                kioskStore.resetCamera();
+                store.setResetCameraFn(() => kioskStore.resetCamera());
+            }
+        }
+        // Nothing on display: no kiosk of the device's own, and no anchor from a QR.
+        if (!kioskStore.kiosk) {
+            return;
+        }
+        // Whichever of the two it is goes when the setkiosk panel takes over, which
+        // starts from the device's own record.
+        return () => {
+            store.uiState.setKioskData(null);
+            store.uiState.resetMapSettings();
+        };
+    });
+    return store.uiState.kiosk && store.uiState.inIdle ? _jsx(TouchHand, {}) : null;
+});
+export default ShowKiosk;

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

@@ -0,0 +1,10 @@
+import { type Kiosk } from './SetKiosk';
+/**
+ * Apply a kiosk anchor to the map. Two callers with different inputs: the
+ * device's own kiosk (saved locally or from `config.kiosk`) carries the full
+ * shape including its home framing, while a QR-shared route hands over the
+ * position alone (`kiosk_x/y/z`) — hence every framing field is optional here.
+ */
+export declare function integrateKioskIntoMap(kiosk: Partial<Kiosk>, enableKioskMode: boolean): void;
+export declare function integrateKioskIntoWf(kiosk: Partial<Kiosk>): void;
+//# sourceMappingURL=integrateKiosk.d.ts.map

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

@@ -0,0 +1,68 @@
+import { runInAction } from 'mobx';
+import store from '../../store';
+import { planWhen } from '../../utils/plan-reactions.js';
+import { getPtScaleZoomRatio } from './kiosk-record';
+/**
+ * Apply a kiosk anchor to the map. Two callers with different inputs: the
+ * device's own kiosk (saved locally or from `config.kiosk`) carries the full
+ * shape including its home framing, while a QR-shared route hands over the
+ * position alone (`kiosk_x/y/z`) — hence every framing field is optional here.
+ */
+export function integrateKioskIntoMap(kiosk, enableKioskMode) {
+    if (!kiosk) {
+        return;
+    }
+    runInAction(() => {
+        // the store's `Kiosk` declares every field required, but a URL anchor only
+        // ever has the position — every reader of `kioskData` already copes with
+        // the rest being absent (that is what the QR channel has always stored)
+        store.uiState.setKioskData(kiosk);
+        store.uiState.kiosk = enableKioskMode;
+        // Both writes below only reach the plan renderer: Map.tsx's mapSettings
+        // reaction bails in map mode, and the map's zoomBy reaction is a fixed ±0.5
+        // step that would misread the ratio. In map mode the framing is restored
+        // through the map camera instead — KioskStore.resetCamera, called right
+        // after this by ShowKiosk.
+        if (store.maplibreStore.showMaplibre) {
+            return;
+        }
+        // The centre is REPLACED, not merged away: `setMapSettings` merges into the
+        // previous settings and the map reaction re-pans on every change, so a
+        // framing-less anchor must overwrite whatever centre is already there — a
+        // QR-shared route must not drag the phone back to the plan's boot camera on
+        // every navigation. Historically the overwrite was the interpolated string
+        // "undefined,undefined", which the reaction rejected as NaN; an empty
+        // string says the same thing without the garbage.
+        //
+        // The home framing belongs to kiosk mode, so a device the mode stayed off on —
+        // a phone, whose kiosk is a marker and nothing more — takes the position alone,
+        // exactly as a QR anchor does.
+        const framing = store.uiState.kiosk ? kiosk : {};
+        const hasFraming = framing.mapCenterX != null && framing.mapCenterY != null;
+        store.uiState.setMapSettings({
+            centerxy: hasFraming ? `${framing.mapCenterX},${framing.mapCenterY}` : '',
+            z: kiosk.z ?? undefined,
+            bearing: framing.mapRollDegrees,
+        });
+        const zoomRatio = getPtScaleZoomRatio(framing);
+        if (zoomRatio !== undefined) {
+            store.uiState.changeZoom(zoomRatio);
+        }
+    });
+}
+export function integrateKioskIntoWf(kiosk) {
+    if (!kiosk) {
+        return;
+    }
+    if (kiosk.z != null) {
+        store.fp.activateFloor({ name: kiosk.z.toString() });
+    }
+    // At page load the route URL is dispatched before the kiosk is integrated, and `selectRoute` applies the
+    // route to `uiState.details` after a 200ms defer — so wait for the selected route instead of reading it
+    // right away, then fill the kiosk anchor as the default FROM if directions mode is active with no FROM.
+    planWhen(() => !!store.uiState.selectedRoute, () => {
+        const route = store.uiState.selectedRoute;
+        if (route?.to && !route.from)
+            store.routeStore.selectRoute(route, false, true);
+    });
+}

package/dist/esm/components/Kiosk/kiosk-mode.d.ts

@@ -0,0 +1,26 @@
+import { type Config } from '@expofp/config';
+import type UIState from '../../store/UIState';
+/**
+ * Toggle kiosk mode — the single meaning of `kiosk=1` / `kiosk=0` from either
+ * channel (the `?kiosk=` URL param, the typed search-box command) — and store
+ * that choice. Exit also resets the per-device UI scale.
+ */
+export declare function applyKioskMode(uiState: UIState, enabled: boolean): void;
+/**
+ * Store-free kiosk check — the mode a load starts in: the `?kiosk=` param wins, then whatever the
+ * device itself says. Used by the Intercom boot, which runs before the MobX stores exist, so the
+ * phone rule (`UIState.kiosk`) is not applied here. The direct `?kiosk` read is kiosk-semantic and
+ * migrates with the kiosk config node (retirement plan §4.7).
+ */
+export declare function isKioskMode(data: Config): boolean;
+/**
+ * The same check without the `?kiosk=` param: the mode init-ui and ShowKiosk settle on between
+ * them, from the stored flag and the kiosks left — the enable flag, then a saved-kiosk object (a
+ * provisioned device is a kiosk on first load, before the flag is set), then the config anchor.
+ * What the setkiosk panel asks on close, since ShowKiosk remounts right after it and reads no
+ * param.
+ */
+export declare function storedKioskMode(data: Config): boolean;
+/** Whether this device holds a kiosk saved by the setkiosk panel. */
+export declare function hasSavedKiosk(): boolean;
+//# sourceMappingURL=kiosk-mode.d.ts.map

package/dist/esm/components/Kiosk/kiosk-mode.js

@@ -0,0 +1,56 @@
+import { KIOSK_ENABLE_KEY } from '../../constants';
+import { isLocalStorageAvailable } from '../../utils/localStorage';
+import { getSavedKiosk } from './SetKiosk/storage';
+/**
+ * Toggle kiosk mode — the single meaning of `kiosk=1` / `kiosk=0` from either
+ * channel (the `?kiosk=` URL param, the typed search-box command) — and store
+ * that choice. Exit also resets the per-device UI scale.
+ */
+export function applyKioskMode(uiState, enabled) {
+    uiState.kiosk = enabled;
+    if (!enabled) {
+        uiState.resetUIScale();
+    }
+    // Stored from this one canonical choice rather than off a reaction on
+    // `uiState.kiosk`, which cannot tell a choice from the several passes that
+    // drive the same flag on the way to one: the setkiosk panel previews kiosk
+    // mode through it and settles it on close, and a QR anchor turns it off on
+    // the scanning device. Those write the key themselves where they mean to — the
+    // panel's Save and Delete do.
+    if (isLocalStorageAvailable) {
+        window.localStorage.setItem(KIOSK_ENABLE_KEY, enabled ? '1' : '0');
+    }
+}
+/**
+ * Store-free kiosk check — the mode a load starts in: the `?kiosk=` param wins, then whatever the
+ * device itself says. Used by the Intercom boot, which runs before the MobX stores exist, so the
+ * phone rule (`UIState.kiosk`) is not applied here. The direct `?kiosk` read is kiosk-semantic and
+ * migrates with the kiosk config node (retirement plan §4.7).
+ */
+export function isKioskMode(data) {
+    const param = new URLSearchParams(window.location.search).get(KIOSK_ENABLE_KEY);
+    // only `1` and `0` are a choice — `?kiosk=` and any other value are none, which is how
+    // `classifyPrimary` (@expofp/config) reads the same param
+    if (param === '1' || param === '0')
+        return param === '1';
+    return storedKioskMode(data);
+}
+/**
+ * The same check without the `?kiosk=` param: the mode init-ui and ShowKiosk settle on between
+ * them, from the stored flag and the kiosks left — the enable flag, then a saved-kiosk object (a
+ * provisioned device is a kiosk on first load, before the flag is set), then the config anchor.
+ * What the setkiosk panel asks on close, since ShowKiosk remounts right after it and reads no
+ * param.
+ */
+export function storedKioskMode(data) {
+    const flag = isLocalStorageAvailable ? window.localStorage.getItem(KIOSK_ENABLE_KEY) : null;
+    if (flag === '1' || flag === '0')
+        return flag === '1';
+    // A config-provisioned kiosk (the config.kiosk anchor) is a kiosk too.
+    return hasSavedKiosk() || Object.keys(data.kiosk ?? {}).length > 0;
+}
+/** Whether this device holds a kiosk saved by the setkiosk panel. */
+export function hasSavedKiosk() {
+    // isLocalStorageAvailable short-circuits: getSavedKiosk() reads localStorage unguarded.
+    return isLocalStorageAvailable && getSavedKiosk() != null;
+}

package/dist/esm/components/Kiosk/kiosk-record.d.ts

@@ -0,0 +1,23 @@
+import { type Kiosk } from './SetKiosk';
+/**
+ * Narrows a saved kiosk field to a usable number.
+ *
+ * Every field of a kiosk record is optional (`KioskSchema`) and the record can
+ * arrive from localStorage, from `config.kiosk` or from the legacy `kiosk_*`
+ * params — so a field can be absent, or present and `NaN` from a bad parse.
+ * Both must read as "not set": feeding `NaN` into a camera move silently parks
+ * the kiosk nowhere.
+ */
+export declare function toFiniteNumber(value: number | null | undefined): number | undefined;
+/**
+ * The zoom factor that takes the plan renderer from the pt-scale it booted at
+ * to the one the kiosk was saved at, or undefined when the record does not
+ * carry both. Restoring the home framing and integrating the kiosk at load both
+ * need it, and both need the same guard.
+ *
+ * `Partial` rather than `Kiosk`: a QR-shared route hands over the anchor
+ * position alone, with no framing at all — the guard above is what that case
+ * lands in.
+ */
+export declare function getPtScaleZoomRatio(kiosk: Partial<Kiosk> | null | undefined): number | undefined;
+//# sourceMappingURL=kiosk-record.d.ts.map