Expandable And Linkified Text Agent Skill

Expandable text, and tappable spans inside it

Two features that read as one and share no parts: clamping to N lines with a more/less affordance is

maxLines plus onTextLayout { hasVisualOverflow }; tappable substrings are buildAnnotatedString

plus pushStringAnnotation, hit-tested by character offset. They compete for the same tap, so

decide what a tap on the body means before writing either.

Clamping on measured overflow

Only the layout pass knows whether the text overflows — the same string wraps differently per

width, font, text scale and translation. Ask it, and re-clamp by hand so the affordance is not

itself truncated:

// adapted: names shortened; the source's runCatching if/else (which re-called getLineEnd on the
// success branch) folded into getOrDefault, and its Character.isWhitespace(it) into it.isWhitespace()
var isExpanded by remember { mutableStateOf(false) }
var clickable by remember { mutableStateOf(false) }
var lastCharIndex by remember { mutableIntStateOf(0) }

Box(Modifier.clickable { isExpanded = !isExpanded }) {   // the only write to isExpanded
    Text(
        text = buildAnnotatedString {
            if (clickable) {
                if (isExpanded) {
                    append(text)
                    withStyle(showLessStyle) { append(showLessText) }
                } else {
                    val adjusted = text.substring(startIndex = 0, endIndex = lastCharIndex)
                        .dropLast(showMoreText.length)
                        .dropLastWhile { it.isWhitespace() || it == '.' }
                    append(adjusted)
                    withStyle(showMoreStyle) { append(showMoreText) }
                }
            } else {
                append(text)          // no overflow: no affordance at all
            }
        },
        maxLines = if (isExpanded) Int.MAX_VALUE else collapsedMaxLine,
        onTextLayout = { result ->
            if (!isExpanded && result.hasVisualOverflow) {
                clickable = true
                lastCharIndex = runCatching { result.getLineEnd(collapsedMaxLine - 1) }
                    .getOrDefault(text.length - 1)
            }
        },
    )
}

maxLines does the visual clamp on the first frame; the string surgery only exists so the "more"

label fits *inside* those lines instead of being cut off with them.

Tappable spans

Tag the matches while building the string, then resolve a tap to a character offset and ask the

string what is annotated there:

// adapted: tag constants named, the two per-kind branches folded into one append
val timeRegex = Regex("""(\d+):(\d+)(?::(\d+))?""")
val urlRegex = Regex("""https?://\S+""")
val combined = Regex("${timeRegex.pattern}|${urlRegex.pattern}")
// walk combined.findAll(text): append the gap before each match, then the match itself
val tag = if (timeRegex.matches(match.value)) TAG_TIME else TAG_URL
builder.withStyle(linkStyle) {
    pushStringAnnotation(tag, match.value); append(match.value); pop()
}

Modifier.pointerInput(Unit) {
    detectTapGestures { offset ->
        val position = layoutResult?.getOffsetForPosition(offset) ?: return@detectTapGestures
        annotated.getStringAnnotations(start = position, end = position)
            .firstOrNull { it.tag.startsWith(TAG_PREFIX) }
            ?.let { onSpanClick(it.tag, it.item) }
    }
}

A timestamp span carries its own raw text ("1:02:33"), so the click handler — not the text

component — decides what it means: parse it and seek, or ignore it on a screen with no player.

Traps

Overflow is a measurement, not a length. A "longer than 120 characters" heuristic is wrong at

every width but the one you tested, and again at a larger text scale. hasVisualOverflow arrives in

a layout callback: the clamp is right on frame one, the "more" label appears on the next.

The affordance has to be cut out of the string. getLineEnd(lastVisibleLine) gives the last

character that fits; appending "… more" pushes the line over and the label is what gets truncated.

Drop as many characters as the label costs, then trim trailing spaces and stops.

Latched flags outlive their text. remember { mutableStateOf(false) } with no key keeps

clickable and lastCharIndex from the previous string when the composable is reused for another

item — a short description then shows "more" and clamps at an index from a longer one. Key on text.

A line index past the last laid-out line is not valid. The callback fires for every layout the

text goes through, including ones with fewer lines than the clamp, so getLineEnd(n) needs a

guard and a fallback rather than an optimistic call.

One tap, two handlers, and the outer one loses. The container clickable in the first excerpt

*is* the entire expand affordance — the "more" label is painted text, not a button — so adding the

second excerpt's detectTapGestures to the same component means the text consumes the tap first:

tapping the body silently stops expanding, and only over the text. Pick one shape per component —

the whole block toggles and carries no spans, or the body owns the spans and a separate label toggles.

Hit-testing snaps to the nearest character. getOffsetForPosition returns the closest offset,

not "inside a glyph", so a tap in the blank space past the end of a line resolves onto the span that

ends it.

Build the annotated string inside remember(text). Otherwise the regex scan runs on every

recomposition — and since findAll is a lazy sequence, calling count() on it inside the loop over

its own matches re-scans the whole text once per match.

JDK character helpers are not multiplatform. Character.isWhitespace(c) compiles in shared code

only while every target is JVM-family; c.isWhitespace() is the Kotlin one and always works.

Verifying it

# every overflow-driven clamp in the codebase (a component with none is guessing at lengths)
grep -rn "hasVisualOverflow" --include="*.kt" .

# annotations written but never read, or read but never written, is a dead affordance
grep -rln "pushStringAnnotation" --include="*.kt" .
grep -rln "getStringAnnotations" --include="*.kt" .

# JDK-only character helpers sitting in shared source
find . -path "*/commonMain/*" -name "*.kt" -exec grep -ln "Character\." {} +

Then, by hand: shrink the window until a two-line string wraps to four and check that "more"

appears *and* that the text before it still ends mid-sentence rather than mid-label; expand and

collapse twice (a latched flag shows up on the second collapse); tap a link and confirm the block

did not also expand.