@expofp/floorplan 3.37.1 → 3.39.0

package/dist/esm/utils/blob-image-size.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Measures an image's intrinsic size without keeping its pixels.
+ *
+ * Floorplan needs one number from a logo's pixels: the aspect ratio, to fit the logo inside a
+ * booth. `createImageBitmap` gives that number at low cost. The browser decodes the image on its
+ * own thread. Then it resolves a promise. The main thread pays only for the call and for the
+ * promise resolution, not for the decode itself. This is the difference between
+ * `createImageBitmap` and an `<img>` element, which decodes on the same thread as the page.
+ *
+ * The function closes the bitmap right after it reads the size. A caller can start as many calls
+ * as it wants. At any instant, only a few bitmaps exist in memory: the ones the browser's decoder
+ * already finished but did not yet hand back. The whole batch of logos never sits in memory
+ * together. One cost remains, and this cost is accepted: each logo gets decoded twice, once here
+ * and once in the atlas worker. This happens because a Blob cannot report its own size, and the
+ * renderer does not report one back either.
+ *
+ * This function has no `<img>` fallback. `createImageBitmap` works on every build target that
+ * this SDK supports. The only targets that lack `createImageBitmap` are targets where the whole
+ * SDK already fails to run.
+ * @param blob - The image bytes.
+ * @returns The size, or `null` if the bytes cannot be decoded.
+ */
+export declare function blobImageSize(blob: Blob): Promise<{
+    width: number;
+    height: number;
+} | null>;
+//# sourceMappingURL=blob-image-size.d.ts.map

package/dist/esm/utils/blob-image-size.js

@@ -0,0 +1 @@
+export async function blobImageSize(e){try{const t=await createImageBitmap(e),i={width:t.width,height:t.height};return t.close(),i}catch{return null}}

package/dist/esm/utils/loadBlob.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fetches an image as a `Blob`, the form the renderer packs from.
+ *
+ * This function returns a `Blob`, not an `HTMLImageElement`, because decoding an image element
+ * blocks the main thread. At a thousand booth logos, the `HTMLImageElement` route stalls the
+ * thread for two seconds, and the `Blob` route does not stall it at all. A `Blob` is also a handle
+ * to bytes that do not change. A worker that receives one gets the handle, not a copy of the bytes.
+ *
+ * This function never throws. `normalize-legacy-data.ts` mints the `__small` and `__tiny` logo
+ * variants by adding a suffix to the full URL. It never confirms that the variant file exists. A
+ * 404 here is routine. When it happens, the caller retries with its fallback URL.
+ * @param src - The image URL.
+ * @returns The bytes, or `null` when the fetch fails.
+ */
+export declare function loadBlob(src: string): Promise<Blob | null>;
+//# sourceMappingURL=loadBlob.d.ts.map

package/dist/esm/utils/loadBlob.js

@@ -0,0 +1 @@
+export async function loadBlob(o){try{const t=await fetch(o,{mode:"cors",credentials:"omit"});if(!t.ok)return null;const n=await t.blob();return n.type.startsWith("image/")?n:null}catch{return null}}

package/dist/esm/utils/loadImagesInBatches.d.ts

@@ -2,6 +2,21 @@ export interface ImageUrls {
     preferred?: string;
     fallback: string;
 }
-export declare function loadImagesInBatches(urls: ImageUrls[], batchSize?: number, delay?: number): Promise<HTMLImageElement[]>;
 export declare function loadImagesInBatchesById(logosUrls: Map<number, ImageUrls>, batchSize?: number, delay?: number): Promise<Map<number, HTMLImageElement>>;
+/**
+ * Loads a map of ids to image bytes. One URL loads at most once per call, no matter how many ids
+ * share it.
+ *
+ * This dedup is not an optimization. It is a correctness requirement. The renderer dedupes image
+ * sources by object identity, so two booths that share a logo must get the very same `Blob`
+ * object. If they do not, the logo downloads twice, packs twice, and draws from two atlas
+ * regions. The cache lives only for the length of this call, because the defs keep their own
+ * Blobs afterward. A cache that outlived the call would give every logo on the plan a second
+ * place to stay in memory.
+ * @param logosUrls - The URLs to load, keyed by booth id.
+ * @param batchSize - How many URLs to load at once.
+ * @param delay - Milliseconds to wait between batches.
+ * @returns The bytes, keyed by booth id. An id is absent when its logo failed to load.
+ */
+export declare function loadBlobsInBatchesById(logosUrls: Map<number, ImageUrls>, batchSize?: number, delay?: number): Promise<Map<number, Blob>>;
 //# sourceMappingURL=loadImagesInBatches.d.ts.map

