@kerros/viewer 0.0.0-stage → 0.1.0-rc.1

package/dist/model/boundaries.js

@@ -0,0 +1,548 @@
+import te from "polygon-clipping";
+import { validateRings as he } from "./validate.js";
+import { uid as F, isArea as V } from "./types.js";
+import { openRing as B, distance as v, pointInRing as H, closeRing as z, ringArea as C, footprint as U, segmentProjection as L, removeBarrier as ge, centroid as ne, rectangle as me, addBarrier as Ie } from "./geometry.js";
+import { GEOMETRY_EPS as w, MIN_RING_EDGE as K, MIN_FACE_AREA as re, CLIP_SCALE as R, MIN_WALL_LENGTH as pe, MIN_SPACE_AREA as oe } from "./precision.js";
+const E = (e) => [...e.barriers, ...e.virtualBoundaries ?? []], Be = (e) => {
+  var t;
+  return ((t = e.geometry) == null ? void 0 : t.mode) === "boundaries";
+}, T = (e, t) => {
+  const r = e.junctions.find((s) => s.id === t.startId), i = e.junctions.find((s) => s.id === t.endId);
+  if (!r || !i) throw new Error("A space boundary references a missing junction.");
+  return [r.position, i.position];
+}, se = (e) => [...e].reverse().map((t) => ({ edgeId: t.edgeId, reversed: !t.reversed })), _ = (e) => e.reduce((t, r, i) => {
+  const s = e[(i + 1) % e.length];
+  return t + r[0] * s[1] - s[0] * r[1];
+}, 0) / 2, j = (e) => C(e[0]) - e.slice(1).reduce((t, r) => t + C(r), 0), ie = (e) => e.reduce((t, r) => t + j(r), 0), de = (e) => e.map(
+  (t) => z(t).map(
+    (r) => [Math.round(r[0] * R) / R, Math.round(r[1] * R) / R]
+  )
+);
+function W(e, ...t) {
+  const r = (d) => d.map((g) => z(g).map((a) => [Math.round(a[0] * R), Math.round(a[1] * R)])), i = r(e), s = t.map(r);
+  let n;
+  try {
+    n = te.difference(i, ...s);
+  } catch {
+    n = [i];
+    for (const d of s) {
+      if (!n.length) break;
+      n = te.difference(n, d);
+    }
+  }
+  return n.map(
+    (d) => d.map(
+      (g) => g.map(
+        (a) => [Math.round(a[0] / R * 1e10) / 1e10, Math.round(a[1] / R * 1e10) / 1e10]
+      )
+    )
+  );
+}
+function ae(e, t, r) {
+  var i;
+  for (const s of e.objects)
+    ((i = s.geometry) == null ? void 0 : i.mode) === "boundaries" && (s.geometry.loops = s.geometry.loops.map(
+      (n) => n.flatMap((d) => d.edgeId !== t ? [d] : d.reversed ? se(r) : r)
+    ));
+}
+function N(e, t, r) {
+  const i = new Map(E(e).map((s) => [s.id, s]));
+  return t.map((s) => {
+    if (s.length < 3) throw new Error("A space boundary must form a closed loop.");
+    const n = [];
+    for (let d = 0; d < s.length; d++) {
+      const g = s[d], a = s[(d + 1) % s.length], u = i.get(g.edgeId), c = i.get(a.edgeId);
+      if (!u || !c || u.floorId !== r || c.floorId !== r)
+        throw new Error("A space boundary references a missing edge or another floor.");
+      if ((g.reversed ? u.startId : u.endId) !== (a.reversed ? c.endId : c.startId))
+        throw new Error("Space boundary edges must share their junctions in order.");
+      n.push(T(e, u)[g.reversed ? 1 : 0]);
+    }
+    return z(n);
+  });
+}
+function ce(e, t, r) {
+  const [i, s] = T(e, t), n = v(i, s), d = r.filter((l) => l.t > w / n && l.t < 1 - w / n).sort((l, o) => l.t - o.t), g = d.filter((l, o) => o === 0 || l.id !== d[o - 1].id);
+  if (!g.length) return;
+  const a = [{ t: 0, id: t.startId }, ...g, { t: 1, id: t.endId }], u = e.objects.filter((l) => l.barrierId === t.id);
+  for (const l of g)
+    for (const o of u)
+      if (Math.abs((o.offset ?? 0) - l.t * n) < o.width / 2 - w)
+        throw new Error("A junction cannot split an opening.");
+  const c = "kind" in t, f = a.slice(1).map((l, o) => {
+    const m = a[o];
+    if ((l.t - m.t) * n < (c ? pe : K) - w)
+      throw new Error(
+        `That crossing would leave a boundary segment too short. "${"name" in t ? t.name : t.id}" would be ${((l.t - m.t) * n).toFixed(4)} m long.`
+      );
+    return { ...t, id: o === 0 ? t.id : F(), startId: m.id, endId: l.id };
+  });
+  for (const l of u) {
+    const o = (l.offset ?? 0) / n, m = a.slice(1).findIndex((h) => o <= h.t + w);
+    l.barrierId = f[m].id, l.offset = (l.offset ?? 0) - a[m].t * n;
+  }
+  ae(
+    e,
+    t.id,
+    f.map((l) => ({ edgeId: l.id }))
+  ), Object.assign(t, f[0]), c ? e.barriers.push(...f.slice(1)) : (e.virtualBoundaries ?? (e.virtualBoundaries = [])).push(...f.slice(1));
+}
+function G(e, t) {
+  const r = E(e).filter((o) => o.floorId === t), i = e.junctions.filter((o) => o.floorId === t), s = /* @__PURE__ */ new Map(), n = [];
+  for (const o of i) {
+    const m = n.find((h) => v(h.position, o.position) <= w);
+    m ? s.set(o.id, m.id) : n.push(o);
+  }
+  for (const o of r)
+    o.startId = s.get(o.startId) ?? o.startId, o.endId = s.get(o.endId) ?? o.endId;
+  e.junctions = e.junctions.filter((o) => !s.has(o.id));
+  const d = new Map(e.junctions.map((o) => [o.id, o.position])), g = r.map((o) => ({
+    points: [d.get(o.startId), d.get(o.endId)],
+    box: D([d.get(o.startId), d.get(o.endId)])
+  })), a = /* @__PURE__ */ new Map(), u = (o, m) => {
+    const [h, I] = T(e, o), p = L(m, h, I);
+    let y = e.junctions.find((x) => x.floorId === t && v(x.position, m) <= w);
+    y || (y = { id: F(), floorId: t, position: m }, e.junctions.push(y));
+    const b = a.get(o.id) ?? [];
+    b.push({ t: p.t, id: y.id }), a.set(o.id, b);
+  };
+  for (let o = 0; o < r.length; o++)
+    for (let m = o + 1; m < r.length; m++) {
+      if (!fe(g[o].box, g[m].box)) continue;
+      const h = r[o], I = r[m], [p, y] = g[o].points, [b, x] = g[m].points, A = y[0] - p[0], k = y[1] - p[1], $ = x[0] - b[0], S = x[1] - b[1], O = A * S - k * $;
+      if (!(h.startId === I.startId || h.startId === I.endId || h.endId === I.startId || h.endId === I.endId) && Math.abs(O) > 1e-12 * Math.hypot(A, k) * Math.hypot($, S)) {
+        const M = ((b[0] - p[0]) * S - (b[1] - p[1]) * $) / O, Z = ((b[0] - p[0]) * k - (b[1] - p[1]) * A) / O;
+        if (M >= -w / Math.hypot(A, k) && M <= 1 + w / Math.hypot(A, k) && Z >= -w / Math.hypot($, S) && Z <= 1 + w / Math.hypot($, S)) {
+          const ee = [p[0] + Math.max(0, Math.min(1, M)) * A, p[1] + Math.max(0, Math.min(1, M)) * k];
+          u(h, ee), u(I, ee);
+        }
+      } else {
+        for (const M of [p, y])
+          L(M, b, x).distance <= w && (u(h, M), u(I, M));
+        for (const M of [b, x])
+          L(M, p, y).distance <= w && (u(h, M), u(I, M));
+      }
+    }
+  for (const o of r) ce(e, o, a.get(o.id) ?? []);
+  const c = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set();
+  for (const o of E(e).filter((m) => m.floorId === t)) {
+    const m = [o.startId, o.endId].sort().join("|"), h = c.get(m);
+    if (!h) {
+      c.set(m, o);
+      continue;
+    }
+    const I = o.startId !== h.startId;
+    ae(e, o.id, [{ edgeId: h.id, reversed: I }]);
+    for (const p of e.objects.filter((y) => y.barrierId === o.id))
+      p.barrierId = h.id, I && (p.offset = v(...T(e, h)) - (p.offset ?? 0), p.kind === "door" && (p.doorHinge = p.doorHinge === "right" ? "left" : "right", p.doorSwing = p.doorSwing === -1 ? 1 : -1));
+    f.add(o.id);
+  }
+  e.barriers = e.barriers.filter((o) => !f.has(o.id)), e.virtualBoundaries && (e.virtualBoundaries = e.virtualBoundaries.filter((o) => !f.has(o.id)));
+  const l = new Set(E(e).flatMap((o) => [o.startId, o.endId]));
+  e.junctions = e.junctions.filter((o) => !s.has(o.id) || l.has(o.id));
+}
+function P(e, t) {
+  const r = E(e).filter((o) => o.floorId === t), i = /* @__PURE__ */ new Map();
+  for (const o of r)
+    for (const [m, h] of [
+      [o.startId, o.endId],
+      [o.endId, o.startId]
+    ]) {
+      const I = i.get(m) ?? [];
+      I.push({ edge: o, to: h }), i.set(m, I);
+    }
+  const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Set();
+  let g = 0;
+  const a = (o, m) => {
+    s.set(o, ++g), n.set(o, g);
+    for (const { edge: h, to: I } of i.get(o) ?? [])
+      h.id !== m && (s.has(I) ? n.set(o, Math.min(n.get(o), s.get(I))) : (a(I, h.id), n.set(o, Math.min(n.get(o), n.get(I))), n.get(I) > s.get(o) && d.add(h.id)));
+  };
+  for (const o of i.keys()) s.has(o) || a(o);
+  const u = new Map(e.junctions.map((o) => [o.id, o.position]));
+  for (const [o, m] of i) {
+    const h = u.get(o);
+    i.set(
+      o,
+      m.filter((I) => !d.has(I.edge.id)).sort((I, p) => {
+        const y = u.get(I.to), b = u.get(p.to);
+        return Math.atan2(y[1] - h[1], y[0] - h[0]) - Math.atan2(b[1] - h[1], b[0] - h[0]);
+      })
+    );
+  }
+  const c = /* @__PURE__ */ new Set(), f = [];
+  for (const o of r.filter((m) => !d.has(m.id)))
+    for (const m of [!1, !0]) {
+      let h = { edgeId: o.id, reversed: m }, I = o;
+      const p = `${o.id}:${m}`, y = [], b = [];
+      if (!c.has(p)) {
+        for (let x = 0; x <= r.length * 2; x++) {
+          const A = `${h.edgeId}:${!!h.reversed}`;
+          if (c.has(A)) break;
+          c.add(A), y.push(h);
+          const k = h.reversed ? I.endId : I.startId, $ = h.reversed ? I.startId : I.endId;
+          b.push(u.get(k));
+          const S = i.get($), O = S.findIndex((M) => M.edge.id === I.id);
+          if (I = S[(O + S.length - 1) % S.length].edge, h = { edgeId: I.id, reversed: I.endId === $ }, `${h.edgeId}:${!!h.reversed}` === p) break;
+        }
+        _(b) >= re && f.push({ loop: y, ring: z(b) });
+      }
+    }
+  const l = f.map(
+    (o, m) => {
+      var h;
+      return (h = f.map((I, p) => ({ j: p, candidate: I })).filter(
+        ({ candidate: I, j: p }) => p !== m && C(I.ring) > C(o.ring) + w && o.ring.every((y) => H(y, I.ring)) && !o.loop.some((y) => I.loop.some((b) => b.edgeId === y.edgeId))
+      ).sort((I, p) => C(I.candidate.ring) - C(p.candidate.ring))[0]) == null ? void 0 : h.j;
+    }
+  );
+  return f.map((o, m) => {
+    const h = f.filter((I, p) => l[p] === m);
+    return {
+      loops: [o.loop, ...h.map((I) => se(I.loop))],
+      rings: [o.ring, ...h.map((I) => z([...B(I.ring)].reverse()))]
+    };
+  });
+}
+function we(e, t) {
+  const r = new Map(e.junctions.map((s) => [s.id, s.position])), i = e.barriers.filter((s) => s.floorId === t).map((s) => ({
+    points: [r.get(s.startId), r.get(s.endId)],
+    thickness: s.thickness
+  }));
+  for (let s = 0; s < i.length; s++) {
+    let n = !0;
+    for (; n; ) {
+      n = !1;
+      for (let d = s + 1; d < i.length; d++) {
+        const g = i[s], a = i[d];
+        if (g.thickness !== a.thickness) continue;
+        const [u, c] = g.points, [f, l] = a.points, o = v(u, c), m = v(f, l);
+        if (Math.abs((c[0] - u[0]) * (l[1] - f[1]) - (c[1] - u[1]) * (l[0] - f[0])) > w * o * m) continue;
+        const h = [
+          [u, f, c, l],
+          [u, l, c, f],
+          [c, f, u, l],
+          [c, l, u, f]
+        ].find(([I, p]) => v(I, p) <= w);
+        if (h) {
+          g.points = [h[2], h[3]], i.splice(d, 1), n = !0;
+          break;
+        }
+      }
+    }
+  }
+  return i.map(({ points: [s, n], thickness: d }) => {
+    (s[0] > n[0] || s[0] === n[0] && s[1] > n[1]) && ([s, n] = [n, s]);
+    const g = v(s, n);
+    return de([
+      me(
+        [(s[0] + n[0]) / 2, (s[1] + n[1]) / 2],
+        g + d,
+        d,
+        Math.atan2(n[1] - s[1], n[0] - s[0]) * 180 / Math.PI
+      )
+    ]);
+  });
+}
+function ye(e) {
+  const t = [];
+  for (const r of B(e)) (!t.length || v(t.at(-1), r) >= w) && t.push(r);
+  return t.length > 1 && v(t[0], t.at(-1)) < w && t.pop(), z(t);
+}
+const D = (e) => {
+  let t = 1 / 0, r = 1 / 0, i = -1 / 0, s = -1 / 0;
+  for (const [n, d] of e)
+    t = Math.min(t, n), r = Math.min(r, d), i = Math.max(i, n), s = Math.max(s, d);
+  return { minX: t, minY: r, maxX: i, maxY: s };
+}, fe = (e, t) => e.minX <= t.maxX + w && e.maxX + w >= t.minX && e.minY <= t.maxY + w && e.maxY + w >= t.minY;
+function q(e) {
+  const t = /* @__PURE__ */ new Map();
+  return (r, i, s = !1) => {
+    let n = t.get(r);
+    n || (n = we(e, r).map((a) => ({ rings: a, box: D(a[0]) })), t.set(r, n));
+    const d = D(i[0]), g = n.filter((a) => fe(a.box, d)).map((a) => a.rings);
+    return be(i, g, s);
+  };
+}
+function be(e, t, r = !1) {
+  const i = t.length ? W(e, ...t) : [de(e)], s = i.filter((n) => j(n) >= oe);
+  if (!s.length && r) return [];
+  if (!s.length)
+    throw new Error(
+      `A space needs at least ${oe} m² of usable area. Largest region after subtracting walls: ${Math.max(0, ...i.map((n) => j(n))).toFixed(3)} m².`
+    );
+  if (s.length !== 1)
+    throw new Error(
+      `The wall would leave ${s.length} disconnected usable regions (${s.map((n) => j(n).toFixed(2)).join(", ")} m²). Extend it to a boundary to divide the space.`
+    );
+  return s[0].map(ye);
+}
+function Q(e, t) {
+  var r;
+  return ((r = t.geometry) == null ? void 0 : r.mode) !== "boundaries" ? U(t) : q(e)(t.floorId, N(e, t.geometry.loops, t.floorId));
+}
+function Y(e, t) {
+  e.rings = t, e.position = ne(t[0]), e.rotation = 0;
+  const r = t[0].map((s) => s[0]), i = t[0].map((s) => s[1]);
+  e.width = Math.max(...r) - Math.min(...r), e.depth = Math.max(...i) - Math.min(...i);
+}
+function ve(e, t, r) {
+  if (!V(t.kind)) throw new Error("Only a drawn area can use shared boundaries.");
+  t.geometry = { mode: "boundaries", loops: structuredClone(r.loops) }, Y(t, Q(e, t));
+}
+function ke(e, t, r) {
+  return P(e, t).filter((i) => H(r, i.rings[0]) && !i.rings.slice(1).some((s) => H(r, s))).sort((i, s) => j(i.rings) - j(s.rings))[0] ?? null;
+}
+function J(e, t, r) {
+  const i = e.junctions.find((n) => n.floorId === t && v(n.position, r) <= w);
+  if (i) return i.id;
+  const s = F();
+  return e.junctions.push({ id: s, floorId: t, position: r }), s;
+}
+function X(e, t, r, i) {
+  if (v(r, i) < K) throw new Error("A space boundary is too short.");
+  const s = J(e, t, r), n = J(e, t, i), d = E(e).find(
+    (a) => a.floorId === t && (a.startId === s && a.endId === n || a.startId === n && a.endId === s)
+  );
+  if (d) return d.id;
+  const g = F();
+  return (e.virtualBoundaries ?? (e.virtualBoundaries = [])).push({ id: g, floorId: t, startId: s, endId: n }), g;
+}
+function $e(e, t, r, i) {
+  const s = v(r, i);
+  if (s < K) throw new Error("A space boundary is too short.");
+  const n = (d) => Math.abs((i[0] - r[0]) * (d[1] - r[1]) - (i[1] - r[1]) * (d[0] - r[0])) / s <= w;
+  for (const d of [...e.barriers].filter((g) => g.floorId === t)) {
+    const [g, a] = T(e, d);
+    if (!n(g) || !n(a)) continue;
+    const u = [r, i].flatMap((c) => {
+      const f = L(c, g, a);
+      return f.distance <= w && f.t > 0 && f.t < 1 ? [{ t: f.t, id: J(e, t, f.point) }] : [];
+    });
+    ce(e, d, u);
+  }
+  for (const d of [...e.barriers].filter((g) => g.floorId === t))
+    T(e, d).every((g) => L(g, r, i).distance <= w) && ((e.virtualBoundaries ?? (e.virtualBoundaries = [])).push({ id: d.id, floorId: t, startId: d.startId, endId: d.endId }), ge(e, d.id));
+  return X(e, t, r, i);
+}
+function Re(e, t, r = "outline") {
+  var n;
+  const i = e.objects.find((d) => d.id === t);
+  if (!i || !V(i.kind)) throw new Error("Select an area to connect to boundaries.");
+  if (r === "walls") {
+    G(e, i.floorId);
+    const d = U(i), g = j(d), a = P(e, i.floorId).map((c) => ({
+      region: c,
+      overlap: g - ie(W(d, c.rings))
+    })).filter((c) => c.overlap > w).sort((c, f) => f.overlap - c.overlap);
+    if (a.length > 1 && Math.abs(a[0].overlap - a[1].overlap) < w)
+      throw new Error("More than one region matches this outline. Use Space from walls inside the intended region.");
+    const u = (n = a[0]) == null ? void 0 : n.region;
+    if (!u) throw new Error("No closed wall boundary surrounds this space.");
+    ve(e, i, u);
+    return;
+  }
+  const s = U(i).map((d, g) => {
+    let a = B(d);
+    return _(a) > 0 != (g === 0) && (a = [...a].reverse()), a.map((u, c) => {
+      const f = a[(c + 1) % a.length], l = X(e, i.floorId, u, f), o = E(e).find((m) => m.id === l);
+      return { edgeId: l, reversed: v(T(e, o)[0], u) > w };
+    });
+  });
+  i.geometry = { mode: "boundaries", loops: s }, G(e, i.floorId), Y(i, Q(e, i));
+}
+function Te(e, t) {
+  const r = e.objects.find((i) => i.id === t);
+  r && (r.geometry = { mode: "independent" });
+}
+function _e(e, t, r) {
+  var n;
+  if (((n = t.geometry) == null ? void 0 : n.mode) !== "boundaries") throw new Error("Select a space with shared boundaries.");
+  let i = B(r);
+  _(i) > 0 && (i = [...i].reverse());
+  const s = i.map((d, g) => {
+    const a = X(e, t.floorId, d, i[(g + 1) % i.length]), u = E(e).find((c) => c.id === a);
+    return { edgeId: a, reversed: v(T(e, u)[0], d) > w };
+  });
+  t.geometry.loops.push(s);
+}
+function Ce(e, t, r, i, s = !0) {
+  var f;
+  if (((f = t.geometry) == null ? void 0 : f.mode) !== "boundaries") throw new Error("This space has no shared boundaries.");
+  const n = v(r, i);
+  if (n < w) throw new Error("Draw a line across the space.");
+  const d = (i[0] - r[0]) / n, g = (i[1] - r[1]) / n, a = [];
+  for (const l of N(e, t.geometry.loops, t.floorId)) {
+    const o = B(l);
+    for (let m = 0; m < o.length; m++) {
+      const h = o[m], I = o[(m + 1) % o.length], p = I[0] - h[0], y = I[1] - h[1], b = d * y - g * p;
+      if (Math.abs(b) < 1e-12) continue;
+      const x = ((h[0] - r[0]) * g - (h[1] - r[1]) * d) / b;
+      x >= -w && x <= 1 + w && a.push(((h[0] - r[0]) * y - (h[1] - r[1]) * p) / b);
+    }
+  }
+  a.sort((l, o) => l - o);
+  const u = a.filter((l, o) => o === 0 || l - a[o - 1] > w);
+  for (let l = 0; l + 1 < u.length; l += 2) {
+    const o = [r[0] + u[l] * d, r[1] + u[l] * g], m = [r[0] + u[l + 1] * d, r[1] + u[l + 1] * g];
+    if (s) {
+      const h = Ie(e, o, m, t.floorId, "wall");
+      h && (h.name = "Partition", h.thickness = 0.18);
+    } else X(e, t.floorId, o, m);
+  }
+  G(e, t.floorId);
+  const c = le(e);
+  if (!c.length) throw new Error("The cut must divide the space into usable regions.");
+  return c[0];
+}
+function ze(e, t, r) {
+  var u, c;
+  if (((u = t.geometry) == null ? void 0 : u.mode) !== "boundaries" || ((c = r.geometry) == null ? void 0 : c.mode) !== "boundaries")
+    throw new Error("Connect both spaces to shared boundaries before merging their boundaries.");
+  const i = t.geometry.loops.flat(), s = r.geometry.loops.flat(), n = new Set(
+    i.filter((f) => s.some((l) => l.edgeId === f.edgeId && !!l.reversed != !!f.reversed)).map((f) => f.edgeId)
+  );
+  if (!n.size) return !1;
+  if (e.barriers.some((f) => n.has(f.id))) throw new Error("Remove the dividing wall before merging these spaces.");
+  const d = new Map(E(e).map((f) => [f.id, f])), g = [...i, ...s].filter((f) => !n.has(f.edgeId)), a = [];
+  for (; g.length; ) {
+    const f = [g.shift()], l = d.get(f[0].edgeId), o = f[0].reversed ? l.endId : l.startId;
+    let m = f[0].reversed ? l.startId : l.endId;
+    for (; m !== o; ) {
+      const h = g.findIndex((y) => {
+        const b = d.get(y.edgeId);
+        return (y.reversed ? b.endId : b.startId) === m;
+      });
+      if (h < 0) throw new Error("The merged space boundary is not closed.");
+      const I = g.splice(h, 1)[0], p = d.get(I.edgeId);
+      f.push(I), m = I.reversed ? p.startId : p.endId;
+    }
+    a.push(f);
+  }
+  return a.sort(
+    (f, l) => _(B(N(e, [l], t.floorId)[0])) - _(B(N(e, [f], t.floorId)[0]))
+  ), t.geometry = { mode: "boundaries", loops: a }, e.virtualBoundaries = (e.virtualBoundaries ?? []).filter(
+    (f) => !n.has(f.id) || e.objects.some(
+      (l) => {
+        var o;
+        return l.id !== r.id && ((o = l.geometry) == null ? void 0 : o.mode) === "boundaries" && l.geometry.loops.some((m) => m.some((h) => h.edgeId === f.id));
+      }
+    )
+  ), Y(t, Q(e, t)), !0;
+}
+function Me(e, t) {
+  e.objects.some(
+    (r) => {
+      var i;
+      return ((i = r.geometry) == null ? void 0 : i.mode) === "boundaries" && r.geometry.loops.some((s) => s.some((n) => n.edgeId === t.id));
+    }
+  ) && ((e.virtualBoundaries ?? []).some((r) => r.id === t.id) || (e.virtualBoundaries ?? (e.virtualBoundaries = [])).push({ id: t.id, floorId: t.floorId, startId: t.startId, endId: t.endId }));
+}
+function le(e, t) {
+  var n;
+  const r = [], i = /* @__PURE__ */ new Map(), s = q(e);
+  for (const d of [...e.objects]) {
+    if (((n = d.geometry) == null ? void 0 : n.mode) !== "boundaries") continue;
+    const g = N(e, d.geometry.loops, d.floorId);
+    if (t && !t.has(d.floorId)) {
+      Y(d, s(d.floorId, g));
+      continue;
+    }
+    i.has(d.floorId) || i.set(d.floorId, P(e, d.floorId));
+    const a = i.get(d.floorId).filter((c) => ie(W(c.rings, g)) < w);
+    if (!a.length) throw new Error("The space boundaries no longer form a closed region.");
+    a.sort((c, f) => j(f.rings) - j(c.rings));
+    const u = a.map((c) => ({ region: c, rings: s(d.floorId, c.rings, a.length > 1) })).filter((c) => c.rings.length).sort((c, f) => j(f.rings) - j(c.rings));
+    if (!u.length) throw new Error("The walls would remove all usable area from this space.");
+    for (let c = 0; c < u.length; c++) {
+      const f = c === 0 ? d : { ...structuredClone(d), id: F(), name: `${d.name} ${c + 1}`, feedId: void 0 };
+      if (f.geometry = { mode: "boundaries", loops: structuredClone(u[c].region.loops) }, Y(f, u[c].rings), c > 0) {
+        e.objects.push(f), r.push(f.id);
+        for (const l of e.zones ?? []) l.spaceIds.includes(d.id) && l.spaceIds.push(f.id);
+      }
+    }
+  }
+  return r;
+}
+function Ne(e, t) {
+  for (const a of ["barriers", "junctions", "objects", "virtualBoundaries", "zones"]) {
+    const u = t[a];
+    u && (Object.isFrozen(u) || u.some((c) => Object.isFrozen(c))) && Object.assign(t, { [a]: structuredClone(u) });
+  }
+  const r = E(t), i = new Set(r.map((a) => a.id));
+  for (const a of E(e))
+    if (!i.has(a.id) && (Me(t, a), (t.virtualBoundaries ?? []).some((u) => u.id === a.id))) {
+      for (const u of [a.startId, a.endId])
+        if (!t.junctions.some((c) => c.id === u)) {
+          const c = e.junctions.find((f) => f.id === u);
+          c && t.junctions.push(structuredClone(c));
+        }
+    }
+  const s = (a, u) => JSON.stringify([
+    E(a).filter((c) => c.floorId === u).map((c) => [c.id, c.startId, c.endId]),
+    a.junctions.filter((c) => c.floorId === u).map((c) => [c.id, c.position])
+  ]), n = new Set(E(t).map((a) => a.floorId));
+  for (const a of n) s(e, a) !== s(t, a) && G(t, a);
+  const d = (a, u) => JSON.stringify(
+    E(a).filter((c) => c.floorId === u).map((c) => [c.id, c.startId, c.endId])
+  ), g = new Set([...n].filter((a) => d(e, a) !== d(t, a)));
+  le(t, g);
+}
+function Oe(e) {
+  const t = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map(), i = q(e), s = (n) => n.flat().map((d) => `${d.edgeId}:${!!d.reversed}`).sort().join("|");
+  for (const n of e.objects) {
+    if (n.geometry === void 0) continue;
+    if (!n.geometry || !["independent", "boundaries"].includes(n.geometry.mode))
+      throw new Error("Unknown space geometry mode.");
+    if (n.geometry.mode === "independent") continue;
+    if (!V(n.kind) || !Array.isArray(n.geometry.loops) || !n.geometry.loops.length || n.geometry.loops.some(
+      (f) => !Array.isArray(f) || f.some(
+        (l) => !l || typeof l.edgeId != "string" || l.reversed !== void 0 && typeof l.reversed != "boolean"
+      )
+    ))
+      throw new Error("Malformed space boundary loops.");
+    const d = N(e, n.geometry.loops, n.floorId), g = he(d, w, re);
+    if (g) throw new Error(g);
+    if (_(B(d[0])) <= 0 || d.slice(1).some((f) => _(B(f)) >= 0))
+      throw new Error("Space boundary loops must keep the space on their left.");
+    if (r.has(n.floorId) || r.set(n.floorId, new Set(P(e, n.floorId).map((f) => s(f.loops)))), !r.get(n.floorId).has(s(n.geometry.loops)))
+      throw new Error("A connected space must follow one face of the boundary network.");
+    for (const f of n.geometry.loops)
+      for (const l of f) {
+        const o = `${l.edgeId}:${!!l.reversed}`;
+        if (t.has(o)) throw new Error("Two spaces cannot occupy the same side of a shared boundary.");
+        t.add(o);
+      }
+    const a = i(n.floorId, d);
+    if (!n.rings || a.length !== n.rings.length || a.some(
+      (f, l) => f.length !== n.rings[l].length || f.some((o, m) => v(o, n.rings[l][m]) > w)
+    ))
+      throw new Error("The space footprint is stale. Update it through a geometry transaction.");
+    const u = a[0].map((f) => f[0]), c = a[0].map((f) => f[1]);
+    if (v(n.position, ne(a[0])) > w || Math.abs(n.width - (Math.max(...u) - Math.min(...u))) > w || Math.abs(n.depth - (Math.max(...c) - Math.min(...c))) > w || n.rotation !== 0)
+      throw new Error("A boundary-driven space has stale calculated dimensions.");
+  }
+}
+export {
+  _e as addBoundaryHole,
+  X as addVirtualBoundary,
+  ve as bindSpaceToRegion,
+  E as boundaryEdges,
+  ke as boundaryRegionAt,
+  P as boundaryRegions,
+  N as boundaryRings,
+  Re as connectSpace,
+  Q as derivedSpaceRings,
+  Te as disconnectSpace,
+  $e as drawVirtualBoundary,
+  Be as followsBoundaries,
+  ze as mergeBoundaryGeometry,
+  G as normalizeBoundaries,
+  Me as preserveBoundary,
+  le as refreshBoundarySpaces,
+  ae as replaceBoundaryUses,
+  Ce as splitBoundarySpace,
+  Ne as synchronizeGeometry,
+  Oe as validateSpaceBoundaries
+};
+//# sourceMappingURL=boundaries.js.map