@expofp/floorplan 3.0.0-alpha.9 → 3.0.1

package/dist/esm/wayfinding/rendering/computeTransitionPoints.d.ts

@@ -0,0 +1,31 @@
+import type { RouteLine } from "../types";
+interface TransitionPointsInput {
+    /** Full route including virtual lines */
+    readonly routeLines: RouteLine[];
+    /** Current floor name (null = single-floor) */
+    readonly currentLayerName: string | null;
+    /** Floor names ordered low → high (from layerStore.floors) */
+    readonly floorOrder: string[];
+}
+interface TransitionPointDef {
+    readonly x: number;
+    readonly y: number;
+    /** Floor where the icon is rendered */
+    readonly layer: string;
+    /** Floor the transition leads to (for click-to-switch) */
+    readonly targetLayer: string;
+    readonly direction: "up" | "down" | "neutral";
+    /** Whether this is an entry (arriving from another floor) or exit (leaving to another floor) in walking direction */
+    readonly role: "entry" | "exit";
+}
+/**
+ * Computes deduplicated, correctly-directed transition points for the
+ * current floor.
+ *
+ * Works directly with the full `routeLines` array (including virtual lines)
+ * and does NOT depend on `routeNextFloor` — the target floor is read from
+ * the opposite endpoint of each virtual line.
+ */
+export declare function computeTransitionPoints(input: TransitionPointsInput): TransitionPointDef[];
+export {};
+//# sourceMappingURL=computeTransitionPoints.d.ts.map

package/dist/esm/wayfinding/rendering/computeTransitionPoints.js

@@ -0,0 +1 @@
+function s(o,n){return o.toLowerCase()===n.toLowerCase()}function p(o,n){return o.findIndex(r=>s(r,n))}function x(o,n,r){const a=p(o,n),t=p(o,r);return a===-1||t===-1?"neutral":t>a?"up":"down"}function d(o,n,r){return o.find(a=>s(a.p0.layer,n)?!r.has(a.p1.layer.toLowerCase()):s(a.p1.layer,n)?!r.has(a.p0.layer.toLowerCase()):!1)}function C(o,n,r,a){if(n.has(a.toLowerCase()))return a;let t=a;const l=new Set([r.toLowerCase(),t.toLowerCase()]);let u=d(o,t,l);for(;u&&(t=s(u.p0.layer,t)?u.p1.layer:u.p0.layer,!n.has(t.toLowerCase()));)l.add(t.toLowerCase()),u=d(o,t,l);return t}export function computeTransitionPoints(o){const{routeLines:n,currentLayerName:r,floorOrder:a}=o,t=n.filter(e=>e.virtual&&!s(e.p0.layer,e.p1.layer)),l=new Set;for(const e of n)e.virtual||(l.add(e.p0.layer.toLowerCase()),l.add(e.p1.layer.toLowerCase()));const w=(r?t.filter(e=>s(e.p0.layer,r)||s(e.p1.layer,r)):t).map(e=>{const c=r?s(e.p0.layer,r):!0,i=c?e.p0:e.p1,L=c?e.p1:e.p0,f=C(t,l,i.layer,L.layer);return{x:i.x,y:i.y,layer:i.layer,targetLayer:f,direction:x(a,i.layer,f),role:r&&c?"entry":"exit"}}),y=new Set;return w.filter(e=>{const c=`${e.x}:${e.y}`;return y.has(c)?!1:(y.add(c),!0)})}

package/dist/esm/wayfinding/rendering/normalizeRouteDirection.d.ts