package/dist/esm/utils/loadImagesInBatches.js

@@ -1 +1 @@
-import d from"./is-mobile";import h from"./is-webview";import{loadImage as l}from"./loadImage";const u=d||h,f=u?8:512,w=u?100:0;async function p(e){return Promise.all(e.map(async([n,{preferred:a,fallback:i}])=>{let t=null;return a&&(t=await l(a)),!t&&i&&(t=await l(i)),[n,t]}))}export async function loadImagesInBatches(e,n=f,a=w){if(!e.length)return[];const i=[];for(let t=0;t<e.length;t+=n){const r=e.slice(t,t+n).map(async({preferred:o,fallback:c})=>{let s=null;return o&&(s=await l(o)),!s&&c&&(s=await l(c)),s}),m=await Promise.all(r);i.push(...m.filter(o=>o!==null)),await new Promise(o=>setTimeout(o,a))}return i}export async function loadImagesInBatchesById(e,n=f,a=w){if(!e.size)return new Map;const i=Array.from(e.entries()),t=new Map;for(let r=0;r<i.length;r+=n){const m=i.slice(r,r+n);(await p(m)).forEach(([c,s])=>{s&&t.set(c,s)}),a&&await new Promise(c=>setTimeout(c,a))}return t}
+import w from"./is-mobile";import y from"./is-webview";import{loadBlob as B}from"./loadBlob";import{loadImage as I}from"./loadImage";const f=w||y,l=f?8:512,d=f?100:0;async function b(e,o){const t=e.preferred?await o(e.preferred):null;return t||(e.fallback?o(e.fallback):null)}async function m(e,o,t,a){if(!e.size)return new Map;const c=Array.from(e.entries()),r=new Map;for(let n=0;n<c.length;n+=t){const p=c.slice(n,n+t),u=await Promise.all(p.map(async([i,s])=>[i,await b(s,o)]));for(const[i,s]of u)s&&r.set(i,s);a&&await new Promise(i=>setTimeout(i,a))}return r}export async function loadImagesInBatchesById(e,o=l,t=d){return m(e,I,o,t)}export async function loadBlobsInBatchesById(e,o=l,t=d){const a=new Map;return m(e,r=>{let n=a.get(r);return n||(n=B(r),a.set(r,n)),n},o,t)}

package/dist/esm/utils/loadLayerImages.d.ts

@@ -0,0 +1,46 @@
+import { type Booth } from '../store/BoothStore';
+/** One `<image>` from a layer's drawing: where it sits, and the pixels to draw there. */
+export interface LayerImage {
+    /** The booth this image belongs to, or null for a plain layer graphic. */
+    booth: Booth | null;
+    /** The image's name, when it has one. */
+    name?: string;
+    /**
+     * The bytes the renderer packs. An SVG image is rasterized and re-encoded as PNG.
+     *
+     * `createImageBitmap` rejects SVG bytes, so an SVG cannot travel to the atlas worker as it is.
+     * It stays a `Blob` all the same: a layer packs in the worker only while every one of its
+     * sources is a `Blob`, so one canvas among a layer's graphics would drop the whole layer back
+     * onto the main thread.
+     */
+    source: Blob;
+    /** Placement read off the SVG element: top-left, size, and rotation in degrees. */
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        angle: number;
+    };
+}
+/**
+ * Loads a layer's drawing images as bytes.
+ *
+ * The placement comes from the SVG element, not from the file. Nothing here needs the image's
+ * intrinsic size, so a raster image is never decoded. Avoiding that decode on the main thread is
+ * the reason for this change.
+ *
+ * Most of these hrefs are inline `data:image/webp;base64` URLs, not file references. The
+ * converter embeds designer graphics directly in the drawing payload. In a real plan, the first
+ * such image is 74KB of WebP inside a 68-unit box. `fetch` serves a `data:` URL from the browser
+ * itself, with no network call and no CORS check, and returns a Blob whose `type` matches the one
+ * the URL declares. These Blobs reach the renderer exactly as a fetched logo does, and take the
+ * same worker path. A drawing can also carry `svg-images/…` file references. `@expofp/config`
+ * rebases those to absolute URLs before this function sees them. Both forms go through `loadBlob`
+ * unchanged.
+ * @param svgImages - The `<image>` elements to load.
+ * @returns One entry per image that loaded, in element order. Images that failed to load are
+ * dropped.
+ */
+export declare function loadLayerImages(svgImages: SVGImageElement[]): Promise<LayerImage[]>;
+//# sourceMappingURL=loadLayerImages.d.ts.map

