@devaccel-labs/comment-service 0.7.0 → 0.9.0

package/dist/chunks/chunk-KKE43QYT.js

@@ -0,0 +1,468 @@
+// ../react/dist/runtime-version.js
+var runtimeVersion = 1;
+
+// ../core/dist/resolve.js
+var norm = (value) => (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+var labelOf = (value) => norm(value.accName) || norm(value.text);
+function isAncestorPath(ancestor, descendant) {
+  if (!ancestor || ancestor === descendant)
+    return false;
+  return descendant.startsWith(`${ancestor}/`);
+}
+function dropAncestors(candidates) {
+  return candidates.filter((candidate) => !candidates.some((other) => isAncestorPath(candidate.path, other.path)));
+}
+function finish(status, candidate, score, reason) {
+  if (candidate && !candidate.visible && (status === "pinned" || status === "drifted")) {
+    return { status: "hidden", key: candidate.key, score, reason: `hidden: ${reason}` };
+  }
+  return { status, key: candidate?.key ?? null, score, reason };
+}
+function sameExplicit(anchor, candidate) {
+  return anchor.explicit.some((expected) => candidate.explicit.some((actual) => actual.attr === expected.attr && actual.value === expected.value));
+}
+function sameComponent(anchor, candidate, requireFile) {
+  if (!anchor.component || !candidate.component)
+    return false;
+  if (anchor.component.name !== candidate.component.name)
+    return false;
+  if (requireFile) {
+    return Boolean(anchor.component.file) && anchor.component.file === candidate.component.file;
+  }
+  return true;
+}
+function sameRole(anchor, candidate) {
+  if (!anchor.role || !candidate.role)
+    return !anchor.role;
+  return anchor.role === candidate.role;
+}
+function sameLabel(anchor, candidate) {
+  const expected = labelOf(anchor);
+  if (!expected)
+    return false;
+  return expected === labelOf(candidate);
+}
+function unavailable(reason) {
+  return { status: "unavailable", key: null, score: 0, reason };
+}
+function resolveAnchor(anchor, candidates) {
+  const pool = candidates.filter((candidate) => candidate.route === anchor.route);
+  if (anchor.explicit.length > 0) {
+    const hits = dropAncestors(pool.filter((candidate) => sameExplicit(anchor, candidate)));
+    if (hits.length === 1)
+      return finish("pinned", hits[0], 100, "explicit id");
+    if (hits.length > 1) {
+      return { status: "ambiguous", key: null, score: 40, reason: "explicit id matches more than one element" };
+    }
+  }
+  const componentScoped = pool.filter((candidate) => sameComponent(anchor, candidate, true) && sameRole(anchor, candidate));
+  const labeled = dropAncestors(componentScoped.filter((candidate) => sameLabel(anchor, candidate)));
+  if (labeled.length === 1)
+    return finish("pinned", labeled[0], 100, "component file, role, and label");
+  if (labeled.length > 1) {
+    return {
+      status: "ambiguous",
+      key: null,
+      score: 50,
+      reason: "several elements in this component share the same label"
+    };
+  }
+  if (anchor.component?.file && anchor.component.name) {
+    const roots = pool.filter((candidate) => candidate.componentRoot && sameComponent(anchor, candidate, true));
+    if (roots.length === 1) {
+      const root = roots[0];
+      const inside = dropAncestors(pool.filter((candidate) => (candidate.path === root.path || isAncestorPath(root.path, candidate.path)) && sameRole(anchor, candidate)));
+      if (inside.length === 1) {
+        return finish("drifted", inside[0], 70, "same component and role, label changed");
+      }
+      const where2 = anchor.overlay ? ` Last seen in ${anchor.overlay.role} \u201C${anchor.overlay.name}\u201D.` : "";
+      return unavailable(`label no longer matches inside ${anchor.component.name}.${where2}`.trim());
+    }
+    if (roots.length === 0) {
+      const where2 = anchor.overlay ? ` Last seen in ${anchor.overlay.role} \u201C${anchor.overlay.name}\u201D.` : "";
+      return unavailable(`component ${anchor.component.name} is not on ${anchor.route}.${where2}`.trim());
+    }
+    return {
+      status: "ambiguous",
+      key: null,
+      score: 45,
+      reason: "component is on the page more than once and the label no longer matches"
+    };
+  }
+  if (anchor.component?.name) {
+    const named = dropAncestors(pool.filter((candidate) => sameComponent(anchor, candidate, false) && sameRole(anchor, candidate) && sameLabel(anchor, candidate)));
+    if (named.length === 1)
+      return finish("pinned", named[0], 80, "component name and label");
+    if (named.length > 1) {
+      return { status: "ambiguous", key: null, score: 40, reason: "component name and label match more than one element" };
+    }
+  }
+  const where = anchor.overlay ? ` It was inside ${anchor.overlay.role} \u201C${anchor.overlay.name}\u201D.` : "";
+  return unavailable(`no element on ${anchor.route} matches this comment.${where}`.trim());
+}
+
+// ../react/dist/capture.js
+var EXPLICIT = ["data-cs-anchor", "data-testid", "data-test", "id"];
+function clip(value, max = 160) {
+  const text = (value ?? "").replace(/\s+/g, " ").trim();
+  return text ? text.slice(0, max) : null;
+}
+function usableExplicit(attr, value) {
+  if (!value || value.length > 200)
+    return false;
+  if (attr === "id" || attr === "data-testid" || attr === "data-test") {
+    if (value.startsWith(":") || value.startsWith("radix-") || value.startsWith("headlessui-"))
+      return false;
+  }
+  return true;
+}
+function domPath(element) {
+  const parts = [];
+  let current = element;
+  while (current && current !== current.ownerDocument.body) {
+    const parent = current.parentElement;
+    if (!parent)
+      break;
+    parts.push([...parent.children].indexOf(current));
+    current = parent;
+  }
+  return parts.reverse().join("/");
+}
+function intraPath(element, owner) {
+  if (!owner || owner === element)
+    return element === owner ? element.tagName.toLowerCase() : null;
+  const parts = [];
+  let current = element;
+  while (current && current !== owner) {
+    const parent = current.parentElement;
+    if (!parent)
+      break;
+    const same = [...parent.children].filter((child) => child.tagName === current.tagName);
+    const index = same.indexOf(current);
+    const tag = current.tagName.toLowerCase();
+    parts.push(same.length > 1 ? `${tag}[${index}]` : tag);
+    current = parent;
+  }
+  return parts.reverse().join("/") || null;
+}
+function elementText(element) {
+  let direct = "";
+  for (const node of element.childNodes) {
+    if (node.nodeType === Node.TEXT_NODE)
+      direct += node.textContent ?? "";
+  }
+  const own = clip(direct);
+  if (own)
+    return own;
+  const full = clip(element.textContent, 80);
+  if (full && element.children.length <= 3)
+    return full;
+  return null;
+}
+function labelFor(element) {
+  const aria = element.getAttribute("aria-label");
+  if (aria)
+    return clip(aria);
+  const labelledby = element.getAttribute("aria-labelledby");
+  if (labelledby) {
+    const text = labelledby.split(/\s+/).map((id) => element.ownerDocument.getElementById(id)?.textContent ?? "").join(" ");
+    const clipped = clip(text);
+    if (clipped)
+      return clipped;
+  }
+  if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+    if (element.labels?.[0]?.textContent)
+      return clip(element.labels[0].textContent);
+    if (element.placeholder)
+      return clip(element.placeholder);
+  }
+  if (element instanceof HTMLImageElement && element.alt)
+    return clip(element.alt);
+  return elementText(element);
+}
+function roleFor(element) {
+  const explicit = element.getAttribute("role");
+  if (explicit)
+    return explicit;
+  const tag = element.tagName.toLowerCase();
+  if (tag === "button")
+    return "button";
+  if (tag === "a" && element.hasAttribute("href"))
+    return "link";
+  if (tag === "textarea")
+    return "textbox";
+  if (tag === "select")
+    return "combobox";
+  if (tag === "dialog")
+    return "dialog";
+  if (/^h[1-6]$/.test(tag))
+    return "heading";
+  if (element instanceof HTMLInputElement)
+    return element.type === "checkbox" ? "checkbox" : "textbox";
+  return null;
+}
+function overlayFor(element) {
+  const node = element.closest("dialog,[role='dialog'],[role='alertdialog']");
+  if (!node)
+    return null;
+  const role = node.getAttribute("role") || (node.tagName === "DIALOG" ? "dialog" : "dialog");
+  return { role, name: labelFor(node) || "dialog" };
+}
+function fiberOf(element) {
+  const key2 = Object.keys(element).find((name) => name.startsWith("__reactFiber$") || name.startsWith("__reactInternalInstance$"));
+  return key2 ? element[key2] : void 0;
+}
+function fiberNames(element) {
+  const names = [];
+  let fiber = fiberOf(element);
+  for (let guard = 0; fiber && guard < 40; guard++) {
+    const type = fiber.type;
+    if (typeof type === "function") {
+      const fn = type;
+      const name = fn.displayName || fn.name;
+      if (name && !name.startsWith("_"))
+        names.push(name);
+    }
+    fiber = fiber.return ?? void 0;
+  }
+  return names.reverse();
+}
+function fiberStamps(element) {
+  const stamps = [];
+  let fiber = fiberOf(element);
+  for (let guard = 0; fiber && guard < 2e3; guard++) {
+    const props = fiber.memoizedProps;
+    const name = props && typeof props === "object" ? props["data-cs-cmp"] : void 0;
+    if (typeof name === "string" && name) {
+      const file = props?.["data-cs-file"];
+      stamps.push({ name, file: typeof file === "string" ? file : null });
+    }
+    fiber = fiber.return ?? void 0;
+  }
+  return stamps;
+}
+function bodyChild(element) {
+  let current = element;
+  while (current?.parentElement && current.parentElement !== current.ownerDocument.body)
+    current = current.parentElement;
+  return current?.parentElement ? current : null;
+}
+function obviouslyHidden(element) {
+  const dialog = element.closest("dialog");
+  if (dialog instanceof HTMLDialogElement && !dialog.open)
+    return true;
+  if (element.closest("[hidden]"))
+    return true;
+  let current = element;
+  while (current) {
+    if (current.getAttribute("aria-hidden") === "true")
+      return true;
+    current = current.parentElement;
+  }
+  return false;
+}
+function ownership(element) {
+  const stack = [];
+  let owner = null;
+  let current = element;
+  while (current) {
+    const name2 = current.getAttribute("data-cs-cmp");
+    if (name2) {
+      if (!owner)
+        owner = current;
+      stack.push(name2);
+    }
+    current = current.parentElement;
+  }
+  const top = bodyChild(element);
+  if (top && top !== element && (!owner || !top.contains(owner))) {
+    const stamps = fiberStamps(element);
+    if (stamps.length && (!owner || stamps[0].name !== owner.getAttribute("data-cs-cmp"))) {
+      return {
+        component: stamps[0],
+        stack: stamps.map((stamp) => stamp.name).reverse(),
+        componentRoot: false,
+        owner: top
+      };
+    }
+  }
+  if (owner) {
+    return {
+      component: { name: owner.getAttribute("data-cs-cmp") || "component", file: owner.getAttribute("data-cs-file") },
+      stack: stack.reverse(),
+      componentRoot: owner === element,
+      owner
+    };
+  }
+  const names = fiberNames(element);
+  const name = names.at(-1) ?? null;
+  return {
+    component: name ? { name, file: null } : null,
+    stack: names,
+    componentRoot: false,
+    owner: null
+  };
+}
+function candidateFromElement(element, route, key2) {
+  const owned = ownership(element);
+  const label = labelFor(element);
+  const explicit = EXPLICIT.flatMap((attr) => {
+    const value = element.getAttribute(attr);
+    return value && usableExplicit(attr, value) ? [{ attr, value }] : [];
+  });
+  return {
+    key: key2,
+    route,
+    visible: !obviouslyHidden(element),
+    path: domPath(element),
+    componentRoot: owned.componentRoot,
+    overlay: overlayFor(element),
+    explicit,
+    component: owned.component,
+    stack: owned.stack,
+    role: roleFor(element),
+    accName: label,
+    text: label,
+    tag: element.tagName.toLowerCase(),
+    intra: intraPath(element, owned.owner)
+  };
+}
+function captureAnchor(element, route = window.location.pathname) {
+  const candidate = candidateFromElement(element, route, "target");
+  return {
+    v: 1,
+    route,
+    overlay: candidate.overlay,
+    explicit: candidate.explicit,
+    component: candidate.component,
+    stack: candidate.stack,
+    role: candidate.role,
+    accName: candidate.accName,
+    text: candidate.text,
+    tag: candidate.tag,
+    intra: candidate.intra
+  };
+}
+function collectCandidates(route = window.location.pathname) {
+  const root = document.getElementById("cs-root");
+  const found = [];
+  const nodes = document.body?.querySelectorAll("*") ?? [];
+  let index = 0;
+  for (const element of nodes) {
+    if (root && (element === root || root.contains(element)))
+      continue;
+    const tag = element.tagName;
+    if (tag === "SCRIPT" || tag === "STYLE" || tag === "LINK" || tag === "META")
+      continue;
+    if (index > 8e3)
+      break;
+    found.push({ element, candidate: candidateFromElement(element, route, `e${index}`) });
+    index += 1;
+  }
+  return found;
+}
+function resolveInDocument(anchor, route = window.location.pathname) {
+  const found = collectCandidates(route);
+  const resolution = resolveAnchor(anchor, found.map((item) => item.candidate));
+  const element = found.find((item) => item.candidate.key === resolution.key)?.element ?? null;
+  return { resolution, element };
+}
+function elementAt(x, y) {
+  const root = document.getElementById("cs-root");
+  for (const element of document.elementsFromPoint(x, y)) {
+    if (element === document.body || element === document.documentElement)
+      continue;
+    if (root && (element === root || root.contains(element)))
+      continue;
+    const tag = element.tagName;
+    if (tag === "SCRIPT" || tag === "STYLE")
+      continue;
+    return element;
+  }
+  return null;
+}
+function describeElement(element) {
+  const name = ownership(element).component?.name;
+  const label = labelFor(element);
+  if (name && label)
+    return `${name} \u2014 ${label}`;
+  return name || label || element.tagName.toLowerCase();
+}
+
+// ../react/dist/handoff.js
+var key = "devaccel.comment.handoff";
+var ttl = 30 * 60 * 1e3;
+function readHandoff() {
+  try {
+    const value = JSON.parse(sessionStorage.getItem(key) ?? "null");
+    return value && Date.now() - value.at < ttl ? value : null;
+  } catch {
+    return null;
+  }
+}
+function write(value) {
+  try {
+    if (value.invite || value.thread)
+      sessionStorage.setItem(key, JSON.stringify(value));
+    else
+      sessionStorage.removeItem(key);
+  } catch {
+  }
+}
+function linkParams() {
+  const url = new URL(window.location.href);
+  const hash = new URLSearchParams(url.hash.slice(1));
+  return {
+    url,
+    hash,
+    invite: url.searchParams.get("cs-invite") ?? hash.get("cs-invite"),
+    thread: url.searchParams.get("cs-thread") ?? hash.get("cs-thread")
+  };
+}
+function captureHandoff() {
+  if (typeof window === "undefined")
+    return;
+  const { invite, thread } = linkParams();
+  if (!invite && !thread)
+    return;
+  write({ ...readHandoff(), ...invite ? { invite } : {}, ...thread ? { thread } : {}, at: Date.now() });
+}
+function dropHandoff(part) {
+  const current = readHandoff();
+  if (!current)
+    return;
+  const { [part]: _dropped, ...rest } = current;
+  write(rest);
+}
+function stripHandoffFromUrl() {
+  const { url, hash } = linkParams();
+  const inQuery = url.searchParams.has("cs-invite") || url.searchParams.has("cs-thread");
+  const inHash = hash.has("cs-invite") || hash.has("cs-thread");
+  if (!inQuery && !inHash)
+    return;
+  url.searchParams.delete("cs-invite");
+  url.searchParams.delete("cs-thread");
+  if (inHash)
+    url.hash = "";
+  history.replaceState(history.state, "", url);
+}
+function linkWith(href, name, value) {
+  const url = new URL(href, window.location.origin);
+  url.searchParams.delete("cs-invite");
+  url.searchParams.delete("cs-thread");
+  url.hash = `${name}=${encodeURIComponent(value)}`;
+  return url.toString();
+}
+
+export {
+  captureAnchor,
+  resolveInDocument,
+  elementAt,
+  describeElement,
+  readHandoff,
+  captureHandoff,
+  dropHandoff,
+  stripHandoffFromUrl,
+  linkWith,
+  runtimeVersion
+};