@linto-ai/transcript-ui-ui 0.9.0

package/src/utils/shadowAwareSelection.ts

@@ -0,0 +1,52 @@
+/**
+ * Chrome's document.getSelection() does not cross the shadow boundary: inside
+ * a shadow root the anchor/focus nodes clamp to the host. These helpers read
+ * the selection through ShadowRoot.getSelection() (Blink) or
+ * Selection.getComposedRanges() (standard) before falling back to the
+ * document selection (which crosses the boundary in Firefox).
+ */
+
+/** Live, mutable Selection for `node`'s root, shadow-aware. */
+export function getShadowAwareSelection(
+  node: Node | null | undefined,
+): Selection | null {
+  if (!node) return null
+  const root = node.getRootNode()
+  if (root instanceof ShadowRoot) {
+    const shadowSelection = getShadowRootSelection(root)
+    if (shadowSelection) return shadowSelection
+  }
+  return node.ownerDocument?.getSelection() ?? null
+}
+
+/** Focus point of the current selection, or null when there is none. Covers
+ *  browsers without ShadowRoot.getSelection() through the read-only
+ *  getComposedRanges() path. */
+export function getSelectionFocus(
+  container: HTMLElement,
+): { node: Node; offset: number } | null {
+  const root = container.getRootNode()
+  if (root instanceof ShadowRoot) {
+    const shadowSelection = getShadowRootSelection(root)
+    if (shadowSelection?.focusNode) {
+      return {
+        node: shadowSelection.focusNode,
+        offset: shadowSelection.focusOffset,
+      }
+    }
+    const range = container.ownerDocument
+      .getSelection()
+      ?.getComposedRanges?.({ shadowRoots: [root] })[0]
+    if (range) return { node: range.endContainer, offset: range.endOffset }
+  }
+  const selection = container.ownerDocument.getSelection()
+  if (!selection?.focusNode) return null
+  return { node: selection.focusNode, offset: selection.focusOffset }
+}
+
+// Blink-only API, absent from lib.dom.
+function getShadowRootSelection(root: ShadowRoot): Selection | null {
+  return (
+    (root as { getSelection?: () => Selection | null }).getSelection?.() ?? null
+  )
+}

package/src/utils/test/computeInitials.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "bun:test"
+import { computeInitials } from "../computeInitials"
+
+describe("computeInitials", () => {
+  it("takes the first letter of the first two words, uppercased", () => {
+    expect(computeInitials("Marie Dupont")).toBe("MD")
+    expect(computeInitials("marie dupont durand")).toBe("MD")
+  })
+
+  it("handles single-word and empty names", () => {
+    expect(computeInitials("marie")).toBe("M")
+    expect(computeInitials("  ")).toBe("?")
+    expect(computeInitials("")).toBe("?")
+  })
+})

package/src/utils/test/computeTextOffsetInContainer.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "bun:test"
+import { computeTextOffsetInContainer } from "../computeTextOffsetInContainer"
+
+// Minimal DOM-shaped stubs: the walk only reads nodeType, nodeValue and
+// childNodes, so plain objects are enough (bun test has no DOM).
+interface StubNode {
+  nodeType: number
+  nodeValue: string | null
+  childNodes: StubNode[]
+}
+
+function text(value: string): StubNode {
+  return { nodeType: 3, nodeValue: value, childNodes: [] }
+}
+
+function element(...children: StubNode[]): StubNode {
+  return { nodeType: 1, nodeValue: null, childNodes: children }
+}
+
+function offset(container: StubNode, target: StubNode, local: number): number {
+  return computeTextOffsetInContainer(
+    container as unknown as Node,
+    target as unknown as Node,
+    local,
+  )
+}
+
+describe("computeTextOffsetInContainer", () => {
+  // Mirrors a read-view turn: <p><span>Bonjour</span> <span>tout</span> <span>le</span></p>
+  const words = [text("Bonjour"), text("tout"), text("le")]
+  const spans = words.map((w) => element(w))
+  const container = element(spans[0]!, text(" "), spans[1]!, text(" "), spans[2]!)
+
+  it("offsets inside the first text node are the local offset", () => {
+    expect(offset(container, words[0]!, 3)).toBe(3)
+  })
+
+  it("offsets in later words include preceding words and separators", () => {
+    // "Bonjour tout le" — "tout" starts at 8, "le" at 13
+    expect(offset(container, words[1]!, 0)).toBe(8)
+    expect(offset(container, words[1]!, 4)).toBe(12)
+    expect(offset(container, words[2]!, 2)).toBe(15)
+  })
+
+  it("resolves an element position to the text before its Nth child", () => {
+    // Caret "before child 2" of the container = before the second span
+    expect(offset(container, container, 2)).toBe(8)
+  })
+
+  it("resolves an element position past the last child to the full length", () => {
+    expect(offset(container, container, container.childNodes.length)).toBe(15)
+  })
+})