@@ -0,0 +1,19 @@
+import type { RouteLine, RoutePoint } from "../types";
+/**
+ * Ensures that `routeLines` run in the from→to direction.
+ *
+ * A* returns paths in target→source order. For rendering (arrow animation,
+ * route progress split) the lines must go from the origin to the destination.
+ *
+ * The function projects `from` and `to` onto `entireRouteLines` (the full
+ * multi-floor route) and reverses `routeLines` if `from` is closer to the
+ * polyline end than to its start.
+ *
+ * @param entireRouteLines  Full route across all floors (used to determine direction).
+ * @param routeLines        Lines to normalize (may be a floor-filtered subset).
+ * @param from              Route origin (user-selected "from" point).
+ * @param to                Route destination (user-selected "to" point).
+ * @returns Lines guaranteed to run from→to, or the original array unchanged.
+ */
+export declare function normalizeRouteDirection(entireRouteLines: RouteLine[], routeLines: RouteLine[], from: RoutePoint, to: RoutePoint): RouteLine[];
+//# sourceMappingURL=normalizeRouteDirection.d.ts.map

package/dist/esm/wayfinding/rendering/normalizeRouteDirection.js

@@ -0,0 +1 @@
+function l(n,r,d){let a=0,p=1/0,e=1/0;const s=d.reduce((c,t)=>c+t,0);for(let c=0;c<r.length;c++){const t=r[c],f=d[c];if(t.p0.layer!==n.layer){a+=f;continue}const o=t.p1.x-t.p0.x,y=t.p1.y-t.p0.y,h=o*o+y*y;if(h<1e-10){a+=f;continue}const i=((n.x-t.p0.x)*o+(n.y-t.p0.y)*y)/h,u=Math.max(0,Math.min(1,i)),x=t.p0.x+o*u,g=t.p0.y+y*u,m=Math.hypot(n.x-x,n.y-g);m<p&&(p=m,e=a+f*u),a+=f}return{found:e!==1/0,fromStart:e,total:s}}export function normalizeRouteDirection(n,r,d,a){if(!r.length)return r;const p=n.map(o=>Math.hypot(o.p1.x-o.p0.x,o.p1.y-o.p0.y)),e=l(d,n,p),s=e.found?e:l(a,n,p);if(!s.found)return r;const c=s.fromStart,t=s.total-s.fromStart;return(e.found?t<c:c<t)?r.slice().reverse().map(o=>({...o,p0:o.p1,p1:o.p0})):r}

package/dist/esm/wayfinding/rendering/routeGeometry.d.ts

@@ -0,0 +1,16 @@
+import { Point, Line } from "simple-geometry";
+/**
+ * Recursive De Casteljau interpolation for a Bézier curve.
+ * Returns the point on the curve defined by `controlPoints` at parameter `t` (0–1).
+ */
+export declare function bezierCurve(controlPoints: Point[], t: number): Point;
+/**
+ * Splits a polyline (sequence of line segments) into evenly spaced points
+ * separated by `interval` units. Preserves the first and last points of the polyline.
+ *
+ * When segments meet at an angle, the remaining distance from the previous segment
+ * is projected onto the next segment direction (cosine correction) to maintain
+ * visually consistent spacing around corners.
+ */
+export declare function splitPolyLine(lines: Line[], interval: number): Point[];
+//# sourceMappingURL=routeGeometry.d.ts.map

package/dist/esm/wayfinding/rendering/routeGeometry.js

@@ -0,0 +1 @@
+export function bezierCurve(t,e){if(t.length===0)return{x:0,y:0};if(t.length===1)return t[0];const s=[];for(let n=0;n<t.length-1;n++){const c=(1-e)*t[n].x+e*t[n+1].x,x=(1-e)*t[n].y+e*t[n+1].y;s.push({x:c,y:x})}return bezierCurve(s,e)}export function splitPolyLine(t,e){if(t.length===0)return[];if(e<=0)return[t[0].p0,t[t.length-1].p1];const s=[];let n=0;for(let o=0;o<t.length;o++){const M=t[o],p=M.p0,l=M.p1,u=l.x-p.x,a=l.y-p.y,h=Math.sqrt(u*u+a*a);if(h===0)continue;const w=u/h,X=a/h;let r=0;for(;n+r*e<=h;){const f=n+r*e,g=p.x+w*f,i=p.y+X*f;s.push({x:g,y:i}),r++}const Y=n+(r-1)*e;let y=h-Y;if(y=Math.max(y,0),o<t.length-1){const f=t[o+1],g=f.p0,i=f.p1,d=i.x-g.x,D=i.y-g.y,L=Math.sqrt(d*d+D*D);if(L===0)n=0;else{const q=d/L,b=D/L,z=w*q+X*b,A=y*z;n=e-A}}else n=e-y;n=Math.max(n,0)}const c=t[0].p0;(s.length===0||s[0].x!==c.x||s[0].y!==c.y)&&s.unshift(c);const x=t[t.length-1].p1,m=s[s.length-1];return(m.x!==x.x||m.y!==x.y)&&s.push(x),s}

