@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/types.d.ts

@@ -0,0 +1,593 @@
+import { type Config } from '@expofp/config';
+import { type LatLng } from '@expofp/geometry';
+import { type Camera, type ListPanel, type PlannerOptions, type SessionsFilters } from '@expofp/schema';
+/**
+ * Represents a floor plan.
+ */
+export interface FloorPlan {
+    /**
+     * Resolves once the plan has mounted and its API is live.
+     *
+     * Rejects if {@link destroy} is called first: the initialization it was
+     * waiting on has been cancelled, so awaiting it any longer would never
+     * return. Await it inside the same chain that owns the teardown, or attach a
+     * `catch` — an unhandled rejection here is a destroyed plan, not a failure
+     * to load.
+     */
+    readonly ready: Promise<void>;
+    readonly element: HTMLDivElement;
+    readonly eventId: string;
+    readonly noOverlay: boolean;
+    readonly offHistory: boolean;
+    /**
+     * @deprecated The consent decision lives on the config — set the `consent`
+     * option instead. `true` ⇄ `'granted'`, `false` ⇄ `'denied'`, `undefined` ⇄ `'ask'`.
+     */
+    readonly allowConsent: boolean | undefined;
+    readonly onInit: (fp: FloorPlan) => void;
+    onBoothClick(e: FloorPlanBoothClickEvent): void;
+    onBookmarkClick(e: FloorPlanBookmarkClickEvent): void;
+    onVisitedClick(e: FloorPlanVisitedClickEvent): void;
+    onCategoryClick(e: FloorPlanCategoryClickEvent): void;
+    /**
+     * @deprecated
+     * The onFpConfigured method is deprecated. Use onInit instead.
+     */
+    onFpConfigured(): void;
+    onDirection(e: FloorPlanDirectionEvent | null): void;
+    onDetails(e: FloorPlanDetailsEvent): void;
+    onExhibitorCustomButtonClick(e: FloorPlanCustomButtonEvent): void;
+    onGetCoordsClick(e: FloorPlanGetCoordsEvent): void;
+    onMarkerClick(e: FloorPlanMarkerEvent): void;
+    /**
+     * Fires when the user triggers a cross-venue journey's external handoff.
+     * Unregistered — or registered and left unhandled — the SDK opens the
+     * event's provider URL itself.
+     */
+    onExternalNavigation?(e: FloorPlanExternalNavigationEvent): void;
+    selectBooth(nameOrExternalId: string): void;
+    selectExhibitor(nameOrExternalId: string): void;
+    selectRoute(from: RouteWaypoint, to: RouteWaypoint): void;
+    selectRoute(waypoints: RouteWaypoint[]): void;
+    getOptimizedRoutes(waypoints: RouteWaypoint[]): RouteInfo[];
+    selectCurrentPosition(point: CurrentPosition, focus: boolean, icon?: number): void;
+    setBookmarks(bookmarks: {
+        name: string;
+        bookmarked: boolean;
+    }[]): void;
+    setEntitiesBookmarks(bookmarks: {
+        type: 'exhibitor' | 'event' | 'speaker' | 'booth';
+        name?: string;
+        externalId?: string;
+        bookmarked: boolean;
+    }[]): void;
+    setEntitiesVisited(entities: {
+        type: 'exhibitor' | 'event';
+        name?: string;
+        externalId?: string;
+        visited: boolean;
+    }[]): void;
+    setMarkers(markersData: MarkersData): void;
+    updateLayerVisibility(layer: string, visible: boolean): void;
+    getCenterCoordinates(): FloorPlanGetCoordsEvent;
+    applyParameters(queryRaw: string): void;
+    exhibitorsList(): FloorPlanExhibitor[];
+    boothsList(): FloorPlanBooth[];
+    categoriesList(): FloorPlanCategory[];
+    selectCategory(nameOrSlug?: string): void;
+    /**
+     * Opens whatever the slug or external id names — a booth, a schedule
+     * session, an exhibitor, a category or a speaker (checked in that order);
+     * anything else opens the search list with the value as the search text.
+     * The programmatic twin of the `?<slug>` deep link.
+     */
+    select(slugOrExternalId: string): void;
+    /** Opens one of the named list panels (the `?bookmarks`, `?sessions`, … deep links). */
+    showList(list: ListPanel): void;
+    /**
+     * Opens the sessions list with exactly these filters, the omitted ones off
+     * (the `?showSessions[…]` deep link).
+     */
+    showSessions(filters?: SessionsFilters): void;
+    /** Launches the tour with the given id; unknown ids fall back to the tours list. */
+    selectTour(tourId: string): void;
+    /** Opens the route planner, optionally pre-filled with slugs or the visitor's bookmarks. */
+    openPlanner(options?: PlannerOptions): void;
+    /** Enters the interactive route-building mode. */
+    startBuildRoute(): void;
+    getVisibility(): Visibility;
+    setVisibility(visibility: Visibility): void;
+    findLocation(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    switchView(): void;
+    /**
+     * Moves the camera. Partial-merge semantics: only the fields present in
+     * `camera` change, omitted ones keep their current values — e.g.
+     * `setCamera({ bearing: 90 })` rotates the map without moving its center.
+     * The center is set either as floor-plan projected coordinates (`x`/`y`) or
+     * as GPS (`lat`/`lng`) — each is a pair, so both halves must be given.
+     * `floor` activates the named floor, `bearing` rotates the map (0–360°) and
+     * `zoomTime` sets the camera animation duration in milliseconds. Applied as
+     * soon as the renderer is ready. Also available as the `setCamera` intent
+     * (URL deep link).
+     */
+    setCamera(camera: Camera): void;
+    /**
+     * The camera state last requested via {@link setCamera} (or the equivalent
+     * URL parameters) — not a live gesture-tracking camera: panning or zooming
+     * by hand does not update it.
+     */
+    getCamera(): Camera;
+    zoomTo(selectors: POISelectors, options?: {
+        padding?: number;
+    }): void;
+    fitBounds(): void;
+    fitBounds(bounds: Bounds, options?: {
+        padding?: number;
+    }): void;
+    getBounds(selectors: POISelectors): Bounds | undefined;
+    getBoothRect(name: string): Rect;
+    convertToGeo(x: number, y: number): [number, number] | never;
+    getGeoConfig(): GeoConfig | null;
+    /**
+     * Tears the floor plan down: unmounts the UI, drops the window listeners,
+     * analytics, URL sync and map resources it installed, and empties the
+     * container element — the element itself is left in the document, ready to
+     * be passed to a new {@link load} call.
+     *
+     * Safe at any point in the lifecycle: calling it before {@link ready}
+     * resolves cancels the pending initialization instead of throwing, so a
+     * single-page app can unmount a route while the plan is still loading. That
+     * cancellation rejects {@link ready} rather than leaving it pending forever.
+     * Synchronous and idempotent — safe to call from a framework unmount hook
+     * without awaiting or guarding, and calling it more than once does nothing
+     * after the first.
+     *
+     * One live plan per page, so this is also the first half of a *plan swap*:
+     * destroy, then `load()` the next event. Calling `load()` before this
+     * rejects. See the Switching plans guide.
+     *
+     * The instance is spent once destroyed — call {@link load} again for a new
+     * plan rather than reusing it.
+     */
+    destroy(): void;
+    /**
+     * @deprecated Renamed to {@link destroy}, which carries the same behaviour
+     * plus a stable contract. This alias will be removed in a future major.
+     */
+    unstable_destroy(): void;
+    highlightExhibitors(externalIds: string[]): void;
+    highlightBooths(externalIds: string[]): void;
+    onCurrentPositionChanged(point: CurrentPosition): void;
+    onLeaveEvent?: () => void;
+    search(term: string): Promise<{
+        item: unknown;
+        score: number;
+    }[]>;
+    getFloors(): Floor[];
+    onFloorActivated(floor: Floor): void;
+    activateFloor(floorId: {
+        name?: string;
+        index?: number;
+    }): void;
+    /**
+     * All venues of the plan in switch order; one implicit venue on single-venue
+     * plans, whose `id` {@link activateVenue} accepts like any other.
+     */
+    getVenues(): Venue[];
+    /** Structured, deterministic venue-model diagnostics captured while loading the plan. */
+    getVenueDiagnostics(): VenueDiagnostic[];
+    /** Fires when venue focus settles on a different venue (tap, API, deep link, or pan handover). */
+    onVenueActivated(venue: Venue): void;
+    /**
+     * Focuses a venue by its `id` — the durable handle; a display name resolves
+     * nothing. Any `id` {@link getVenues} returned is accepted, including the
+     * implicit venue of a single-venue plan, where activation is a no-op because
+     * that venue is already active. An `id` that was never issued reports a
+     * not-found error, whatever the plan's shape.
+     */
+    activateVenue(venueId: {
+        id: string;
+    }): void;
+    showPathway(pathwayId: string, externalIds: string[]): void;
+    showPathwayOnly(pathwayId: string, floorId: string): void;
+    hidePathways(): void;
+    showSearch(): void;
+    changeLanguage(langId: string): void;
+    isGpsTrackingEnabled(): boolean;
+    setGpsTrackingEnabled(value: boolean): void;
+    deselectCurrentPosition(): void;
+    deselectRoute(): void;
+    reset(): void;
+    /**
+     * Same as {@link selectRoute}, but restricts the path to accessible segments only.
+     * @param waypoints - Ordered route stops (booth name/ID or `CurrentPosition`).
+     */
+    selectAccessibleRoute(waypoints: RouteWaypoint[]): void;
+}
+/**
+ * Options for configuring the FloorPlan instance.
+ */
+export interface FloorPlanOptions {
+    element?: HTMLDivElement | string;
+    onBoothClick?: (e: FloorPlanBoothClickEvent) => void;
+    onBookmarkClick?: (e: FloorPlanBookmarkClickEvent) => void;
+    onVisitedClick?: (e: FloorPlanVisitedClickEvent) => void;
+    onCategoryClick?: (e: FloorPlanCategoryClickEvent) => void;
+    /**
+     * @deprecated
+     * The onFpConfigured method is deprecated. Use onInit instead.
+     */
+    onFpConfigured?: () => void;
+    onDirection?: (e: FloorPlanDirectionEvent | null) => void;
+    onDetails?: (e: FloorPlanDetailsEvent) => void;
+    onExhibitorCustomButtonClick?: (e: FloorPlanCustomButtonEvent) => void;
+    onMarkerClick?: (e: FloorPlanMarkerEvent | undefined) => void;
+    onGetCoordsClick?: (e: FloorPlanGetCoordsEvent) => void;
+    /**
+     * Called when the user triggers a cross-venue journey's external handoff, so
+     * a native embedding can navigate the way it prefers. Omitted — or present
+     * and left unhandled — the SDK opens the event's provider URL itself, which
+     * is what every existing embedding keeps doing.
+     */
+    onExternalNavigation?: (e: FloorPlanExternalNavigationEvent) => void;
+    onInit?: (fp: FloorPlan) => void;
+    onCurrentPositionChanged?: (point: CurrentPosition) => void;
+    onFloorActivated?: (floor: Floor) => void;
+    onVenueActivated?: (venue: Venue) => void;
+    onLeaveEvent?: () => void;
+}
+/** MapLibre options — the config schema (`MapLibreConfigSchema`) is the single definition. */
+export type MaplibreOptions = NonNullable<Config['maplibre']>;
+export interface Layer {
+    name: string;
+    description: string;
+}
+export interface FloorPlanBoothBase {
+    id: number;
+    externalId: string;
+    name: string;
+    layer: Layer;
+}
+export interface FloorPlanBooth extends FloorPlanBoothBase {
+    id: number;
+    name: string;
+    externalId: string;
+    isSpecial: boolean;
+    exhibitors: number[];
+    layer: Layer;
+    meta: Record<string, string>;
+    description: string;
+    entity: Entity;
+    title?: string;
+}
+export interface FloorPlanBoothClickEvent {
+    target: FloorPlanBoothBase;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface FloorPlanBookmarkClickEvent {
+    name: string;
+    bookmarked: boolean;
+    externalId: string;
+}
+export interface FloorPlanVisitedClickEvent {
+    name: string;
+    visited: boolean;
+    externalId: string;
+}
+type FloorPlanCategoryClickEvent = FloorPlanCategory;
+/**
+ * A route endpoint as the direction event reports it. A booth carries its own layer and external
+ * id; a point picked on the map (the blue dot, a kiosk anchor) carries the layer name it snapped
+ * to, so both fields read as optional here.
+ */
+export interface FloorPlanDirectionEndpoint {
+    id: number;
+    externalId?: string;
+    name: string;
+    layer: {
+        name?: string;
+        description?: string;
+    };
+}
+export interface FloorPlanDirectionEvent {
+    /** The origin, `null` while the route has only a destination. */
+    from: FloorPlanDirectionEndpoint | null;
+    /** The destination, `null` while the route has only an origin. */
+    to: FloorPlanDirectionEndpoint | null;
+    /**
+     * Route polyline segments in walking order — from the origin (`from`) to the
+     * destination (`to`), each `p0 → p1` pointing forward along the route.
+     *
+     * Changed in v3.12.0: segments run source→target. Earlier versions emitted
+     * them reversed (target→source, with `p0`/`p1` swapped).
+     */
+    lines: {
+        p0: Point;
+        p1: Point;
+    }[];
+    /** Length with units (`"120m"`), empty while the route length is still unknown. */
+    distance: string;
+    units: string;
+    time: number;
+}
+export interface FloorPlanDetailsEvent {
+    type: 'booth' | 'exhibitor' | 'route' | 'category';
+    id: string;
+    name: string;
+    externalId: string;
+    boothsNames: string[];
+    routeInfo?: Record<string, unknown>;
+}
+export interface FloorPlanCustomButtonEvent {
+    externalId: string;
+    buttonNumber: number;
+    buttonUrl: string;
+    preventDefault: () => void;
+}
+/**
+ * Human-readable context for an external handoff — the names a host app can put
+ * in its own UI without resolving anything itself.
+ */
+export interface FloorPlanExternalNavigationContext {
+    /** The venue the journey leaves. */
+    originVenue: string;
+    /** The venue the journey leads to. */
+    destinationVenue: string;
+    /**
+     * The name of the authored entrance the handoff aims at. Absent while the
+     * venue has no entrance authored — the handoff then aims at the venue's
+     * marker point, which is normal behavior for such plans, not an error — and
+     * absent for a door whose author gave it no name.
+     */
+    entrance?: string;
+    /** What the handoff point is called: the entrance when there is one, the venue itself otherwise. */
+    label: string;
+}
+/**
+ * The external handoff of a cross-venue journey, offered to the host app the
+ * moment the user triggers it.
+ *
+ * Doing nothing keeps the SDK's default — it opens {@link url} itself. A host
+ * that would rather launch a native maps intent calls {@link preventDefault}
+ * and navigates on its own.
+ */
+export interface FloorPlanExternalNavigationEvent {
+    /** Where the handoff leads, in geographic coordinates — the point {@link url} names. */
+    destination: LatLng;
+    context: FloorPlanExternalNavigationContext;
+    /**
+     * The ready-made provider URL: Apple Maps on iOS/iPadOS, Google Maps
+     * elsewhere, or whichever provider the event's `mapsProvider` pins. What the
+     * SDK opens when the event goes unhandled.
+     */
+    url: string;
+    /**
+     * The journey deep link — identifiers only, re-planned on open. A host that
+     * discards its WebView during the maps round trip reopens the journey with
+     * this. Absent while the journey's destination has no identifier to name.
+     */
+    deepLink?: string;
+    /**
+     * Marks the event handled: the SDK then opens nothing and the handoff is the
+     * host's alone. Same idiom as {@link FloorPlanCustomButtonEvent.preventDefault}.
+     */
+    preventDefault: () => void;
+}
+export interface FloorPlanGetCoordsEvent extends Point {
+    z: string | null;
+}
+export interface FloorPlanMarkerEvent extends Point {
+    id: string;
+    z?: number | string;
+}
+export interface FloorPlanExhibitor {
+    id: number;
+    name: string;
+    externalId: string;
+    booths: number[];
+    entity: Entity;
+    slug: string;
+}
+export interface FloorPlanCategory {
+    id: number;
+    name: string;
+    exhibitors: number[];
+    entity: Entity;
+    slug: string;
+}
+export type RouteWaypoint = string | CurrentPosition;
+export interface RouteInfo {
+    waypoints: RouteWaypoint[];
+}
+export interface ExpoData {
+    booths: FloorPlanBooth[];
+    exhibitors: FloorPlanExhibitor[];
+    categories: FloorPlanCategory[];
+}
+export type FloorPlanIcon = 'departure' | 'departure_inactive' | 'destination' | 'direction' | 'transition' | 'transition_up' | 'transition_down' | 'kiosk' | 'yah';
+export interface LayerPoint extends Point {
+    layer: string;
+}
+export interface Entity {
+    type: 'booth' | 'category' | 'exhibitor' | 'schedule' | 'language' | 'heatmap-yah' | 'route-cut-in';
+    variant?: 'regular' | 'special';
+}
+export interface FloorPlanSchedule {
+    id: number;
+    externalId: string;
+    boothId: number;
+    exhibitorId: number;
+    name: string;
+    description: string;
+    startDate: string;
+    endDate: string;
+    link: string;
+    entity: Entity;
+    isEnded: boolean;
+}
+/** One selectable UI language (as `utils/i18n.ts` serves them). */
+export interface Language {
+    readonly id: string;
+    readonly name: string;
+    readonly entity: {
+        readonly type: 'language';
+    };
+}
+export interface FloorPlanHeatmapYah {
+    id: string;
+    name: string;
+    viewCount: number;
+    x: number;
+    y: number;
+    z: number | string;
+    entity: Entity;
+}
+export type FloorPlanEntity = FloorPlanBooth | FloorPlanCategory | FloorPlanExhibitor | FloorPlanSchedule | Language | FloorPlanHeatmapYah;
+export interface Floor {
+    name: string;
+    shortName: string;
+    description: string;
+    active: boolean;
+    disabled: boolean;
+    index: number;
+    venueId?: string;
+    ordinal?: number;
+    displayName?: string;
+}
+/**
+ * A venue of a multi-venue plan (multi-venue data contract v1). Single-venue
+ * plans report one implicit venue so the API shape is uniform.
+ */
+export interface Venue {
+    /**
+     * The venue's durable handle. Authored on multi-venue plans, where the
+     * contract constrains it to `[a-z0-9_-]+`; SDK-synthesised from the event key
+     * on single-venue plans, where it has no wire representation and that pattern
+     * does not bind it. Either way it is what `activateVenue` resolves.
+     */
+    id: string;
+    name: string;
+    order: number;
+    active: boolean;
+}
+/**
+ * What the SDK did with the authored value — the single axis of a venue
+ * diagnostic. There is no severity field: a producer's export gate is derived
+ * from `dropped`, plus the two contractually required fields whose fallback
+ * puts them out of its reach (contract §11).
+ */
+export type VenueDiagnosticEffect = 'dropped' | 'fallback' | 'clamped' | 'advisory';
+export interface VenueDiagnostic {
+    /**
+     * Stable machine identity for the rule, kebab-case `<subject>-<condition>`
+     * (e.g. `level-layer-unknown`). Key handling off this — never off `message`
+     * or `consequence`, which are prose and may be reworded in any revision.
+     */
+    code: string;
+    /** Where in the payload, e.g. `venues[2].layers[0].minSizePx`. */
+    path: string;
+    /** What was wrong. */
+    message: string;
+    /** What happened as a result — not derivable from `effect`. */
+    consequence: string;
+    effect: VenueDiagnosticEffect;
+}
+export interface CurrentPosition extends Point {
+    z?: number | string;
+    angle?: number;
+    lat?: number;
+    lng?: number;
+}
+export interface Marker extends CurrentPosition {
+    id: string;
+    icon: string;
+    selectedIcon: string;
+    position: 'centertop' | 'lefttop' | 'centerbottom';
+    active?: boolean;
+}
+export interface MarkerIcon {
+    name: string;
+    content: string;
+    width: number;
+    height: number;
+    scale?: number;
+}
+export interface MarkersData {
+    icons: MarkerIcon[];
+    markers: Marker[];
+}
+export interface Visibility {
+    controls?: boolean;
+    levels?: boolean;
+    header?: boolean;
+    overlay?: boolean;
+    searchButtons?: boolean;
+}
+export interface Rect {
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+}
+/**
+ * Defines a rectangular bounding box using two corner points.
+ */
+export interface Bounds {
+    /** Top-left corner of the bounding box */
+    leftTop: Point;
+    /** Bottom-right corner of the bounding box */
+    rightBottom: Point;
+}
+/**
+ * Selector for identifying a Point of Interest (POI) by name or external ID.
+ */
+export interface POISelector {
+    /** Name of the POI */
+    name?: string;
+    /** External identifier of the POI */
+    externalId?: string;
+}
+/**
+ * Collection of POI selectors for booths and exhibitors.
+ */
+export interface POISelectors {
+    /** Array of booth selectors */
+    booths?: POISelector[];
+    /** Array of exhibitor selectors */
+    exhibitors?: POISelector[];
+}
+/**
+ * Geographic anchor point that ties a floor plan coordinate to a real-world
+ * GPS location. Used to georeference the map.
+ */
+export interface GeoAnchor {
+    /** X coordinate in the floor plan coordinate system */
+    x: number;
+    /** Y coordinate in the floor plan coordinate system */
+    y: number;
+    /** Latitude in decimal degrees */
+    lat: number;
+    /** Longitude in decimal degrees */
+    lng: number;
+}
+/**
+ * Geographic configuration of the floor plan: its orientation and the anchor
+ * points that map local coordinates to GPS positions.
+ */
+export interface GeoConfig {
+    /** Bearing in degrees clockwise from true north; `0` when the map is north-aligned. */
+    bearing: number;
+    /** Primary anchor point. */
+    p0: GeoAnchor;
+    /** Optional secondary anchor point. */
+    p1?: GeoAnchor;
+    /** Tertiary anchor point. */
+    p2: GeoAnchor;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.js

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

package/dist/esm/utils/_OLD_gpu-info.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    vendor: string;
+    renderer: string;
+};
+export default _default;
+//# sourceMappingURL=_OLD_gpu-info.d.ts.map

package/dist/esm/utils/_OLD_gpu-info.js

@@ -0,0 +1,23 @@
+/* eslint-disable no-empty */
+// @ts-nocheck
+import logger from '../tools/logger';
+const canvas = document.createElement('canvas');
+let gl;
+let debugInfo;
+let vendor = '';
+let renderer = '';
+try {
+    gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+    if (gl) {
+        debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+        vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+        renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+    }
+}
+catch (e) { }
+logger.log('GPU vendor: ', vendor);
+logger.log('GPU renderer: ', renderer);
+export default {
+    vendor,
+    renderer,
+};

package/dist/esm/utils/_OLD_should-use-backdrop.d.ts

@@ -0,0 +1,3 @@
+declare const isWebkit: boolean;
+export default isWebkit;
+//# sourceMappingURL=_OLD_should-use-backdrop.d.ts.map

package/dist/esm/utils/_OLD_should-use-backdrop.js

@@ -0,0 +1,4 @@
+// const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+// import gpuInfo from './gpu-info';
+const isWebkit = navigator.userAgent.indexOf('AppleWebKit') !== -1;
+export default isWebkit; // && !!gpuInfo;

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

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

package/dist/esm/utils/areLayersEnabled.js

@@ -0,0 +1,4 @@
+import { getFpSvgJs } from '../data/fp-payloads';
+export function areLayersEnabled() {
+    return !!getFpSvgJs().__fpLayers;
+}

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