@dynamix-layout/core 1.1.1 → 2.0.0

package/dist/index.js

@@ -0,0 +1,1338 @@
+/*! @dynamix-layout/core | MIT License */ function tt() {
+  return typeof process > "u" || // Read at runtime by consumers' bundlers, not a build input of this repo.
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  process.env.NODE_ENV !== "production";
+}
+const Ut = (t) => {
+  tt() && console.warn(`[dynamix-layout] ${t.message}`);
+}, w = (t) => t.type === "row";
+function E(t) {
+  const e = [], n = (i) => {
+    w(i) ? i.children.forEach(n) : e.push(i);
+  };
+  return t.children.forEach(n), e;
+}
+function Wt(t) {
+  return E(t).flatMap(
+    (e) => e.children.map((n) => n.id)
+  );
+}
+function xt(t) {
+  const e = [], n = (i) => {
+    e.push(i.id), w(i) && i.children.forEach(n);
+  };
+  return n(t), e;
+}
+function T(t, e) {
+  return E(t).find((n) => n.id === e);
+}
+function S(t, e) {
+  return E(t).find(
+    (n) => n.children.some((i) => i.id === e)
+  );
+}
+function et(t, e) {
+  for (const n of t.children) {
+    if (n.id === e) return t;
+    if (w(n)) {
+      const i = et(n, e);
+      if (i) return i;
+    }
+  }
+}
+const jt = 6;
+function It(t, e, n, i) {
+  if (n.type === "root") return ct(e.container, n.position);
+  if (n.type === "tabset") {
+    const f = e.tabsets.get(n.tabsetId);
+    return f ? n.position !== "center" ? ct(f, n.position) : T(t.root, n.tabsetId)?.isFolded ? f : {
+      x: f.x + f.width * 0.1,
+      y: f.y + f.height * 0.1,
+      width: f.width * 0.8,
+      height: f.height * 0.8
+    } : null;
+  }
+  const o = S(t.root, n.tabId), r = o && i?.tabBars.get(o.id)?.tabs, a = r?.findIndex((f) => f.id === n.tabId) ?? -1;
+  if (!r || a < 0) return null;
+  const d = r.length > 1 ? Math.max(
+    2,
+    r[1].rect.x - (r[0].rect.x + r[0].rect.width)
+  ) : jt, { rect: s } = r[a];
+  return {
+    x: n.position === "before" ? s.x - d + 1 : s.x + s.width + 1,
+    y: s.y,
+    width: Math.max(2, d - 2),
+    height: s.height
+  };
+}
+function ct(t, e) {
+  const { x: n, y: i, width: o, height: r } = t;
+  switch (e) {
+    case "left":
+      return { x: n, y: i, width: o / 2, height: r };
+    case "right":
+      return { x: n + o / 2, y: i, width: o / 2, height: r };
+    case "top":
+      return { x: n, y: i, width: o, height: r / 2 };
+    case "bottom":
+      return { x: n, y: i + r / 2, width: o, height: r / 2 };
+  }
+}
+const Kt = (t, e) => t.length === e.length && t.every((n, i) => n === e[i]);
+function F(t, e) {
+  return Kt(t.children, e) ? t : { ...t, children: e };
+}
+function O(t, e, n) {
+  if (t.id === e) {
+    const o = n(t);
+    if (Array.isArray(o) || !w(o))
+      throw new Error("The root can only be replaced by a row.");
+    return o;
+  }
+  const i = (o) => {
+    const r = [];
+    for (const a of o.children)
+      if (a.id === e) {
+        const d = n(a);
+        Array.isArray(d) ? r.push(...d) : r.push(d);
+      } else
+        r.push(w(a) ? i(a) : a);
+    return F(o, r);
+  };
+  return i(t);
+}
+const $ = 100, Tt = (t) => Number.isFinite(t) && t >= 0 ? t : $;
+function Gt(t) {
+  if (t.children.length === 0) return null;
+  const e = Tt(t.weight), n = t.children.some(
+    (i) => i.id === t.activeTabId
+  );
+  return e === t.weight && n ? t : {
+    ...t,
+    weight: e,
+    activeTabId: n ? t.activeTabId : t.children[0].id
+  };
+}
+function zt(t) {
+  const e = [];
+  for (const o of t.children) {
+    if (!w(o)) {
+      const a = Gt(o);
+      a && e.push(a);
+      continue;
+    }
+    let r = zt(o);
+    w(r) && r.children.length === 1 && (r = r.children[0]), !(w(r) && r.children.length === 0) && (w(r) && r.direction === t.direction ? e.push(...r.children) : e.push(r));
+  }
+  const n = Tt(t.weight), i = F(t, e);
+  return n === t.weight ? i : { ...i, weight: n };
+}
+function V(t) {
+  let e = zt(t);
+  for (; e.children.length === 1 && w(e.children[0]); ) {
+    const i = e.children[0];
+    e = {
+      ...e,
+      weight: i.weight,
+      direction: i.direction,
+      children: i.children
+    };
+  }
+  return (e.children.length <= 1 || e.direction === "horizontal") && (e.direction !== "horizontal" || e.weight !== $) && (e = { ...e, direction: "horizontal", weight: $ }), e;
+}
+const Ht = (t) => t === "horizontal" ? "vertical" : "horizontal";
+function P(t, e) {
+  return {
+    type: "tabset",
+    id: e("tabset", t),
+    weight: $,
+    activeTabId: t,
+    isFolded: !1,
+    children: [{ type: "tab", id: t }]
+  };
+}
+function Jt(t, e, n = "root") {
+  const i = (o, r, a) => {
+    const d = o.length <= 2 ? o.map((s) => P(s, e)) : [
+      P(o[0], e),
+      i(o.slice(1), Ht(r), e("row"))
+    ];
+    return { type: "row", id: a, weight: $, direction: r, children: d };
+  };
+  return i(t, "horizontal", n);
+}
+const St = (t) => t === "horizontal" ? "vertical" : "horizontal", q = (t) => t === "top" || t === "left", vt = (t, e) => (t === "left" || t === "right") == (e === "horizontal");
+function j(t, e, n, i, o) {
+  return O(t, e, (r) => {
+    const a = r, d = [...a.children];
+    return d.splice(i, 0, ...n), { ...a, children: d, activeTabId: o, isFolded: !1 };
+  });
+}
+function At(t, e, n, i, o) {
+  const r = et(t, e), a = T(t, e);
+  if (!r || !a) return t;
+  if (vt(i, r.direction)) {
+    const f = r.children.indexOf(a) + (q(i) ? 0 : 1), p = [...r.children];
+    return p.splice(f, 0, n), O(
+      t,
+      r.id,
+      () => F(r, p)
+    );
+  }
+  const d = {
+    ...a,
+    weight: $,
+    isFolded: !1
+  }, s = {
+    type: "row",
+    id: o("row"),
+    weight: a.weight,
+    direction: St(r.direction),
+    children: q(i) ? [n, d] : [d, n]
+  };
+  return O(t, e, () => s);
+}
+function Dt(t, e, n, i) {
+  const o = q(n);
+  if (t.children.length === 0) return F(t, [e]);
+  if (vt(n, t.direction))
+    return F(
+      t,
+      o ? [e, ...t.children] : [...t.children, e]
+    );
+  const r = t.children.length === 1 ? t.children[0] : {
+    type: "row",
+    id: i("row"),
+    weight: t.weight,
+    direction: t.direction,
+    children: t.children
+  };
+  return {
+    ...t,
+    weight: $,
+    direction: St(t.direction),
+    children: o ? [e, r] : [r, e]
+  };
+}
+function it(t, e) {
+  const n = S(t, e);
+  if (!n) return t;
+  const i = n.children.filter((r) => r.id !== e), o = O(
+    t,
+    n.id,
+    () => i.length === 0 ? [] : {
+      ...n,
+      children: i,
+      activeTabId: n.activeTabId === e ? i[0].id : n.activeTabId
+    }
+  );
+  return V(o);
+}
+function Yt(t, e) {
+  return V(O(t, e, () => []));
+}
+const dt = (t, e) => t.foldOrder.indexOf(e) + 1;
+function Ot(t, e, n) {
+  let i = null;
+  for (const o of e)
+    o.id === n || w(o) || !o.isFolded || (!i || dt(t, o.id) > dt(t, i.id)) && (i = o);
+  return e.map(
+    (o) => o === i ? { ...i, isFolded: !1 } : o
+  );
+}
+const Et = (t) => !w(t) && t.isFolded;
+function kt(t) {
+  return E(t).length > 1;
+}
+function M(t) {
+  const e = (d) => {
+    let s = d.children;
+    return s.length > 0 && s.every(Et) && (s = Ot(t, s)), s = s.map((f) => w(f) ? e(f) : f.isFolded && s.length < 2 ? { ...f, isFolded: !1 } : f), F(d, s);
+  }, n = e(t.root), i = new Set(xt(n)), o = t.maximizedTabsetId && T(n, t.maximizedTabsetId) ? t.maximizedTabsetId : null, r = t.foldOrder.filter((d) => i.has(d)), a = t.lastActiveTabsetId && T(n, t.lastActiveTabsetId) ? t.lastActiveTabsetId : null;
+  return n === t.root && o === t.maximizedTabsetId && r.length === t.foldOrder.length && a === t.lastActiveTabsetId ? t : { root: n, maximizedTabsetId: o, foldOrder: r, lastActiveTabsetId: a };
+}
+function qt(t, e) {
+  return t.maximizedTabsetId === e || !T(t.root, e) || !kt(t.root) ? null : { ...t, maximizedTabsetId: e };
+}
+function Ft(t) {
+  return t.maximizedTabsetId ? { ...t, maximizedTabsetId: null } : null;
+}
+function Zt(t, e) {
+  const n = T(t.root, e), i = et(t.root, e);
+  if (!n || !i || n.isFolded || i.children.length < 2)
+    return null;
+  const o = [
+    ...t.foldOrder.filter((s) => s !== e),
+    e
+  ], r = { ...t, foldOrder: o, maximizedTabsetId: null };
+  let a = i.children.map(
+    (s) => s === n ? { ...n, isFolded: !0 } : s
+  );
+  a.every(Et) && (a = Ot(r, a, e));
+  const d = O(
+    t.root,
+    i.id,
+    () => F(i, a)
+  );
+  return M({ ...r, root: d });
+}
+function Xt(t, e) {
+  const n = T(t.root, e);
+  if (!n || !n.isFolded) return null;
+  const i = O(t.root, e, () => ({
+    ...n,
+    isFolded: !1
+  }));
+  return M({ ...t, root: i });
+}
+function Nt(t, e) {
+  return e.type === "tab" ? S(t, e.tabId) : T(t, e.tabsetId);
+}
+function nt(t, e, n) {
+  const i = Nt(t, e);
+  if (!i || E(t).length === 1 && (e.type === "tabset" || i.children.length === 1)) return !1;
+  switch (n.type) {
+    case "root":
+      return !0;
+    case "tab": {
+      const a = S(t, n.tabId);
+      return a ? e.type === "tab" ? e.tabId !== n.tabId : a !== i : !1;
+    }
+    case "tabset": {
+      const a = T(t, n.tabsetId);
+      return a ? e.type === "tabset" ? a !== i : a !== i ? !0 : i.children.length < 2 ? !1 : n.position !== "center" || i.children[i.children.length - 1].id !== e.tabId : !1;
+    }
+  }
+}
+function Z(t, e, n, i) {
+  if (!nt(t.root, e, n)) return null;
+  const o = Nt(t.root, e), r = e.type === "tab" ? [{ type: "tab", id: e.tabId }] : o.children, a = e.type === "tab" ? e.tabId : r[r.length - 1].id, d = () => e.type === "tab" ? P(e.tabId, i) : { ...o, isFolded: !1 };
+  let s = e.type === "tab" ? it(t.root, e.tabId) : Yt(t.root, o.id);
+  switch (n.type) {
+    case "tab": {
+      const f = S(s, n.tabId), p = f.children.findIndex((c) => c.id === n.tabId) + (n.position === "after" ? 1 : 0);
+      s = j(s, f.id, r, p, a);
+      break;
+    }
+    case "tabset": {
+      if (n.position === "center") {
+        const f = T(s, n.tabsetId);
+        s = j(
+          s,
+          f.id,
+          r,
+          f.children.length,
+          a
+        );
+      } else
+        s = At(
+          s,
+          n.tabsetId,
+          d(),
+          n.position,
+          i
+        );
+      break;
+    }
+    case "root":
+      s = Dt(s, d(), n.position, i);
+      break;
+  }
+  return s = V(s), M({
+    ...t,
+    root: s,
+    maximizedTabsetId: null,
+    lastActiveTabsetId: S(s, a)?.id ?? null
+  });
+}
+const Qt = ["left", "right", "top", "bottom"], H = (t, e) => e.x >= t.x && e.x <= t.x + t.width && e.y >= t.y && e.y <= t.y + t.height;
+function te(t, e, n = {}) {
+  const { length: i = 0.25, thickness: o = 8 } = n, { x: r, y: a, width: d, height: s } = t;
+  switch (e) {
+    case "left":
+      return {
+        x: r,
+        y: a + s * (1 - i) / 2,
+        width: o,
+        height: s * i
+      };
+    case "right":
+      return {
+        x: r + d - o,
+        y: a + s * (1 - i) / 2,
+        width: o,
+        height: s * i
+      };
+    case "top":
+      return {
+        x: r + d * (1 - i) / 2,
+        y: a,
+        width: d * i,
+        height: o
+      };
+    case "bottom":
+      return {
+        x: r + d * (1 - i) / 2,
+        y: a + s - o,
+        width: d * i,
+        height: o
+      };
+  }
+}
+function ee(t, e) {
+  const n = e.x - t.x, i = e.y - t.y;
+  return n < t.width / 3 ? "left" : n > 2 * t.width / 3 ? "right" : i < t.height / 3 ? "top" : i > 2 * t.height / 3 ? "bottom" : "center";
+}
+function ie(t, e) {
+  if (t.length === 0) return null;
+  const n = t[t.length - 1];
+  if (e.x > n.rect.x + n.rect.width)
+    return { type: "tab", tabId: n.id, position: "after" };
+  if (e.x < t[0].rect.x)
+    return { type: "tab", tabId: t[0].id, position: "before" };
+  let i = t[0], o = 1 / 0;
+  for (const a of t) {
+    const d = a.rect.x + a.rect.width / 2;
+    Math.abs(e.x - d) < o && (o = Math.abs(e.x - d), i = a);
+  }
+  const r = i.rect.x + i.rect.width / 2;
+  return {
+    type: "tab",
+    tabId: i.id,
+    position: e.x < r ? "before" : "after"
+  };
+}
+function $t(t, e, n, i, o, r) {
+  const a = (s) => s && nt(t.root, i, s) ? s : null;
+  for (const s of Qt)
+    if (H(te(e.container, s, r), n))
+      return a({ type: "root", position: s });
+  const d = E(t.root);
+  for (const s of d) {
+    const f = o?.tabBars.get(s.id);
+    if (!(!f || !H(f.rect, n)))
+      return f.isRotated || s.isFolded ? a({
+        type: "tabset",
+        tabsetId: s.id,
+        position: "center"
+      }) : a(ie(f.tabs, n));
+  }
+  for (const s of d) {
+    if (t.maximizedTabsetId && t.maximizedTabsetId !== s.id)
+      continue;
+    const f = e.tabsets.get(s.id);
+    if (!f || !H(f, n)) continue;
+    const p = s.isFolded ? "center" : ee(f, n);
+    return a({ type: "tabset", tabsetId: s.id, position: p });
+  }
+  return null;
+}
+function rt(t, e) {
+  const n = /* @__PURE__ */ new Map(), { width: i, height: o } = e.minPanelSize, r = (a, d) => {
+    let s;
+    if (w(a)) {
+      let f = 0, p = 0, c = 0, l = 0;
+      for (const u of a.children) {
+        const h = r(u, a.direction);
+        c += h.horizontalCount, l += h.verticalCount, a.direction === "horizontal" ? (f += h.width, p = Math.max(p, h.height)) : (p += h.height, f = Math.max(f, h.width));
+      }
+      const b = (a.children.length - 1) * e.splitterSize;
+      a.direction === "horizontal" ? f += b : p += b, s = { width: f, height: p, horizontalCount: c, verticalCount: l };
+    } else {
+      const f = d === "horizontal";
+      s = a.isFolded ? f ? {
+        width: e.foldedSize,
+        height: o,
+        horizontalCount: 0,
+        verticalCount: 0
+      } : {
+        width: i,
+        height: e.foldedSize,
+        horizontalCount: 0,
+        verticalCount: 0
+      } : {
+        width: i,
+        height: o,
+        horizontalCount: f ? 1 : 0,
+        verticalCount: f ? 0 : 1
+      };
+    }
+    return n.set(a.id, s), s;
+  };
+  return r(t, t.direction), n;
+}
+function ne(t, e) {
+  const n = (i, o) => i * o + Math.max(0, i - 1) * e.splitterSize;
+  return {
+    width: Math.max(
+      t.width,
+      n(t.horizontalCount, e.minPanelSize.width)
+    ),
+    height: Math.max(
+      t.height,
+      n(t.verticalCount, e.minPanelSize.height)
+    )
+  };
+}
+const ot = (t, e) => `${t}~${e}`, J = (t, e) => {
+  if (t.size !== e.size) return !1;
+  const n = e.entries();
+  for (const [i, o] of t) {
+    const [r, a] = n.next().value;
+    if (i !== r || o !== a) return !1;
+  }
+  return !0;
+}, lt = (t, e) => !!t && t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+function ft(t, e, n, i, o) {
+  const r = rt(t, n), a = ne(r.get(t.id), n), d = {
+    x: e.x,
+    y: e.y,
+    width: Math.max(e.width, a.width),
+    height: Math.max(e.height, a.height)
+  }, s = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), c = (u, h, g, m) => u.set(g, lt(h?.get(g), m) ? h.get(g) : m), l = (u, h) => {
+    c(s, o?.rows, u.id, h);
+    const g = u.direction === "horizontal", m = r.get(u.id), y = g ? h.width - m.width : h.height - m.height, x = y < 0;
+    let v = 0, A, C = 0;
+    for (const I of u.children)
+      !w(I) && I.isFolded || (v += I.weight, A = I.id, C++);
+    const N = v === 0, R = (I) => N ? 1 : I;
+    N && (v = C);
+    let _ = 0, B = 0, U = 0;
+    u.children.forEach((I, Vt) => {
+      const st = r.get(I.id), Bt = w(I) || !I.isFolded;
+      let G = 0;
+      if (!x && Bt && v > 0) {
+        B += R(I.weight);
+        const W = I.id === A ? y : Math.round(
+          y * B / v
+        );
+        G = W - U, U = W;
+      }
+      const z = g ? {
+        x: h.x + _,
+        y: h.y,
+        width: st.width + G,
+        height: h.height
+      } : {
+        x: h.x,
+        y: h.y + _,
+        width: h.width,
+        height: st.height + G
+      };
+      _ += (g ? z.width : z.height) + n.splitterSize, w(I) ? l(I, z) : c(f, o?.tabsets, I.id, z);
+      const at = u.children[Vt + 1];
+      if (at) {
+        const W = g ? {
+          x: z.x + z.width,
+          y: z.y,
+          width: n.splitterSize,
+          height: z.height
+        } : {
+          x: z.x,
+          y: z.y + z.height,
+          width: z.width,
+          height: n.splitterSize
+        };
+        c(
+          p,
+          o?.splitters,
+          ot(I.id, at.id),
+          W
+        );
+      }
+    });
+  };
+  l(t, d), i && f.has(i) && c(f, o?.tabsets, i, d);
+  const b = lt(o?.container, d) ? o.container : d;
+  return o && b === o.container && J(s, o.rows) && J(f, o.tabsets) && J(p, o.splitters) ? o : { container: b, rows: s, tabsets: f, splitters: p };
+}
+function Mt(t, e) {
+  const n = (i) => {
+    for (let o = 0; o < i.children.length; o++) {
+      const r = i.children[o], a = i.children[o + 1];
+      if (a && ot(r.id, a.id) === e)
+        return { row: i, before: r, after: a };
+      if (w(r)) {
+        const d = n(r);
+        if (d) return d;
+      }
+    }
+    return null;
+  };
+  return n(t);
+}
+const ht = (t) => !w(t) && t.isFolded;
+function re(t) {
+  return ht(t.before) || ht(t.after);
+}
+const K = (t, e) => (w(e) ? t.rows : t.tabsets).get(e.id);
+function oe(t, e, n, i) {
+  const o = Mt(t, i);
+  if (!o) return null;
+  const r = K(e, o.before), a = K(e, o.after);
+  if (!r || !a) return null;
+  const d = rt(t, n), s = o.row.direction === "horizontal", f = (c) => s ? c.width : c.height, p = (c) => {
+    const l = d.get(c.id);
+    return s ? l.width : l.height;
+  };
+  return {
+    value: f(r),
+    min: p(o.before),
+    max: f(r) + f(a) - p(o.after)
+  };
+}
+function Rt(t, e, n, i, o) {
+  const r = Mt(t, i);
+  if (!r || re(r)) return null;
+  const a = K(e, r.before), d = K(e, r.after);
+  if (!a || !d) return null;
+  const s = rt(t, n), f = r.row.direction === "horizontal", p = f ? a.x : a.y, c = f ? d.x + d.width : d.y + d.height, l = s.get(r.before.id), b = s.get(r.after.id), u = f ? l.width : l.height, h = f ? b.width : b.height, g = n.splitterSize / 2, m = f ? o.x : o.y, y = Math.max(
+    p + u + g,
+    Math.min(c - h - g, m)
+  ), x = y - g - p, v = c - (y + g), A = Math.max(0, x - u), C = Math.max(0, v - h), N = A + C, R = r.before.weight + r.after.weight, _ = N > 0 ? A / N * R : R / 2, B = N > 0 ? C / N * R : R / 2, U = r.row.children.map(
+    (I) => I === r.before ? { ...I, weight: _ } : I === r.after ? { ...I, weight: B } : I
+  );
+  return O(
+    t,
+    r.row.id,
+    () => F(r.row, U)
+  );
+}
+const se = (t) => ({
+  type: "tabset",
+  id: t.id,
+  weight: t.weight,
+  activeTabId: t.activeTabId,
+  ...t.isFolded ? { isFolded: !0 } : {},
+  children: t.children.map((e) => ({ type: "tab", id: e.id }))
+}), Lt = (t) => ({
+  type: "row",
+  id: t.id,
+  weight: t.weight,
+  direction: t.direction,
+  children: t.children.map(
+    (e) => w(e) ? Lt(e) : se(e)
+  )
+});
+function Ct(t) {
+  return {
+    version: 2,
+    root: Lt(t.root),
+    ...t.maximizedTabsetId ? { maximizedTabsetId: t.maximizedTabsetId } : {}
+  };
+}
+const ae = (t, e) => {
+  for (const n of Object.keys(t)) {
+    const i = t[n], o = e[n];
+    if (Array.isArray(i) && Array.isArray(o)) {
+      if (i.length !== o.length || i.some((r, a) => r !== o[a]))
+        return !1;
+    } else if (i !== o) return !1;
+  }
+  return !0;
+}, X = (t) => tt() ? Object.freeze(t) : t;
+function Y(t, e) {
+  if (!e)
+    return t.forEach((r) => X(r)), t;
+  let n = t.size !== e.size;
+  const i = [...e.keys()];
+  let o = 0;
+  for (const [r, a] of t) {
+    const d = e.get(r);
+    d && ae(d, a) ? t.set(r, d) : (X(a), n = !0), i[o++] !== r && (n = !0);
+  }
+  return n ? t : e;
+}
+function ut(t, e, n, i) {
+  if (i && i.root === t.root && i.maximizedTabsetId === t.maximizedTabsetId && i.rects === e && i.drag === n)
+    return i;
+  const o = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), d = t.maximizedTabsetId;
+  let s = 0;
+  const f = (c) => c.children.forEach(
+    (l) => w(l) ? f(l) : s++
+  );
+  f(t.root);
+  const p = (c) => {
+    c.children.forEach((l, b) => {
+      if (w(l)) p(l);
+      else {
+        const h = l.id === d, g = !!d && !h, m = l.isFolded && !h;
+        o.set(l.id, {
+          id: l.id,
+          tabIds: l.children.map((y) => y.id),
+          activeTabId: l.activeTabId,
+          parentDirection: c.direction,
+          isFolded: m,
+          isMaximized: h,
+          isHidden: g,
+          canFold: c.children.length > 1,
+          canMaximize: s > 1
+        });
+        for (const y of l.children) {
+          const x = y.id === l.activeTabId;
+          a.set(y.id, {
+            id: y.id,
+            tabsetId: l.id,
+            isActive: x,
+            isVisible: x && !m && !g
+          });
+        }
+      }
+      const u = c.children[b + 1];
+      if (u) {
+        const h = ot(l.id, u.id), g = (m) => !w(m) && m.isFolded;
+        r.set(h, {
+          id: h,
+          rowId: c.id,
+          direction: c.direction,
+          beforeId: l.id,
+          afterId: u.id,
+          isLocked: g(l) || g(u),
+          isHidden: !!d
+        });
+      }
+    });
+  };
+  return p(t.root), X({
+    root: t.root,
+    tabsets: Y(o, i?.tabsets),
+    splitters: Y(r, i?.splitters),
+    tabs: Y(a, i?.tabs),
+    rects: e,
+    maximizedTabsetId: d,
+    drag: n
+  });
+}
+function ce(t, e, n, i) {
+  const o = /* @__PURE__ */ new Set();
+  let r = t, a = e, d = { x: 0, y: 0, width: 0, height: 0 }, s = ft(
+    r.root,
+    d,
+    a,
+    r.maximizedTabsetId
+  ), f = null, p = ut(r, s, null), c = !1, l = null;
+  const b = () => {
+    s = ft(
+      r.root,
+      d,
+      a,
+      r.maximizedTabsetId,
+      s
+    );
+    const h = le(p.drag, f) ? p.drag : f && de(f), g = ut(r, s, h, p);
+    g !== p && (p = g, o.forEach((m) => m(p)));
+  }, u = () => (l && l.model.root === r.root && l.model.maximizedTabsetId === r.maximizedTabsetId || (l = { model: r, value: Ct(r) }), l.value);
+  return {
+    get model() {
+      return r;
+    },
+    get rects() {
+      return s;
+    },
+    get config() {
+      return a;
+    },
+    get snapshot() {
+      return p;
+    },
+    get drag() {
+      return f;
+    },
+    get isDestroyed() {
+      return c;
+    },
+    subscribe(h) {
+      return o.add(h), () => o.delete(h);
+    },
+    setContainer(h) {
+      d = h, c || b();
+    },
+    setConfig(h) {
+      a = h, c || b();
+    },
+    update(h) {
+      c || (h.model && (r = h.model), h.drag !== void 0 && (f = h.drag), b());
+    },
+    commit(h, g) {
+      return c ? (i({
+        code: "DESTROYED",
+        message: "This layout was destroyed; the call was ignored."
+      }), !1) : !h || h === r ? !1 : (r = h, b(), g && n?.(u(), g), !0);
+    },
+    report(h) {
+      c || n?.(u(), h);
+    },
+    toJSON: u,
+    destroy() {
+      c = !0, f = null, o.clear();
+    }
+  };
+}
+const de = ({ source: t, target: e, indicator: n }) => ({
+  source: t,
+  target: e,
+  indicator: n
+});
+function le(t, e) {
+  return !t || !e ? t === e : t.source === e.source && t.target === e.target && t.indicator === e.indicator;
+}
+function fe(t, e) {
+  return t === e ? !0 : !t || !e || t.type !== e.type || t.position !== e.position ? !1 : t.type === "tab" ? t.tabId === e.tabId : t.type === "tabset" ? t.tabsetId === e.tabsetId : !0;
+}
+function he(t, e) {
+  const n = {
+    startDrag(i) {
+      if (t.isDestroyed) return !1;
+      const { snapshot: o, model: r } = t;
+      if (i.type === "splitter") {
+        const a = o.splitters.get(i.splitterId);
+        if (!a || a.isLocked || r.maximizedTabsetId)
+          return !1;
+      } else {
+        if (!(i.type === "tab" ? o.tabs.has(i.tabId) : o.tabsets.has(i.tabsetId))) return !1;
+        t.commit(Ft(r), "maximize");
+      }
+      return t.update({
+        drag: {
+          source: i,
+          target: null,
+          indicator: null,
+          startRoot: t.model.root
+        }
+      }), !0;
+    },
+    updateDrag(i, o) {
+      const { drag: r, model: a, rects: d, config: s } = t;
+      if (r) {
+        if (r.source.type === "splitter") {
+          const f = Rt(
+            a.root,
+            d,
+            s,
+            r.source.splitterId,
+            i
+          );
+          f && t.update({ model: { ...a, root: f } });
+          return;
+        }
+        n.setDragTarget(
+          $t(a, d, i, r.source, o),
+          o
+        );
+      }
+    },
+    setDragTarget(i, o) {
+      const { drag: r, model: a, rects: d } = t;
+      if (!r || r.source.type === "splitter" || fe(r.target, i))
+        return;
+      const s = i && It(a, d, i, o);
+      t.update({ drag: { ...r, target: i, indicator: s } });
+    },
+    endDrag() {
+      const { drag: i, model: o } = t;
+      if (!i) return !1;
+      if (t.update({ drag: null }), i.source.type === "splitter")
+        return o.root === i.startRoot ? !1 : (t.report("resize"), !0);
+      const r = i.target && Z(o, i.source, i.target, e);
+      return t.commit(r, "move");
+    },
+    cancelDrag() {
+      const { drag: i, model: o } = t;
+      if (!i) return;
+      const r = i.source.type === "splitter" && o.root !== i.startRoot;
+      t.update({
+        drag: null,
+        ...r ? { model: { ...o, root: i.startRoot } } : {}
+      });
+    }
+  };
+  return n;
+}
+const ue = [
+  "center",
+  "left",
+  "right",
+  "top",
+  "bottom"
+], be = ["left", "right", "top", "bottom"];
+function ge(t, e) {
+  const n = [];
+  for (const i of E(t.root))
+    for (const o of ue)
+      n.push({ type: "tabset", tabsetId: i.id, position: o });
+  for (const i of be) n.push({ type: "root", position: i });
+  return n.filter((i) => nt(t.root, e, i));
+}
+class L extends Error {
+  code;
+  /** Where in the input the problem is, e.g. `root.children[1].weight`. */
+  path;
+  constructor(e, n, i) {
+    super(i ? `${n} (at ${i})` : n), this.name = "DynamixLayoutError", this.code = e, this.path = i;
+  }
+}
+const pe = {
+  minPanelSize: { width: 40, height: 40 },
+  splitterSize: 10,
+  foldedSize: 40
+}, bt = { row: "row", tabset: "ts" };
+function me(t) {
+  const e = /* @__PURE__ */ new Set();
+  let n = 0;
+  return {
+    createId: (o, r) => {
+      if (t) {
+        const d = t(o, r);
+        return e.add(d), d;
+      }
+      let a = r === void 0 ? "" : `${bt[o]}-${r}`;
+      for (; a === "" || e.has(a); ) a = `${bt[o]}-${++n}`;
+      return e.add(a), a;
+    },
+    reserve(o) {
+      for (const r of o) e.add(r);
+    },
+    reset() {
+      e.clear(), n = 0;
+    }
+  };
+}
+const k = (t) => typeof t == "object" && t !== null && !Array.isArray(t), D = (t, e) => {
+  throw new L("INVALID_LAYOUT", t, e);
+}, ye = ["horizontal", "vertical"];
+function Q(t, e) {
+  const n = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), o = (c, l) => {
+    (typeof c.id != "string" || c.id === "") && D("Expected a non-empty string id", `${l}.id`);
+    const b = c.id;
+    return n.has(b) && D(`Duplicate node id "${b}"`, `${l}.id`), n.add(b), b;
+  }, r = (c, l) => {
+    const b = c.weight;
+    return typeof b == "number" && Number.isFinite(b) && b >= 0 ? b : (e({
+      code: "INVALID_WEIGHT",
+      message: "Invalid weight replaced by 100",
+      path: `${l}.weight`
+    }), 100);
+  }, a = (c, l) => {
+    const b = o(c, l);
+    Array.isArray(c.children) || D("Expected a children array", `${l}.children`);
+    const u = c.children.flatMap((g, m) => {
+      const y = `${l}.children[${m}]`;
+      (!k(g) || g.type !== "tab" || typeof g.id != "string" || g.id === "") && D('Expected { type: "tab", id: string }', y);
+      const x = g.id;
+      return i.has(x) ? (e({
+        code: "DUPLICATE_TAB_ID",
+        message: `Duplicate tab "${x}" dropped`,
+        path: y
+      }), []) : (i.add(x), [{ type: "tab", id: x }]);
+    }), h = c.activeTabId;
+    return h !== void 0 && !u.some((g) => g.id === h) && e({
+      code: "INVALID_ACTIVE_TAB",
+      message: `Active tab "${String(h)}" is not in the tabset`,
+      path: `${l}.activeTabId`
+    }), {
+      type: "tabset",
+      id: b,
+      weight: r(c, l),
+      activeTabId: typeof h == "string" ? h : u[0]?.id ?? "",
+      isFolded: c.isFolded === !0,
+      children: u
+    };
+  }, d = (c, l) => {
+    const b = o(c, l);
+    ye.includes(c.direction) || D(
+      'Expected direction "horizontal" or "vertical"',
+      `${l}.direction`
+    ), Array.isArray(c.children) || D("Expected a children array", `${l}.children`);
+    const u = c.children.map(
+      (h, g) => {
+        const m = `${l}.children[${g}]`;
+        return k(h) ? h.type === "row" ? d(h, m) : h.type === "tabset" ? a(h, m) : D(
+          'Expected type "row" or "tabset"',
+          `${m}.type`
+        ) : D("Expected a row or tabset", m);
+      }
+    );
+    return {
+      type: "row",
+      id: b,
+      weight: r(c, l),
+      direction: c.direction,
+      children: u
+    };
+  };
+  (!k(t.root) || t.root.type !== "row") && D("Expected a root row", "root");
+  const s = V(d(t.root, "root")), f = typeof t.maximizedTabsetId == "string" ? t.maximizedTabsetId : null, p = M({
+    root: s,
+    maximizedTabsetId: f,
+    lastActiveTabsetId: null,
+    foldOrder: []
+  });
+  return { root: p.root, maximizedTabsetId: p.maximizedTabsetId };
+}
+function _t(t) {
+  return typeof t == "object" && t !== null && !("version" in t) && typeof t.typNode == "string";
+}
+const we = (t) => typeof t == "number" && Number.isFinite(t) && t >= 0;
+function xe(t, e = {}) {
+  const n = e.onWarning ?? (() => {
+  }), i = (u, h) => we(u.nodPart) ? u.nodPart : (n({
+    code: "INVALID_WEIGHT",
+    message: "Invalid weight replaced by 100",
+    path: `${h}.nodPart`
+  }), 100);
+  if (!_t(t))
+    throw new L("INVALID_LAYOUT", "Not a v1 layout", "");
+  const o = /* @__PURE__ */ new Set(), r = (u) => {
+    typeof u.uidNode == "string" && o.add(u.uidNode), u.nodKids?.forEach(r);
+  };
+  r(t);
+  const a = (u) => {
+    let h = u;
+    for (let g = 1; o.has(h); g++) h = `${u}-${g}`;
+    return o.add(h), h;
+  }, d = (u, h) => typeof u.uidNode == "string" && u.uidNode !== "" ? u.uidNode : a(h), s = /* @__PURE__ */ new Set(), f = (u, h) => u.flatMap((g, m) => {
+    if (g?.typNode !== "tab") return [];
+    const y = g.nodName;
+    return typeof y != "string" || y === "" || s.has(y) ? (n({
+      code: "DUPLICATE_TAB_ID",
+      message: `Duplicate or unnamed tab "${String(y)}" dropped`,
+      path: `${h}.nodKids[${m}]`
+    }), []) : (s.add(y), [{ type: "tab", id: y }]);
+  }), p = (u, h) => {
+    const g = f(u.nodKids ?? [], h), m = typeof u.nodOpen == "string" ? u.nodOpen : "", y = g.some((x) => x.id === m);
+    return m && !y && g.length > 0 && n({
+      code: "INVALID_ACTIVE_TAB",
+      message: `Active tab "${m}" is not in the tabset`,
+      path: `${h}.nodOpen`
+    }), {
+      type: "tabset",
+      id: d(u, "ts"),
+      weight: i(u, h),
+      ...g.length > 0 ? { activeTabId: y ? m : g[0].id } : {},
+      ...u.nodFold === !0 ? { isFolded: !0 } : {},
+      children: g
+    };
+  }, c = (u, h, g) => {
+    const m = h % 2 === 0 ? "horizontal" : "vertical", y = [];
+    return (u.nodKids ?? []).forEach((x, v) => {
+      const A = `${g}.nodKids[${v}]`;
+      x?.typNode === "row" ? y.push(c(x, h + 1, A)) : x?.typNode === "tabset" ? y.push(p(x, A)) : x?.typNode === "tab" && y.push({
+        ...p(
+          {
+            ...x,
+            uidNode: a(`ts-${x.nodName}`),
+            nodKids: [x],
+            nodOpen: x.nodName
+          },
+          A
+        )
+      });
+    }), {
+      type: "row",
+      id: d(u, "row"),
+      weight: i(u, g),
+      direction: m,
+      children: y
+    };
+  }, b = {
+    root: t.typNode === "row" ? c(t, 0, "root") : t.typNode === "tabset" ? {
+      type: "row",
+      id: a("root"),
+      weight: 100,
+      direction: "horizontal",
+      children: [p(t, "root")]
+    } : (() => {
+      throw new L(
+        "INVALID_LAYOUT",
+        `A v1 layout root must be a row, not "${t.typNode}"`,
+        "root"
+      );
+    })(),
+    ...typeof t.nodMaxd == "string" ? { maximizedTabsetId: t.nodMaxd } : {}
+  };
+  return Ct(Q(b, n));
+}
+const gt = 2, Ie = (t) => typeof t == "object" && t !== null && !Array.isArray(t);
+function Te(t, e) {
+  if (_t(t))
+    return e({
+      code: "MIGRATED_FROM_V1",
+      message: "Loaded a v1 layout; save it again to store the v2 format."
+    }), Q(
+      xe(t, { onWarning: e }),
+      e
+    );
+  if (!Ie(t))
+    throw new L(
+      "INVALID_LAYOUT",
+      "Expected a layout object"
+    );
+  if (t.version !== gt)
+    throw new L(
+      "UNSUPPORTED_VERSION",
+      `Unsupported layout version ${String(t.version)}; expected ${gt}`,
+      "version"
+    );
+  return Q(t, e);
+}
+function ze(t, e) {
+  return t.lastActiveTabsetId && T(e, t.lastActiveTabsetId) ? t.lastActiveTabsetId : E(e)[0]?.id;
+}
+function Pt(t, e, n, i = !0) {
+  if (S(t.root, e.id)) return t;
+  const o = { type: "tab", id: e.id }, r = e.target;
+  let a = t.root;
+  const d = (s) => {
+    const f = T(a, s), p = i ? e.id : f.activeTabId;
+    return j(
+      a,
+      s,
+      [o],
+      f.children.length,
+      p
+    );
+  };
+  if (r?.type === "tab" && S(a, r.tabId)) {
+    const s = S(a, r.tabId), f = s.children.findIndex((p) => p.id === r.tabId) + (r.position === "after" ? 1 : 0);
+    a = j(
+      a,
+      s.id,
+      [o],
+      f,
+      i ? e.id : s.activeTabId
+    );
+  } else r?.type === "tabset" && T(a, r.tabsetId) ? a = r.position === "center" ? d(r.tabsetId) : At(
+    a,
+    r.tabsetId,
+    P(e.id, n),
+    r.position,
+    n
+  ) : r?.type === "root" || E(a).length === 0 ? a = Dt(
+    a,
+    P(e.id, n),
+    r?.type === "root" ? r.position : "right",
+    n
+  ) : a = d(ze(t, a));
+  return a = V(a), M({
+    ...t,
+    root: a,
+    lastActiveTabsetId: i ? S(a, e.id)?.id ?? null : t.lastActiveTabsetId
+  });
+}
+function pt(t, e, n, i = !0) {
+  const o = new Set(e.map((d) => d.id));
+  let r = t.root;
+  for (const d of Wt(r))
+    o.has(d) || (r = it(r, d));
+  let a = r === t.root ? t : M({ ...t, root: r });
+  for (const d of e) a = Pt(a, d, n, i);
+  return a;
+}
+const mt = "root";
+function Se(t) {
+  const e = t.onWarning ?? Ut, n = me(t.createId), { createId: i, reserve: o } = n;
+  let r = wt(t.tabs, e);
+  const a = (c) => {
+    const l = Te(c, e);
+    o(xt(l.root));
+    const b = { ...l, lastActiveTabsetId: null, foldOrder: [] };
+    return pt(b, r, i, !1);
+  }, d = () => {
+    if (t.initialLayout) return a(t.initialLayout);
+    o([mt]);
+    const c = r.map((l) => l.id);
+    return {
+      root: Jt(c, i, mt),
+      maximizedTabsetId: null,
+      lastActiveTabsetId: null,
+      foldOrder: []
+    };
+  }, s = ce(
+    d(),
+    yt(t, pe),
+    t.onLayoutChange,
+    e
+  ), f = (c, l) => (e({ code: "UNKNOWN_ID", message: `Unknown ${c} "${l}"` }), !1), p = {
+    getSnapshot: () => s.snapshot,
+    subscribe: (c) => s.subscribe(c),
+    setContainerRect: (c) => s.setContainer(c),
+    setOptions: (c) => s.setConfig(yt(c, s.config)),
+    setTabs(c) {
+      r = wt(c, e), s.commit(
+        pt(s.model, r, i, !0),
+        "tabs"
+      );
+    },
+    moveTab: (c, l) => s.commit(
+      Z(s.model, { type: "tab", tabId: c }, l, i),
+      "move"
+    ),
+    moveTabset: (c, l) => s.commit(
+      Z(
+        s.model,
+        { type: "tabset", tabsetId: c },
+        l,
+        i
+      ),
+      "move"
+    ),
+    selectTab(c) {
+      const { model: l } = s, b = S(l.root, c);
+      if (!b) return f("tab", c);
+      if (b.activeTabId === c && l.lastActiveTabsetId === b.id)
+        return !1;
+      const u = O(l.root, b.id, () => ({
+        ...b,
+        activeTabId: c
+      }));
+      return s.commit(
+        { ...l, root: u, lastActiveTabsetId: b.id },
+        "select"
+      );
+    },
+    addTab(c, l) {
+      if (r.some((u) => u.id === c.id)) return !1;
+      const b = l ? { ...c, target: l } : c;
+      return r = [...r, b], s.commit(
+        Pt(s.model, b, i, !0),
+        "tabs"
+      );
+    },
+    removeTab(c) {
+      if (!r.some((u) => u.id === c)) return f("tab", c);
+      r = r.filter((u) => u.id !== c);
+      const { model: l } = s, b = it(l.root, c);
+      return s.commit(
+        M({ ...l, root: b }),
+        "tabs"
+      );
+    },
+    resizeSplitter(c, l) {
+      const { model: b, rects: u, config: h } = s;
+      if (b.maximizedTabsetId) return !1;
+      const g = Rt(
+        b.root,
+        u,
+        h,
+        c,
+        l
+      );
+      return s.commit(g && { ...b, root: g }, "resize");
+    },
+    moveSplitterBy(c, l) {
+      const b = s.rects.splitters.get(c), u = s.snapshot.splitters.get(c);
+      if (!b || !u) return f("splitter", c);
+      const h = b.x + b.width / 2, g = b.y + b.height / 2, m = u.direction === "horizontal" ? { x: h + l, y: g } : { x: h, y: g + l };
+      return p.resizeSplitter(c, m);
+    },
+    maximize: (c) => s.commit(qt(s.model, c), "maximize"),
+    restore: () => s.commit(Ft(s.model), "maximize"),
+    toggleMaximize: (c) => s.model.maximizedTabsetId === c ? p.restore() : p.maximize(c),
+    fold: (c) => s.commit(Zt(s.model, c), "fold"),
+    unfold: (c) => s.commit(Xt(s.model, c), "fold"),
+    toggleFold(c) {
+      const l = s.snapshot.tabsets.get(c);
+      return l ? l.isFolded ? p.unfold(c) : p.fold(c) : f("tabset", c);
+    },
+    ...he(s, i),
+    getDropTarget: (c, l, b) => l.type === "splitter" ? null : $t(
+      s.model,
+      s.rects,
+      c,
+      l,
+      b
+    ),
+    getDropIndicatorRect: (c, l) => It(
+      s.model,
+      s.rects,
+      c,
+      l
+    ),
+    listDropTargets: (c) => c.type === "splitter" ? [] : ge(s.model, c),
+    getSplitterBounds: (c) => oe(s.model.root, s.rects, s.config, c),
+    load: (c) => {
+      s.commit(a(c));
+    },
+    reset() {
+      n.reset(), s.commit(d(), "reset");
+    },
+    toJSON: () => s.toJSON(),
+    destroy: () => s.destroy()
+  };
+  return p;
+}
+function yt(t, e) {
+  return {
+    minPanelSize: t.minPanelSize ?? e.minPanelSize,
+    splitterSize: t.splitterSize ?? e.splitterSize,
+    foldedSize: t.foldedSize ?? t.minPanelSize?.height ?? e.foldedSize
+  };
+}
+function wt(t, e) {
+  const n = /* @__PURE__ */ new Set();
+  return t.filter((i) => {
+    if (!n.has(i.id))
+      return n.add(i.id), !0;
+    if (tt())
+      throw new L(
+        "DUPLICATE_TAB_ID",
+        `Duplicate tab id "${i.id}"`
+      );
+    return e({
+      code: "DUPLICATE_TAB_ID",
+      message: `Duplicate tab id "${i.id}" ignored`
+    }), !1;
+  });
+}
+function ve(t, e, n) {
+  const { x: i, y: o, width: r, height: a } = t;
+  return e.isFolded && e.parentDirection === "horizontal" ? {
+    rect: { x: i + r, y: o, width: a, height: r },
+    isRotated: !0
+  } : { rect: { x: i, y: o, width: r, height: n }, isRotated: !1 };
+}
+function Ae(t, e) {
+  return {
+    x: t.x,
+    y: t.y + e,
+    width: t.width,
+    height: Math.max(0, t.height - e)
+  };
+}
+function De(t, e) {
+  const { style: n } = t;
+  n.left = `${e.x}px`, n.top = `${e.y}px`, n.width = `${e.width}px`, n.height = `${e.height}px`;
+}
+function Oe(t) {
+  let e = null, n = null;
+  const i = () => {
+    n = null;
+    const o = e;
+    e = null, o && t(o.value);
+  };
+  return {
+    schedule(o) {
+      e = { value: o }, n === null && (n = requestAnimationFrame(i));
+    },
+    flush() {
+      n !== null && (cancelAnimationFrame(n), i());
+    },
+    cancel() {
+      n !== null && cancelAnimationFrame(n), n = null, e = null;
+    }
+  };
+}
+const Ee = "2.0.0";
+export {
+  L as DynamixLayoutError,
+  gt as LAYOUT_VERSION,
+  De as applyRect,
+  Oe as createFrameScheduler,
+  Se as createLayout,
+  te as getRootDropZoneRect,
+  ve as getTabBarPlacement,
+  Ae as getTabContentRect,
+  _t as isLayoutV1,
+  xe as migrateLayoutFromV1,
+  Ee as version
+};