package/dist/esm/wayfinding/routing/buildMultiPointRoute.d.ts

@@ -0,0 +1,11 @@
+import type { GraphInstance, RoutePoint, RouteResult } from "../types";
+/**
+ * Builds a route through an ordered sequence of pre-resolved candidate groups.
+ * Each group is a `RoutePoint[]` — the candidate graph points for one waypoint.
+ *
+ * Intermediate groups with no candidates (empty arrays) are silently skipped —
+ * adjacent groups are connected directly. This matches the legacy behavior
+ * where unreachable waypoints were omitted.
+ */
+export declare function buildMultiPointRoute(graph: GraphInstance, candidateGroups: RoutePoint[][]): RouteResult;
+//# sourceMappingURL=buildMultiPointRoute.d.ts.map

package/dist/esm/wayfinding/routing/buildMultiPointRoute.js

@@ -0,0 +1 @@
+import{buildRoute as u}from"./buildRoute";import{emptyResult as o}from"./routeResult";export function buildMultiPointRoute(i,r){if(r.length<2)return o();const e=r.filter((t,l)=>l===0||l===r.length-1?!0:t.length>0);if(e.length<2)return o();if(e.length===2)return u(i,e[0],e[1]);const n=[];for(let t=0;t<e.length-1;t++)n.push(u(i,e[t],e[t+1]));n.reverse();const s=n.flatMap(t=>t.lines),f=n.reduce((t,l)=>t+l.totalDistance,0);return{lines:s,totalDistance:f}}

package/dist/esm/wayfinding/routing/buildRoute.d.ts

@@ -0,0 +1,9 @@
+import type { GraphInstance, RouteResult, RoutePoint } from "../types";
+/**
+ * Builds a route between two sets of candidate graph points.
+ *
+ * This is pure pathfinding — it does not resolve waypoints to graph points.
+ * Resolution is the caller's responsibility (see `getGraphLines`).
+ */
+export declare function buildRoute(graph: GraphInstance, fromCandidates: RoutePoint[], toCandidates: RoutePoint[]): RouteResult;
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/esm/wayfinding/routing/buildRoute.js

@@ -0,0 +1 @@
+import{findShortestPath as l}from"../graph/findShortestPath";import{emptyResult as n}from"./routeResult";export function buildRoute(i,e,r){if(!e.length||!r.length)return n();const t=l(i,e,r);return t?{lines:t.lines,totalDistance:t.distance}:n()}

package/dist/esm/wayfinding/routing/findNearestGraphPoint.d.ts

@@ -0,0 +1,21 @@
+import { Rect as SGRect } from "simple-geometry";
+import type { GraphDataSource, GraphInstance, RoutePoint } from "../types";
+/**
+ * Finds all graph endpoints (lineEnds) that fall inside the given containment rect.
+ * Uses simple-geometry's pointInsideRectangle for ~1% tolerance at boundaries,
+ * matching the legacy wayfinding behavior.
+ *
+ * The rect is a simple-geometry Rect (4-point polygon) — it may be rotated,
+ * not necessarily axis-aligned.
+ */
+export declare function findGraphPointsInRect(dataSource: GraphDataSource, containmentRect: SGRect, layer?: string): RoutePoint[];
+/**
+ * Finds the nearest graph endpoint by Euclidean distance from an arbitrary point.
+ * Generalizes the old rect-based filtering for point-to-point routing.
+ */
+export declare function findNearestGraphPoint(graph: GraphInstance, point: {
+    x: number;
+    y: number;
+    layer?: string;
+}): RoutePoint | null;
+//# sourceMappingURL=findNearestGraphPoint.d.ts.map