package/dist/esm/utils/loadLayerImages.js

@@ -0,0 +1 @@
+import{loadBlob as e}from"./loadBlob";import{isSvgBlob as u,svgToPngBlob as i}from"./rasterize-svg";export async function loadLayerImages(a){const t=new Map,r=n=>{let l=t.get(n);return l||(l=s(n),t.set(n,l)),l};return(await Promise.all(a.map(async n=>{const l=n.getAttribute("xlink:href")??n.getAttribute("href"),o=l?await r(l):null;return o?{bounds:{x:n.x.animVal.value,y:n.y.animVal.value,width:n.width.animVal.value,height:n.height.animVal.value,angle:n.transform?.animVal[0]?.angle??0},source:o,booth:null}:null}))).filter(n=>n!==null)}async function s(a){const t=await e(a);return t?u(t)?i(t):t:null}

package/dist/esm/utils/rasterize-svg.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Whether these bytes are an SVG.
+ *
+ * The test reads a prefix, not the whole type. A server may send `image/svg+xml; charset=utf-8`,
+ * and these images come from customer origins and CDNs, not only from this repository's own
+ * server. An exact match lets that form through to `createImageBitmap`, which rejects SVG bytes,
+ * and the image then disappears with no sign of why.
+ * @param blob - The bytes to test.
+ * @returns Whether the bytes are an SVG.
+ */
+export declare function isSvgBlob(blob: Blob): boolean;
+/**
+ * Draws an SVG into a canvas at its own intrinsic size.
+ *
+ * `createImageBitmap` refuses SVG bytes (`InvalidStateError`, measured in Chrome 153, even for an
+ * SVG with an explicit `width` and `height`), so an SVG cannot travel to the atlas worker as it is.
+ * An `<img>` element renders the same bytes. This function does that conversion once, at load time.
+ * @param blob - The SVG bytes.
+ * @returns The rasterized canvas, or null when the SVG does not render, or declares no size.
+ */
+export declare function rasterizeSvg(blob: Blob): Promise<HTMLCanvasElement | null>;
+/**
+ * Rasterizes an SVG and hands the pixels back as PNG bytes.
+ *
+ * The result is a `Blob` and not a canvas on purpose. A layer packs in the atlas worker only while
+ * every one of its sources is a `Blob`, so one canvas among a thousand booth logos would drop the
+ * whole layer back onto the main thread — the exact layer the worker exists for.
+ * @param blob - The SVG bytes.
+ * @returns The PNG bytes, or null when the SVG does not render.
+ */
+export declare function svgToPngBlob(blob: Blob): Promise<Blob | null>;
+//# sourceMappingURL=rasterize-svg.d.ts.map

package/dist/esm/utils/rasterize-svg.js

@@ -0,0 +1 @@
+import{loadImage as o}from"./loadImage";export function isSvgBlob(n){return n.type.startsWith("image/svg+xml")}export async function rasterizeSvg(n){const t=URL.createObjectURL(n);try{const e=await o(t);if(!e?.naturalWidth||!e.naturalHeight)return null;const a=document.createElement("canvas");a.width=e.naturalWidth,a.height=e.naturalHeight;const r=a.getContext("2d");return r?(r.drawImage(e,0,0),a):null}finally{URL.revokeObjectURL(t)}}export async function svgToPngBlob(n){const t=await rasterizeSvg(n);return t?i(t):null}function i(n){return new Promise(t=>{try{n.toBlob(e=>t(e),"image/png")}catch{t(null)}})}

package/dist/esm/wayfinding/createWayfinding.js

