@nldoc/validation 1.0.0

package/dist/index.mjs

@@ -0,0 +1,922 @@
+import { ValidationFinding as pe } from "@nldoc/types";
+import ce, { useMemo as me, useState as H, useEffect as w, createContext as ge, useContext as Ee, useRef as de, useReducer as he, useCallback as Se, useLayoutEffect as Ie } from "react";
+import { z as be } from "zod";
+import { ContentType as ee, useConversion as ke } from "@nldoc/api";
+import { useDebounce as Re } from "use-debounce";
+import { TransactionMeta as ve } from "@nldoc/tiptap-extensions";
+function xe(n, t = {}) {
+  const { debounceDelay: r = 500, debounceMaxWait: o = 5e3, includeAssets: s = !1 } = t, [i] = Re(n, r, { maxWait: o }), l = me(() => {
+    if (!i) return null;
+    const p = s ? i : {
+      ...i,
+      attrs: { ...i.attrs, assets: {} }
+    };
+    return new Blob([JSON.stringify(p)], { type: ee.Tiptap });
+  }, [i, s]);
+  return ke(l, ee.Validation);
+}
+const Te = new Error("An unknown error occurred"), _e = be.array(pe);
+function Ne(n, t = {}) {
+  const r = xe(n, t), [o, s] = H(!1), [i, l] = H([]), [p, b] = H(null);
+  return w(() => {
+    if (r.status === "error") {
+      s(!1), b(r.error);
+      return;
+    }
+    if (r.status === "idle") {
+      s(!1);
+      return;
+    }
+    if (r.status !== "done") {
+      s(!0);
+      return;
+    }
+    try {
+      const E = _e.parse(JSON.parse(r.content));
+      l(E), b(null);
+    } catch (E) {
+      b(E instanceof Error ? E : Te);
+    } finally {
+      s(!1);
+    }
+  }, [r]), { isValidating: o, findings: i, error: p };
+}
+var V = { exports: {} }, G = {};
+var ne;
+function ye() {
+  if (ne) return G;
+  ne = 1;
+  var n = /* @__PURE__ */ Symbol.for("react.transitional.element"), t = /* @__PURE__ */ Symbol.for("react.fragment");
+  function r(o, s, i) {
+    var l = null;
+    if (i !== void 0 && (l = "" + i), s.key !== void 0 && (l = "" + s.key), "key" in s) {
+      i = {};
+      for (var p in s)
+        p !== "key" && (i[p] = s[p]);
+    } else i = s;
+    return s = i.ref, {
+      $$typeof: n,
+      type: o,
+      key: l,
+      ref: s !== void 0 ? s : null,
+      props: i
+    };
+  }
+  return G.Fragment = t, G.jsx = r, G.jsxs = r, G;
+}
+var U = {};
+var te;
+function Ae() {
+  return te || (te = 1, process.env.NODE_ENV !== "production" && (function() {
+    function n(e) {
+      if (e == null) return null;
+      if (typeof e == "function")
+        return e.$$typeof === q ? null : e.displayName || e.name || null;
+      if (typeof e == "string") return e;
+      switch (e) {
+        case y:
+          return "Fragment";
+        case h:
+          return "Profiler";
+        case c:
+          return "StrictMode";
+        case _:
+          return "Suspense";
+        case z:
+          return "SuspenseList";
+        case W:
+          return "Activity";
+      }
+      if (typeof e == "object")
+        switch (typeof e.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), e.$$typeof) {
+          case m:
+            return "Portal";
+          case u:
+            return e.displayName || "Context";
+          case S:
+            return (e._context.displayName || "Context") + ".Consumer";
+          case L:
+            var f = e.render;
+            return e = e.displayName, e || (e = f.displayName || f.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+          case M:
+            return f = e.displayName || null, f !== null ? f : n(e.type) || "Memo";
+          case P:
+            f = e._payload, e = e._init;
+            try {
+              return n(e(f));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function t(e) {
+      return "" + e;
+    }
+    function r(e) {
+      try {
+        t(e);
+        var f = !1;
+      } catch {
+        f = !0;
+      }
+      if (f) {
+        f = console;
+        var I = f.error, v = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return I.call(
+          f,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          v
+        ), t(e);
+      }
+    }
+    function o(e) {
+      if (e === y) return "<>";
+      if (typeof e == "object" && e !== null && e.$$typeof === P)
+        return "<...>";
+      try {
+        var f = n(e);
+        return f ? "<" + f + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function s() {
+      var e = D.A;
+      return e === null ? null : e.getOwner();
+    }
+    function i() {
+      return Error("react-stack-top-frame");
+    }
+    function l(e) {
+      if (B.call(e, "key")) {
+        var f = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (f && f.isReactWarning) return !1;
+      }
+      return e.key !== void 0;
+    }
+    function p(e, f) {
+      function I() {
+        j || (j = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          f
+        ));
+      }
+      I.isReactWarning = !0, Object.defineProperty(e, "key", {
+        get: I,
+        configurable: !0
+      });
+    }
+    function b() {
+      var e = n(this.type);
+      return $[e] || ($[e] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), e = this.props.ref, e !== void 0 ? e : null;
+    }
+    function E(e, f, I, v, F, J) {
+      var x = I.ref;
+      return e = {
+        $$typeof: R,
+        type: e,
+        key: f,
+        props: I,
+        _owner: v
+      }, (x !== void 0 ? x : null) !== null ? Object.defineProperty(e, "ref", {
+        enumerable: !1,
+        get: b
+      }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(e, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(e, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: F
+      }), Object.defineProperty(e, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: J
+      }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+    }
+    function a(e, f, I, v, F, J) {
+      var x = f.children;
+      if (x !== void 0)
+        if (v)
+          if (Y(x)) {
+            for (v = 0; v < x.length; v++)
+              g(x[v]);
+            Object.freeze && Object.freeze(x);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else g(x);
+      if (B.call(f, "key")) {
+        x = n(e);
+        var C = Object.keys(f).filter(function(fe) {
+          return fe !== "key";
+        });
+        v = 0 < C.length ? "{key: someKey, " + C.join(": ..., ") + ": ...}" : "{key: someKey}", Q[x + v] || (C = 0 < C.length ? "{" + C.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          v,
+          x,
+          C,
+          x
+        ), Q[x + v] = !0);
+      }
+      if (x = null, I !== void 0 && (r(I), x = "" + I), l(f) && (r(f.key), x = "" + f.key), "key" in f) {
+        I = {};
+        for (var K in f)
+          K !== "key" && (I[K] = f[K]);
+      } else I = f;
+      return x && p(
+        I,
+        typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+      ), E(
+        e,
+        x,
+        I,
+        s(),
+        F,
+        J
+      );
+    }
+    function g(e) {
+      T(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e !== null && e.$$typeof === P && (e._payload.status === "fulfilled" ? T(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+    }
+    function T(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === R;
+    }
+    var k = ce, R = /* @__PURE__ */ Symbol.for("react.transitional.element"), m = /* @__PURE__ */ Symbol.for("react.portal"), y = /* @__PURE__ */ Symbol.for("react.fragment"), c = /* @__PURE__ */ Symbol.for("react.strict_mode"), h = /* @__PURE__ */ Symbol.for("react.profiler"), S = /* @__PURE__ */ Symbol.for("react.consumer"), u = /* @__PURE__ */ Symbol.for("react.context"), L = /* @__PURE__ */ Symbol.for("react.forward_ref"), _ = /* @__PURE__ */ Symbol.for("react.suspense"), z = /* @__PURE__ */ Symbol.for("react.suspense_list"), M = /* @__PURE__ */ Symbol.for("react.memo"), P = /* @__PURE__ */ Symbol.for("react.lazy"), W = /* @__PURE__ */ Symbol.for("react.activity"), q = /* @__PURE__ */ Symbol.for("react.client.reference"), D = k.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, B = Object.prototype.hasOwnProperty, Y = Array.isArray, A = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    k = {
+      react_stack_bottom_frame: function(e) {
+        return e();
+      }
+    };
+    var j, $ = {}, X = k.react_stack_bottom_frame.bind(
+      k,
+      i
+    )(), Z = A(o(i)), Q = {};
+    U.Fragment = y, U.jsx = function(e, f, I) {
+      var v = 1e4 > D.recentlyCreatedOwnerStacks++;
+      return a(
+        e,
+        f,
+        I,
+        !1,
+        v ? Error("react-stack-top-frame") : X,
+        v ? A(o(e)) : Z
+      );
+    }, U.jsxs = function(e, f, I) {
+      var v = 1e4 > D.recentlyCreatedOwnerStacks++;
+      return a(
+        e,
+        f,
+        I,
+        !0,
+        v ? Error("react-stack-top-frame") : X,
+        v ? A(o(e)) : Z
+      );
+    };
+  })()), U;
+}
+var re;
+function je() {
+  return re || (re = 1, process.env.NODE_ENV === "production" ? V.exports = ye() : V.exports = Ae()), V.exports;
+}
+var d = je();
+const ue = ge({
+  findings: [],
+  isValidating: !1,
+  error: null
+});
+function Ze({
+  children: n,
+  editor: t,
+  editorJSON: r,
+  options: o,
+  autoApplyFindings: s = !0,
+  onApplyFindings: i
+}) {
+  const [l, p] = H(
+    () => r !== void 0 ? null : t?.getJSON() ?? null
+  );
+  w(() => {
+    if (!t || r !== void 0) return;
+    const a = ({
+      editor: g,
+      transaction: T
+    }) => {
+      T.getMeta(ve.blockValidation) !== !0 && p(g.getJSON());
+    };
+    return t.on("update", a), () => {
+      t.off("update", a);
+    };
+  }, [t, r]);
+  const E = Ne(r ?? l, o);
+  return w(() => {
+    if (!(!t || !s))
+      if (i)
+        i(t, E.findings);
+      else {
+        const a = t.commands;
+        a.setValidationFindings && a.setValidationFindings(E.findings);
+      }
+  }, [t, E.findings, s, i]), /* @__PURE__ */ d.jsx(ue.Provider, { value: E, children: n });
+}
+function Qe() {
+  return Ee(ue);
+}
+const Le = ({
+  findings: n,
+  isBundle: t = !1,
+  variant: r = "default",
+  stackAmount: o,
+  stackIsExpanded: s,
+  stackOnToggle: i,
+  onResolve: l,
+  onRetrigger: p,
+  isExpanded: b,
+  onToggle: E,
+  labels: a = {},
+  renderIcon: g,
+  renderMessage: T,
+  renderResolution: k,
+  className: R = "",
+  styles: m = {}
+}) => {
+  const y = de(null), [c, h] = ce.useState(!1), S = r === "stack";
+  if (S && (o === void 0 || s === void 0 || !i))
+    return console.error(
+      'ValidationResult: stackAmount, stackIsExpanded, and stackOnToggle are required when variant="stack"'
+    ), null;
+  const u = S ? s : b ?? c, L = S ? i : E ?? (() => h(!c)), _ = n[0], M = g ?? ((A) => {
+    const j = {
+      error: "⚠️",
+      warning: "⚠️",
+      suggestion: "ℹ️",
+      close: "✕",
+      chevron: "▼"
+    };
+    return /* @__PURE__ */ d.jsx("span", { children: j[A] });
+  }), W = T ?? ((A, j, $) => $ ? `${j} ${A.rule} findings` : j > 1 ? `${j} ${A.rule} findings` : A.rule), D = k ?? ((A, j) => /* @__PURE__ */ d.jsx(
+    "button",
+    {
+      onClick: () => {
+        l && l(A), j();
+      },
+      children: "Resolve"
+    }
+  )), B = () => {
+    p && p();
+  }, Y = /* @__PURE__ */ d.jsxs(
+    "div",
+    {
+      className: `${m.outerWrapper ?? ""} ${R}`,
+      ref: S ? null : y,
+      children: [
+        /* @__PURE__ */ d.jsx(
+          "button",
+          {
+            className: `${m.toggleButton ?? ""} ${u ? m.toggleButtonSelected ?? "" : ""}`,
+            onClick: L,
+            "aria-controls": `comment-${t ? "" : "inner-"}${_.resourceId}`,
+            "aria-expanded": u,
+            "aria-label": a.toggleFinding ?? "Toggle finding details",
+            "data-testid": "toggle-button",
+            children: /* @__PURE__ */ d.jsx("div", { className: m.dropShadow ?? "", children: S ? /* @__PURE__ */ d.jsx("div", { className: m.amount ?? "", children: /* @__PURE__ */ d.jsx("strong", { children: o }) }) : M(u ? "close" : _.severity) })
+          }
+        ),
+        /* @__PURE__ */ d.jsxs(
+          "div",
+          {
+            className: `${m.result ?? ""} ${m.resultSeverity ? `${m.resultSeverity}-${_.severity}` : ""} ${u ? m.resultSelected ?? "" : ""}`,
+            id: `comment-${t ? "" : "inner-"}${_.resourceId}`,
+            tabIndex: -1,
+            "aria-live": "polite",
+            children: [
+              /* @__PURE__ */ d.jsxs("div", { className: m.messageWrapper ?? "", children: [
+                /* @__PURE__ */ d.jsxs("div", { className: m.label ?? "", children: [
+                  M(_.severity),
+                  /* @__PURE__ */ d.jsx("strong", { children: a.severity?.[_.severity] ?? _.severity })
+                ] }),
+                /* @__PURE__ */ d.jsx("div", { className: m.message ?? "", children: W(
+                  _,
+                  S ? o ?? 0 : n.length,
+                  t
+                ) })
+              ] }),
+              S ? /* @__PURE__ */ d.jsx("div", { className: m.openValidations ?? "", children: /* @__PURE__ */ d.jsx("button", { onClick: i, children: a.toggleStackOpen ?? "Open validations" }) }) : /* @__PURE__ */ d.jsx("div", { className: m.resolution ?? "", children: D(
+                n.map((A) => A.resourceId),
+                B
+              ) })
+            ]
+          }
+        )
+      ]
+    }
+  );
+  return S ? /* @__PURE__ */ d.jsxs("div", { className: m.stack ?? "", children: [
+    Y,
+    o === 2 ? /* @__PURE__ */ d.jsx("div", { className: m.stackDecorationTwoItems ?? "" }) : /* @__PURE__ */ d.jsx("div", { className: m.stackDecorationManyItems ?? "", children: /* @__PURE__ */ d.jsx("div", { className: m.stackDecorationManyItems ?? "" }) })
+  ] }) : Y;
+}, Oe = ["no-underline", "style-bold-in-header", "style-italic-in-header"];
+function Ce(n, t) {
+  const r = /* @__PURE__ */ new Map();
+  for (const s of n) {
+    if (!Oe.includes(s.rule) || s.hidden) continue;
+    const i = t.get(s.resourceId);
+    if (!i) continue;
+    const l = r.get(i);
+    l ? l.push(s) : r.set(i, [s]);
+  }
+  const o = [];
+  for (const [s, i] of r) {
+    if (i.length < 2) continue;
+    const l = [...i].sort((p, b) => p.desiredYLocation - b.desiredYLocation);
+    o.push({
+      id: crypto.randomUUID(),
+      type: "bundle",
+      findings: l,
+      blockId: s,
+      rule: l[0].rule,
+      // All findings in bundle have same rule
+      desiredYLocation: l[0].desiredYLocation,
+      yLocation: l[0].desiredYLocation
+    });
+  }
+  return o;
+}
+function we(n) {
+  const t = /* @__PURE__ */ new Set();
+  for (const r of n)
+    for (const o of r.findings)
+      t.add(o.resourceId);
+  return t;
+}
+function Me(n, t = {}) {
+  const { editorSelector: r = "#tiptap" } = t, o = document.getElementById(n.resourceId);
+  if (!o)
+    return null;
+  const s = document.querySelector(r);
+  if (!s)
+    throw new Error(`Editor not found: ${r} element does not exist`);
+  const i = s.getBoundingClientRect().top;
+  return o.getBoundingClientRect().top - i;
+}
+function De(n, t) {
+  const o = Me(n, t) ?? 0;
+  return {
+    ...n,
+    desiredYLocation: o,
+    yLocation: o,
+    hidden: !1
+  };
+}
+function se(n, t) {
+  return n.map((r) => De(r, t)).sort(Ge);
+}
+function Ge(n, t) {
+  const r = n.desiredYLocation - t.desiredYLocation;
+  return Math.abs(r) > 0.01 ? r : n.resourceId.localeCompare(t.resourceId);
+}
+function le(n) {
+  return "type" in n && n.type === "bundle";
+}
+function oe(n) {
+  return le(n) ? `bundle:${n.blockId}` : n.resourceId;
+}
+function O(n) {
+  return n.desiredYLocation;
+}
+function Ue(n) {
+  return n.map((t) => ({
+    id: crypto.randomUUID(),
+    type: "stack",
+    items: [t],
+    rule: t.rule,
+    isExpandable: !1,
+    isExpanded: !1,
+    desiredYLocation: O(t),
+    yLocation: O(t)
+  }));
+}
+function Pe(n, t, r = /* @__PURE__ */ new Set(), o = []) {
+  if (n.length === 0) return [];
+  const s = [...n].sort((T, k) => T.desiredYLocation - k.desiredYLocation), i = [...o], l = [];
+  let p = [], b = null, E = 0, a = 0, g = 0;
+  for (const T of s) {
+    const k = T.items[0], R = k.rule, m = O(k), y = Be(k, t), c = Math.max(m, g);
+    if (p.length === 0) {
+      p = [k], b = R, E = c, a = y, g = c + y;
+      continue;
+    }
+    const h = R === b, S = c <= E + a;
+    h && S ? (p.push(k), g = E + a) : (l.push(ie(p, r, i)), p = [k], b = R, E = c, a = y, g = c + y);
+  }
+  return p.length > 0 && l.push(ie(p, r, i)), l;
+}
+function Be(n, t) {
+  return le(n) ? t.get(n.id) ?? 0 : t.get(n.resourceId) ?? 0;
+}
+function ie(n, t, r) {
+  const o = [...n].sort((l, p) => O(l) - O(p)), s = Ye(o, r), i = s ? s.id : crypto.randomUUID();
+  return {
+    id: i,
+    type: "stack",
+    items: o,
+    rule: o[0].rule,
+    isExpandable: o.length > 1,
+    isExpanded: t.has(i),
+    desiredYLocation: O(o[0]),
+    yLocation: O(o[0])
+  };
+}
+function Ye(n, t) {
+  if (t.length === 0) return null;
+  const r = new Set(n.map(oe));
+  let o = null, s = 0, i = -1;
+  for (let l = 0; l < t.length; l++) {
+    const p = t[l], b = new Set(p.items.map(oe));
+    let E = 0;
+    for (const g of r)
+      b.has(g) && E++;
+    const a = E / Math.max(r.size, b.size);
+    a > s && (s = a, o = p, i = l);
+  }
+  return s >= 0.5 && i >= 0 ? (t.splice(i, 1), o) : null;
+}
+function $e(n, t) {
+  const r = n.map((o) => ({ ...o }));
+  for (let o = 1; o < r.length; o++) {
+    const s = r[o - 1], i = r[o], l = t[s.id]?.offsetHeight ?? 0, p = s.yLocation + l;
+    i.yLocation = Math.max(i.desiredYLocation, p);
+  }
+  return r;
+}
+const N = {
+  IDLE: "idle",
+  MEASURING: "measuring",
+  // Render findings invisibly to measure heights
+  BUNDLING: "bundling",
+  // Group findings into bundles based on proximity
+  MEASURING_BUNDLES: "measuring-bundles",
+  // Render bundles invisibly to measure heights
+  STACKING: "stacking",
+  // Create initial vertical stacks
+  MERGING: "merging",
+  // Merge overlapping stacks
+  POSITIONING: "positioning"
+  // Final absolute positioning calculation
+}, Fe = {
+  phase: N.IDLE,
+  bundles: [],
+  stacks: [],
+  previousStacks: [],
+  expandedStackIds: /* @__PURE__ */ new Set(),
+  itemHeights: /* @__PURE__ */ new Map(),
+  findingBlockMap: /* @__PURE__ */ new Map(),
+  findings: []
+}, ae = (n, t) => ({
+  ...n,
+  phase: N.MEASURING,
+  findings: t,
+  previousStacks: n.stacks,
+  // Cache previous stacks to prevent layout jumping
+  stacks: [],
+  bundles: []
+});
+function Ve(n, t) {
+  switch (t.type) {
+    case "FINDINGS_UPDATED":
+    case "ANIMATION_FINISHED":
+      return n.findings === t.findings ? n : ae(n, t.findings);
+    case "RECALCULATE":
+      return ae(n, n.findings);
+    case "HEIGHTS_MEASURED":
+      return { ...n, phase: N.BUNDLING, itemHeights: t.heights };
+    case "BLOCK_MAP_BUILT":
+      return { ...n, findingBlockMap: t.blockMap };
+    case "BUNDLES_CREATED":
+      return { ...n, phase: N.MEASURING_BUNDLES, bundles: t.bundles };
+    case "BUNDLE_HEIGHTS_MEASURED":
+      return {
+        ...n,
+        phase: N.STACKING,
+        itemHeights: new Map([...n.itemHeights, ...t.heights])
+      };
+    case "STACKS_CREATED":
+      return { ...n, phase: N.MERGING, stacks: t.stacks };
+    case "STACKS_MERGED":
+      return { ...n, phase: N.POSITIONING, stacks: t.stacks };
+    case "STACKS_POSITIONED":
+      return { ...n, phase: N.IDLE, stacks: t.stacks };
+    case "TOGGLE_STACK": {
+      const r = new Set(n.expandedStackIds);
+      return r.has(t.stackId) ? r.delete(t.stackId) : r.add(t.stackId), {
+        ...n,
+        expandedStackIds: r,
+        phase: N.STACKING,
+        previousStacks: n.stacks
+      };
+    }
+    default:
+      return n;
+  }
+}
+function He(n, t) {
+  let r;
+  return () => {
+    clearTimeout(r), r = setTimeout(n, t);
+  };
+}
+const en = ({
+  findings: n,
+  isAnimating: t = !1,
+  positioningConfig: r,
+  buildFindingBlockMap: o,
+  validationResultProps: s = {},
+  resultComponent: i,
+  collapseButtonComponent: l,
+  resizeDebounceDelay: p = 100,
+  className: b = "",
+  styles: E = {}
+}) => {
+  const [a, g] = he(Ve, Fe), T = i ?? Le, k = l, R = de({
+    findings: {},
+    bundles: {},
+    stacks: {}
+  }), m = Se(() => g({ type: "RECALCULATE" }), []);
+  w(() => {
+    t || g({ type: "ANIMATION_FINISHED", findings: n });
+  }, [t, n]), w(() => {
+    g({ type: "FINDINGS_UPDATED", findings: n }), g(o ? {
+      type: "BLOCK_MAP_BUILT",
+      blockMap: o(n)
+    } : { type: "BLOCK_MAP_BUILT", blockMap: /* @__PURE__ */ new Map() });
+  }, [n, o]), w(() => {
+    const c = He(m, p);
+    return window.addEventListener("resize", c), () => window.removeEventListener("resize", c);
+  }, [m, p]), Ie(() => {
+    const c = se(a.findings, r);
+    switch (a.phase) {
+      case N.MEASURING: {
+        const h = /* @__PURE__ */ new Map();
+        c.forEach((S) => {
+          const u = R.current.findings[S.resourceId];
+          u && h.set(S.resourceId, u.offsetHeight);
+        }), g({ type: "HEIGHTS_MEASURED", heights: h });
+        break;
+      }
+      case N.BUNDLING: {
+        const h = Ce(c, a.findingBlockMap);
+        g({ type: "BUNDLES_CREATED", bundles: h });
+        break;
+      }
+      case N.MEASURING_BUNDLES: {
+        const h = /* @__PURE__ */ new Map();
+        a.bundles.forEach((S) => {
+          const u = R.current.bundles[S.id];
+          u && h.set(S.id, u.offsetHeight);
+        }), g({ type: "BUNDLE_HEIGHTS_MEASURED", heights: h });
+        break;
+      }
+      case N.STACKING: {
+        const h = we(a.bundles), S = c.filter((L) => !h.has(L.resourceId)), u = Ue([...a.bundles, ...S]);
+        g({ type: "STACKS_CREATED", stacks: u });
+        break;
+      }
+      case N.MERGING: {
+        const h = Pe(
+          a.stacks,
+          a.itemHeights,
+          a.expandedStackIds,
+          a.previousStacks
+        );
+        g({ type: "STACKS_MERGED", stacks: h });
+        break;
+      }
+      case N.POSITIONING: {
+        const h = $e(a.stacks, R.current.stacks);
+        g({ type: "STACKS_POSITIONED", stacks: h });
+        break;
+      }
+    }
+  }, [
+    a.phase,
+    a.findings,
+    a.bundles,
+    a.stacks,
+    a.findingBlockMap,
+    a.itemHeights,
+    a.expandedStackIds,
+    a.previousStacks,
+    r
+  ]);
+  const y = {
+    position: "absolute",
+    visibility: "hidden",
+    pointerEvents: "none"
+  };
+  return /* @__PURE__ */ d.jsxs(
+    "section",
+    {
+      className: `${E.container ?? ""} ${b}`,
+      tabIndex: -1,
+      "data-testid": "validation-results-summary",
+      children: [
+        a.phase === N.MEASURING && se(a.findings, r).map((c) => /* @__PURE__ */ d.jsx(
+          "div",
+          {
+            ref: (h) => {
+              R.current.findings[c.resourceId] = h;
+            },
+            style: y,
+            children: /* @__PURE__ */ d.jsx(
+              T,
+              {
+                ...s,
+                findings: [c],
+                onRetrigger: m
+              }
+            )
+          },
+          c.resourceId
+        )),
+        a.phase === N.MEASURING_BUNDLES && a.bundles.map((c) => /* @__PURE__ */ d.jsx(
+          "div",
+          {
+            className: E.comment ?? "",
+            ref: (h) => {
+              R.current.bundles[c.id] = h;
+            },
+            style: y,
+            children: /* @__PURE__ */ d.jsx(
+              T,
+              {
+                ...s,
+                findings: c.findings,
+                onRetrigger: m,
+                isBundle: !0
+              }
+            )
+          },
+          c.id
+        )),
+        a.stacks.map((c) => {
+          const h = c.items.length > 1, S = c.items.flatMap(
+            (u) => "type" in u && u.type === "bundle" ? u.findings : [u]
+          );
+          return /* @__PURE__ */ d.jsx(
+            "div",
+            {
+              "data-testid": `comment-item-${c.id}`,
+              className: E.comment ?? "",
+              ref: (u) => {
+                R.current.stacks[c.id] = u;
+              },
+              style: { top: `${c.yLocation}px`, position: "absolute" },
+              children: h && !c.isExpanded ? (
+                // Collapsed stack: show count and render hidden items for measurement
+                /* @__PURE__ */ d.jsxs(d.Fragment, { children: [
+                  c.items.map((u) => "type" in u && u.type === "bundle" ? /* @__PURE__ */ d.jsx(
+                    "div",
+                    {
+                      ref: (_) => {
+                        R.current.bundles[u.id] = _;
+                      },
+                      style: y,
+                      children: /* @__PURE__ */ d.jsx(
+                        T,
+                        {
+                          ...s,
+                          findings: u.findings,
+                          onRetrigger: m,
+                          isBundle: !0
+                        }
+                      )
+                    },
+                    u.id
+                  ) : /* @__PURE__ */ d.jsx(
+                    "div",
+                    {
+                      ref: (_) => {
+                        R.current.findings[u.resourceId] = _;
+                      },
+                      style: y,
+                      children: /* @__PURE__ */ d.jsx(
+                        T,
+                        {
+                          ...s,
+                          findings: [u],
+                          onRetrigger: m
+                        }
+                      )
+                    },
+                    u.resourceId
+                  )),
+                  /* @__PURE__ */ d.jsx(
+                    T,
+                    {
+                      ...s,
+                      variant: "stack",
+                      findings: S,
+                      stackAmount: c.items.length,
+                      stackIsExpanded: !1,
+                      stackOnToggle: () => g({ type: "TOGGLE_STACK", stackId: c.id }),
+                      onRetrigger: m
+                    }
+                  )
+                ] })
+              ) : (
+                // Single item or expanded stack: show individual items
+                /* @__PURE__ */ d.jsxs(d.Fragment, { children: [
+                  c.items.map((u) => "type" in u && u.type === "bundle" ? /* @__PURE__ */ d.jsx(
+                    "div",
+                    {
+                      ref: (_) => {
+                        R.current.bundles[u.id] = _;
+                      },
+                      className: c.isExpanded ? E.findingInExpandedStack : void 0,
+                      children: /* @__PURE__ */ d.jsx(
+                        T,
+                        {
+                          ...s,
+                          findings: u.findings,
+                          onRetrigger: m,
+                          isBundle: !0
+                        }
+                      )
+                    },
+                    u.id
+                  ) : /* @__PURE__ */ d.jsx(
+                    "div",
+                    {
+                      ref: (_) => {
+                        R.current.findings[u.resourceId] = _;
+                      },
+                      className: c.isExpanded ? E.findingInExpandedStack : void 0,
+                      children: /* @__PURE__ */ d.jsx(
+                        T,
+                        {
+                          ...s,
+                          findings: [u],
+                          onRetrigger: m
+                        }
+                      )
+                    },
+                    u.resourceId
+                  )),
+                  h && c.isExpanded && k && /* @__PURE__ */ d.jsx(
+                    k,
+                    {
+                      onClick: () => g({ type: "TOGGLE_STACK", stackId: c.id })
+                    }
+                  ),
+                  h && c.isExpanded && !k && /* @__PURE__ */ d.jsx("div", { children: /* @__PURE__ */ d.jsx("button", { onClick: () => g({ type: "TOGGLE_STACK", stackId: c.id }), children: s.labels?.toggleStackClosed ?? "Collapse" }) })
+                ] })
+              )
+            },
+            c.id
+          );
+        })
+      ]
+    }
+  );
+};
+export {
+  Oe as BUNDLEABLE_RULES,
+  ue as ValidationContext,
+  Ze as ValidationProvider,
+  Le as ValidationResult,
+  en as ValidationResultSummary,
+  Ge as byIncreasingDesiredYLocation,
+  Me as calculateDesiredYLocation,
+  Ce as computeBundles,
+  Ue as createInitialStacksFromItems,
+  we as getBundledFindingIds,
+  le as isBundle,
+  De as makePositionedFinding,
+  se as makePositionedFindings,
+  Pe as mergeOverlappingStacksWithBundles,
+  $e as positionStacksWithBundles,
+  xe as useTiptapValidation,
+  Ne as useValidation,
+  Qe as useValidationContext
+};