package/dist/esm/wayfinding/routing/findNearestGraphPoint.js

@@ -0,0 +1 @@
+import{lineLength as a,pointInsideRectangle as c}from"simple-geometry";export function findGraphPointsInRect(i,n,t){return i.getLineEnds().filter(e=>(!t||e.layer===t)&&c(e,n))}export function findNearestGraphPoint(i,n){const t=i.dataSource.getLineEnds();let e=null,o=1/0;for(const r of t){if(n.layer&&r.layer!==n.layer)continue;const s=a(r,n);s<o&&(o=s,e=r)}return e}

package/dist/esm/wayfinding/routing/getGraphLines.d.ts

@@ -0,0 +1,14 @@
+import type { RouteWaypoint, RouteLine, GraphDataSource } from "../types";
+/**
+ * High-level routing: resolves waypoints to route lines using a cached graph.
+ * Accepts `GraphDataSource` explicitly — no global configuration.
+ *
+ * Orchestrates two steps:
+ * 1. Resolve: waypoint → candidate graph points (via resolveWaypointCandidates)
+ * 2. Route: candidate points → shortest path via A* (via buildRoute / buildMultiPointRoute)
+ *
+ * Returns lines in **target→source** order — the convention used throughout
+ * the pipeline (see `aStarPathFinder.find()` JSDoc for rationale).
+ */
+export declare function getGraphLines(dataSource: GraphDataSource, from: RouteWaypoint, to: RouteWaypoint, onlyAccessible?: boolean, waypoints?: RouteWaypoint[]): RouteLine[];
+//# sourceMappingURL=getGraphLines.d.ts.map

package/dist/esm/wayfinding/routing/getGraphLines.js

@@ -0,0 +1 @@
+import{createGraphCache as f}from"../graph/graphCache";import{buildRoute as m}from"./buildRoute";import{buildMultiPointRoute as h}from"./buildMultiPointRoute";import{findGraphPointsInRect as p,findNearestGraphPoint as g}from"./findNearestGraphPoint";const C=f();function o(r,e){if(e.rect)return p(r.dataSource,e.rect,e.layer);const n=g(r,{x:e.x,y:e.y,layer:e.layer});return n?[n]:[]}export function getGraphLines(r,e,n,l=!1,a=[]){const u=performance.now(),t=C.getOrBuild(r,l),s=o(t,e),c=o(t,n),i=a.length>0?h(t,[s,...a.map(d=>o(t,d)),c]):m(t,s,c);return console.debug(`WF. Get graph lines: ${i.lines.length} ~ ${performance.now()-u}ms.`),i.lines}

package/dist/esm/wayfinding/routing/getRouteLength.d.ts

@@ -0,0 +1,3 @@
+import { RouteLine } from "../types";
+export declare function getRouteLength(routeLines: RouteLine[]): number;
+//# sourceMappingURL=getRouteLength.d.ts.map

package/dist/esm/wayfinding/routing/getRouteLength.js

@@ -0,0 +1 @@
+import{lineLength as n}from"simple-geometry";export function getRouteLength(t){return t.reduce((r,e)=>r+n(e.p0,e.p1),0)}

package/dist/esm/wayfinding/routing/routeResult.d.ts

@@ -0,0 +1,4 @@
+import type { RouteResult } from "../types";
+/** Returns a fresh empty result each call to avoid shared-mutable-object bugs at runtime. */
+export declare const emptyResult: () => RouteResult;
+//# sourceMappingURL=routeResult.d.ts.map

package/dist/esm/wayfinding/routing/routeResult.js

@@ -0,0 +1 @@
+export const emptyResult=()=>({lines:[],totalDistance:0});

package/dist/esm/wayfinding/types.d.ts