@@ -1 +1 @@
-import{update as d}from"@expofp/renderer";import{createWayfinding as g,resolveWayfindingLayers as S}from"@expofp/wayfinding";import{fpGeo as R}from"../data/fpGeo";import{attachCardinalSnap as v}from"../engine/utils/rotation";import{createCanvasIconProvider as h,createFloorContext as x,createGraphDataSource as k}from"./adapters";import{bindMobxReactions as C}from"./bindMobxReactions";import{createKioskHandler as P}from"./handlers/kioskHandler";import{createYahHandler as W}from"./handlers/yahHandler";let u=null;export function isWayfindingReady(){return u!==null}function b(){if(!u)throw new Error("Wayfinding is not initialized \u2014 call createWayfinding() first.");return u}export function buildRoute(e,n,r){return b().wayfinding.buildRoute(e,n,r)}export function createWayfinding(e){const{scene:n,store:r,canvas:o}=e,c=S(n.rootLayer),{wayfinding:s,dispose:i}=w(r,c,{attachCardinalSnap:v,update:d}),t=c.icons;return t.onClick=f=>M(s,f),t.onPointerMove=f=>y(s,o,f),t.onPointerOut=()=>y(s,o),d(t),()=>{t.onClick=void 0,t.onPointerMove=void 0,t.onPointerOut=void 0,o.current&&(o.current.style.cursor=""),d(t),i()}}function w(e,n,r){const o=k(),c=h({iconMap:e.fp.icons,pixelRatio:devicePixelRatio}),s=x(e.layerStore,e.routeStore),i=g({dataSource:o,renderer:r,iconProvider:c,floorContext:s,layers:n,gpsConfig:R?.properties?.config,onTransitionClick:a=>{a.role==="exit"&&e.layerStore.updateVisibility(a.targetLayer,!0)},onRouteUpdate:(a,p)=>{e.routeStore.updateRoute([...a]),p.isEmpty()||(e.uiState.moveToRect=p)},onRouteDistance:a=>e.routeStore.updateRouteDistance(a)}),t=P({wayfinding:i,kioskIconMap:e.fp.icons}),f=W({wayfinding:i,iconMap:e.fp.icons,pixelRatio:devicePixelRatio,floorContext:s}),m=C({wayfinding:i,kioskHandler:t,yahHandler:f,stores:{routeStore:e.routeStore,uiState:e.uiState,layerStore:e.layerStore}});e.routeStore.showAccessible=o.getLines().some(a=>a.unaccessible);const l={wayfinding:i};return u=l,i.flush(),{wayfinding:i,dispose(){H(l)&&(u=null,e.routeStore.showAccessible=!1),m(),i.destroy()}}}function H(e){return u===e}function M(e,n){e.handleClick([n.def])&&n.stopPropagation()}function y(e,n,r){const o=n.current;if(!o)return;const c=r?e.handleHover([r.def]):!1;o.style.cursor=c?"pointer":""}
+import{update as d}from"@expofp/renderer";import{createWayfinding as S,resolveWayfindingLayers as g}from"@expofp/wayfinding";import{fpGeo as R}from"../data/fpGeo";import{attachCardinalSnap as v}from"../engine/utils/rotation";import{createCanvasIconProvider as h,createFloorContext as x,createGraphDataSource as k}from"./adapters";import{bindMobxReactions as C}from"./bindMobxReactions";import{createKioskHandler as P}from"./handlers/kioskHandler";import{createYahHandler as W}from"./handlers/yahHandler";let u=null;export function isWayfindingReady(){return u!==null}function w(){if(!u)throw new Error("Wayfinding is not initialized \u2014 call createWayfinding() first.");return u}export function buildRoute(e,n,r){return w().wayfinding.buildRoute(e,n,r)}export function createWayfinding(e){const{scene:n,store:r,canvas:o}=e,c=g(n.rootLayer),{wayfinding:s,dispose:t}=b(r,c,{attachCardinalSnap:v,update:d}),i=c.icons;return i.onClick=f=>M(s,f),i.onPointerMove=f=>y(s,o,f),i.onPointerOut=()=>y(s,o),d(i),()=>{i.onClick=void 0,i.onPointerMove=void 0,i.onPointerOut=void 0,o.current&&(o.current.style.cursor=""),d(i),t()}}function b(e,n,r){const o=k(),c=h({iconMap:e.fp.icons,pixelRatio:devicePixelRatio}),s=x(e.layerStore,e.routeStore),t=S({dataSource:o,renderer:r,iconProvider:c,floorContext:s,layers:n,gpsConfig:R?.properties?.config,screenSpaceIcons:e.uiState.is3DView,onTransitionClick:a=>{a.role==="exit"&&e.layerStore.updateVisibility(a.targetLayer,!0)},onRouteUpdate:(a,p)=>{e.routeStore.updateRoute([...a]),p.isEmpty()||(e.uiState.moveToRect=p)},onRouteDistance:a=>e.routeStore.updateRouteDistance(a)}),i=P({wayfinding:t,kioskIconMap:e.fp.icons}),f=W({wayfinding:t,iconMap:e.fp.icons,pixelRatio:devicePixelRatio,floorContext:s}),m=C({wayfinding:t,kioskHandler:i,yahHandler:f,stores:{routeStore:e.routeStore,uiState:e.uiState,layerStore:e.layerStore}});e.routeStore.showAccessible=o.getLines().some(a=>a.unaccessible);const l={wayfinding:t};return u=l,t.flush(),{wayfinding:t,dispose(){H(l)&&(u=null,e.routeStore.showAccessible=!1),m(),t.destroy()}}}function H(e){return u===e}function M(e,n){e.handleClick([n.def])&&n.stopPropagation()}function y(e,n,r){const o=n.current;if(!o)return;const c=r?e.handleHover([r.def]):!1;o.style.cursor=c?"pointer":""}