@@ -0,0 +1,76 @@
+import { Rect as SimpleGeometryRect } from "simple-geometry";
+export interface RoutePoint {
+    readonly x: number;
+    readonly y: number;
+    readonly layer: string;
+}
+export interface RouteLine {
+    readonly p0: RoutePoint;
+    readonly p1: RoutePoint;
+    /**
+     * Internal graph properties from external wayfinding data (wf.data.js).
+     * Temporarily public because config-wf.ts and RouteStore read RouteLine directly.
+     * After Phase 7 (WayfindingRuntime), consumers will receive filtered data
+     * through RenderPort/WayfindingStore and these fields will become internal.
+     */
+    readonly unaccessible: boolean;
+    readonly unidirection: boolean;
+    readonly virtual: boolean;
+    readonly weight: number;
+    /**
+     * Optional custom cost for virtual (floor-transition) links, configured
+     * per-line in the designer as "Virtual length". When set, the pathfinder
+     * uses this value instead of the default VIRTUAL_LINE_PENALTY (0), making
+     * the transition less preferred so routes may stay on the same floor.
+     */
+    readonly virtualLength?: number;
+}
+export interface PathNode {
+    readonly id: string;
+    readonly layer: string;
+    readonly x: number;
+    readonly y: number;
+}
+export interface PathFinderOptions {
+    readonly oriented: boolean;
+    readonly onlyAccessible: boolean;
+}
+export interface PathFinder {
+    build(lines: RouteLine[], options: PathFinderOptions): void;
+    find(fromId: string, toId: string): PathNode[];
+    hasNode(id: string): boolean;
+}
+export interface GraphDataSource {
+    getLines(): RouteLine[];
+    getLineEnds(): RoutePoint[];
+}
+export interface GraphInstance {
+    readonly finder: PathFinder;
+    readonly dataSource: GraphDataSource;
+    readonly options: GraphBuildOptions;
+}
+export interface GraphBuildOptions {
+    readonly oriented?: boolean;
+    readonly onlyAccessible?: boolean;
+}
+export interface ShortestPathResult {
+    readonly lines: RouteLine[];
+    readonly distance: number;
+}
+export interface RouteResult {
+    readonly lines: RouteLine[];
+    readonly totalDistance: number;
+}
+export interface RouteWaypoint {
+    readonly x: number;
+    readonly y: number;
+    readonly layer?: string;
+    /**
+     * Optional containment rect for booth-based graph point resolution.
+     * When set, resolveWaypointCandidates finds all graph endpoints inside this rect
+     * instead of falling back to nearest-point lookup.
+     * Populated by boothToWaypoint adapter. Not part of the public module contract.
+     */
+    readonly rect?: SimpleGeometryRect;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/wayfinding/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/floorplan",
-  "version": "3.0.0-alpha.9",
+  "version": "3.0.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -35,11 +35,8 @@
   ],
   "dependencies": {
     "@expofp/renderer": "^2.1.2",
-    "@grafana/faro-web-sdk": "^1.19.0",
-    "@grafana/faro-web-tracing": "^1.19.0",
     "@sentry/core": "^10.38.0",
     "@sentry/react": "10.34.0",
-    "array-flat-polyfill": "^1.0.1",
     "bowser": "^2.7.0",
     "classnames": "^2.2.6",
     "color": "^3.1.2",
@@ -54,7 +51,6 @@
     "dateformat": "^3.0.3",
     "debug": "^4.4.3",
     "deepmerge": "^4.2.2",
-    "document-ready": "^2.0.2",
     "fontfaceobserver": "^2.3.0",
     "fuse.js": "^7.1.0",
     "glob": "^7.1.6",
@@ -83,13 +79,13 @@
     "twgl.js": "^4.14.0",
     "uuid": "^9.0.1",
     "zod": "4.3.5",
-    "@expofp/data": "3.0.0-alpha.9",
-    "@expofp/debug": "3.0.0-alpha.9",
-    "@expofp/resolve": "3.0.0-alpha.9"
+    "@expofp/resolve": "3.0.1",
+    "@expofp/debug": "3.0.1"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^7.29.0",
     "@babel/plugin-transform-class-properties": "^7.28.6",
+    "@sentry/vite-plugin": "5.1.1",
     "@types/d3": "^7.1.0",
     "@types/lz-string": "1.3.32",
     "@types/mapbox-gl": "^2.6.3",

package/dist/browser/Debug-k5RKtjZM.js

@@ -1,31 +0,0 @@
-function __vite_inject_css__(css, id, nonce){  if (typeof document==='undefined') return;  var s=document.createElement('style');  s.setAttribute('data-vite-chunk-style', id);  s.appendChild(document.createTextNode(css));  document.head.appendChild(s);}
-import { j as a } from "./jsx-runtime-jIxVPx5o.js";
-import { c as n, a as t, s as i } from "./floorplan.ready-DEdtWjzo.js";
-import { u as l } from "./index-1HPoYB-N.js";
-const e = [];
-function u() {
-  const r = e.map((s) => s.width * s.height).reduce((s, c) => s += c, 0), o = e.map((s) => /* @__PURE__ */ a.jsxs("div", { className: "debug__canvas", id: s.toDataURL(), children: [
-    s.width,
-    "x",
-    s.height,
-    "=",
-    s.width * s.height,
-    /* @__PURE__ */ a.jsx("br", {}),
-    /* @__PURE__ */ a.jsx("img", { src: s.toDataURL(), alt: "", crossOrigin: "anonymous" })
-  ] }, s.toDataURL()));
-  return /* @__PURE__ */ a.jsxs("div", { className: "debug", children: [
-    /* @__PURE__ */ a.jsx("button", { onClick: () => i.searchStore.selectSearch(""), children: l("Close") }),
-    /* @__PURE__ */ a.jsxs("div", { children: [
-      "Total square: ",
-      r
-    ] }),
-    o
-  ] });
-}
-const g = () => n(() => /* @__PURE__ */ a.jsx(a.Fragment, { children: t.list.type === "search" && t.list.text === "q1" ? /* @__PURE__ */ a.jsx(u, {}) : null }));
-export {
-  g as default
-};
-
-;/* vite-per-chunk-css */
-__vite_inject_css__(".debug{position:fixed;top:1rem;left:1vw;z-index:999;width:calc(100vw - 2rem);height:calc(100vh - 2rem);padding:1rem;overflow:scroll;background:var(--color-white);box-shadow:0 0 1rem #00000080}.debug label{display:block;font-weight:var(--font-weight-bold)}.debug__canvas{display:inline-block;padding:2px;vertical-align:top}.debug__canvas>img{background:var(--color-gray-300)}\n/*$vite$:1*/", "Debug.css", undefined);

package/dist/browser/Demo-CgMWCXus.js

@@ -1,38 +0,0 @@
-import { j as e } from "./jsx-runtime-jIxVPx5o.js";
-import { y as n } from "./index-04R_J8Na.js";
-import { u as a, a as d, b as m, c } from "./floorplan.ready-DEdtWjzo.js";
-import { u as t } from "./index-1HPoYB-N.js";
-const r = "note-dismissed5";
-function f() {
-  const s = a(() => ({
-    hidden: !0,
-    get top() {
-      return d.screenSize.width <= 820;
-    },
-    get classes() {
-      return n({
-        demo: !0,
-        top: this.top,
-        hidden: this.hidden
-      });
-    }
-  }));
-  return m(() => {
-    sessionStorage.getItem(r) || window.setTimeout(() => {
-      s.hidden = !1;
-    }, 2e3);
-  }), c(() => /* @__PURE__ */ e.jsx("div", { className: s.classes, children: /* @__PURE__ */ e.jsxs("section", { children: [
-    /* @__PURE__ */ e.jsx("div", { className: "demo__message", children: /* @__PURE__ */ e.jsxs("span", { children: [
-      t("Get your free floor plan at"),
-      " ",
-      /* @__PURE__ */ e.jsx("a", { href: "https://expofp.com/", target: "_blank", rel: "noopener noreferrer", children: "ExpoFP.com" })
-    ] }) }),
-    /* @__PURE__ */ e.jsx("a", { href: "/", onClick: o, className: "demo__dismiss", children: t("Dismiss") })
-  ] }) }));
-  function o(i) {
-    i.preventDefault(), s.hidden = !0, sessionStorage.setItem(r, "1");
-  }
-}
-export {
-  f as default
-};

package/dist/browser/Free-D7jT727E.js

@@ -1,42 +0,0 @@
-function __vite_inject_css__(css, id, nonce){  if (typeof document==='undefined') return;  var s=document.createElement('style');  s.setAttribute('data-vite-chunk-style', id);  s.appendChild(document.createTextNode(css));  document.head.appendChild(s);}
-import { j as e } from "./jsx-runtime-jIxVPx5o.js";
-import { y as n } from "./index-04R_J8Na.js";
-import { u as a, a as d, b as m, c } from "./floorplan.ready-DEdtWjzo.js";
-import { a2 as f, u as r } from "./index-1HPoYB-N.js";
-const t = "free-dismissed5";
-function x() {
-  const s = a(() => ({
-    hidden: !0,
-    get top() {
-      return d.screenSize.width < f;
-    },
-    get classes() {
-      return n({
-        free: !0,
-        bottom: !this.top,
-        hidden: this.hidden
-      });
-    }
-  }));
-  return m(() => {
-    sessionStorage.getItem(t) || window.setTimeout(() => {
-      s.hidden = !1;
-    }, 2e3);
-  }), c(() => /* @__PURE__ */ e.jsx("div", { className: s.classes, children: /* @__PURE__ */ e.jsxs("section", { children: [
-    /* @__PURE__ */ e.jsx("div", { className: "free__message", children: /* @__PURE__ */ e.jsxs("span", { children: [
-      r("Create a free floor plan at"),
-      " ",
-      /* @__PURE__ */ e.jsx("a", { href: "https://expofp.com/", target: "_blank", rel: "noopener noreferrer", children: "ExpoFP.com" })
-    ] }) }),
-    /* @__PURE__ */ e.jsx("a", { href: "/", onClick: i, className: "free__dismiss", children: r("Dismiss") })
-  ] }) }));
-  function i(o) {
-    o.preventDefault(), s.hidden = !0, sessionStorage.setItem(t, "1");
-  }
-}
-export {
-  x as default
-};
-
-;/* vite-per-chunk-css */
-__vite_inject_css__(".free{position:absolute;bottom:0;display:flex;justify-content:center;width:100%;min-height:2rem;background:#ab40a0;background:linear-gradient(90deg,#e5175c,#5c17e5);opacity:1;transition:all .5s}.free>section{display:flex;padding:.2rem .5rem;font-size:.8rem;-webkit-user-select:none;user-select:none}.free__message{display:flex;align-items:center;color:#fff}.free__message a{color:#fff;text-decoration:underline}.free__dismiss{display:flex;align-items:center;margin-inline-start:.5rem;padding:.1rem .8rem;background:#1378d5;border-radius:2px;font-size:.8rem;font-weight:500;color:#fff!important;text-decoration:none!important}.free__dismiss:hover{background:#69b7ff}@media print{.free__dismiss{display:none}}.free.top{top:0;bottom:unset;width:100%;min-height:2.5rem}.free.top>section{flex-grow:1}.free.top span{display:inline-block}.free.top .free__message{flex-grow:1}.free.bottom .free__message{font-size:1.5rem;font-weight:300;color:#ffffffe6}.free.bottom>section{padding:.5rem}.free.bottom .free__dismiss{padding:.5rem 1rem;font-size:1.2rem;font-weight:600}.free.hidden{transform:translateY(100%)}.free.top.hidden{transform:translateY(-100%)}\n/*$vite$:1*/", "Free.css", undefined);