package/dist/esm/wayfinding/handlers/kioskHandler.js

@@ -1 +1 @@
-import{degToRad as l}from"@expofp/geometry";import{createKioskCanvas as f}from"../adapters";const n="kiosk",p=0;export function createKioskHandler({wayfinding:t,kioskIconMap:a}){const s=new Map,u=e=>{const o=e??100,c=s.get(o);if(c)return c;const r=f(a,e);return s.set(o,r),r};return(e,o,c)=>{if(!e){t.setIcon(n,null),t.flush();return}if(c!==p&&e.z&&o&&e.z!==o){t.setIcon(n,null),t.flush();return}t.setIcon(n,{canvas:u(e.iconSizePercent),x:e.x,y:e.y,rotation:l(e.heading??0)}),t.flush()}}
+import{degToRad as l}from"@expofp/geometry";import{createKioskCanvas as f}from"../adapters";const n="kiosk",p=0;export function createKioskHandler({wayfinding:t,kioskIconMap:a}){const s=new Map,u=e=>{const c=e??100,o=s.get(c);if(o)return o;const r=f(a,e);return s.set(c,r),r};return(e,c,o)=>{if(!e){t.setIcon(n,null),t.flush();return}if(o!==p&&e.z&&c&&e.z!==c){t.setIcon(n,null),t.flush();return}t.setIcon(n,{canvas:u(e.iconSizePercent),x:e.x,y:e.y,rotation:l(e.heading??0),screenSpace:!1}),t.flush()}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/floorplan",
-  "version": "3.37.1",
+  "version": "3.39.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -69,15 +69,15 @@
     "tslib": "^2.3.0",
     "uuid": "^9.0.1",
     "zod": "4.4.3",
-    "@expofp/config": "3.37.1",
-    "@expofp/debug": "3.37.1",
-    "@expofp/geometry": "3.37.1",
-    "@expofp/renderer": "3.37.1",
-    "@expofp/resolve": "3.37.1",
-    "@expofp/schema": "3.37.1",
-    "@expofp/ui": "3.37.1",
-    "@expofp/utils": "3.37.1",
-    "@expofp/wayfinding": "3.37.1"
+    "@expofp/config": "3.39.0",
+    "@expofp/debug": "3.39.0",
+    "@expofp/geometry": "3.39.0",
+    "@expofp/renderer": "3.39.0",
+    "@expofp/resolve": "3.39.0",
+    "@expofp/schema": "3.39.0",
+    "@expofp/ui": "3.39.0",
+    "@expofp/utils": "3.39.0",
+    "@expofp/wayfinding": "3.39.0"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^8.0.2",

package/dist/esm/utils/imageloader.d.ts

@@ -1,15 +0,0 @@
-import { type Booth } from '../store/BoothStore';
-export interface Img {
-    booth: Booth;
-    name?: string;
-    htmlImage: HTMLImageElement;
-    bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        angle: number;
-    };
-}
-export declare function loadIcons(svgImages: SVGImageElement[]): Promise<Img[]>;
-//# sourceMappingURL=imageloader.d.ts.map

package/dist/esm/utils/imageloader.js

@@ -1 +0,0 @@
-import{loadImage as e}from"./loadImage";export function loadIcons(t){return Promise.all(t.map(a=>new Promise(async n=>{var l=await e(a.getAttribute("xlink:href")||a.getAttribute("href"));n(l?{bounds:{x:a.x.animVal.value,y:a.y.animVal.value,width:a.width.animVal.value,height:a.height.animVal.value,angle:a.transform?.animVal[0]?.angle??0},htmlImage:l,booth:null}:null)})))}