@estiva-app/ui 0.68.0 → 0.69.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estiva-app/ui",
-  "version": "0.68.0",
+  "version": "0.69.1",
   "description": "Estiva's design tokens (the contract) and a small set of primitives (a convenience) for every Estiva app.",
   "type": "module",
   "license": "MIT",

package/registry.json

@@ -4,7 +4,7 @@
     "kind": "package",
     "repo": "estiva-ui",
     "package": "@estiva-app/ui",
-    "packageVersion": "0.68.0",
+    "packageVersion": "0.69.1",
     "exports": 162,
     "typeExports": 152,
     "files": null

package/src/LinkChips.mdx

@@ -21,10 +21,10 @@ recognise, or has not answered for yet, stays text.
 
 - A document that is only read → **RichText**, whose text already says which
   runs are chips.
-- An editor with a link mark (a composer's Link button) → its links are the
-  author's words, not chips. Turn the link mark off in a document editor
-  (`StarterKit.configure({ link: false })`), or URLs are linked before this
-  sees them.
+- A link on words (a composer's Link button, a URL pasted over selected
+  words) → it stays the author's link, not a chip. A link whose text is its
+  own URL (an autolink, a link mark's paste rule) is that URL, and becomes
+  its chip.
 
 ## How
 
@@ -47,10 +47,13 @@ LinkChips.configure({
   never turns into a chip while it is being typed. A pasted URL is whole: it
   is asked about and becomes its chip at once, with the caret at its end, so
   **ReferenceMenu** can open its menu.
-- A URL in code, in a code block, or under a link mark stays text.
-- Each URL is asked about once, and one editor asks about at most `limit`
+- A URL in code or in a code block stays text, and so does a link on words.
+- Each URL is asked about once while the document holds it, and one editor
+  asks about at most `limit` of the URLs it holds unanswered at a time
   (24 by default), the first ones: an answer can cost the app a query.
-- Making a chip is not an undo step: undo takes back what was typed.
+- A pasted URL's chip is its own undo step: undo gives the URL back, and a
+  second undo takes the paste away. A typed URL's chip is not a step: undo
+  takes back what was typed.
 
 ## What it owns
 

package/src/LinkChips.test.tsx

@@ -83,6 +83,23 @@ describe('LinkChips', () => {
     expect(asked).toEqual([['https://a.example/1', 'https://a.example/2']])
   })
 
+  it('counts its limit over the URLs the document holds: a message box keeps asking after the last message is sent', async () => {
+    const asked: string[][] = []
+    editor = new Editor({
+      extensions: [
+        StarterKit.configure({ link: false }),
+        BlockId,
+        ReferenceNode,
+        LinkChips.configure({ referenceOf: () => undefined, ask: (urls) => void asked.push(urls), limit: 2 }),
+      ],
+      content: para({ type: 'text', text: 'https://a.example/1 https://a.example/2 ' }),
+    })
+    await tick()
+    // Sent: the box is emptied, and the next message's links are asked about.
+    editor.commands.setContent(para({ type: 'text', text: 'https://a.example/3 ' }))
+    expect(asked).toEqual([['https://a.example/1', 'https://a.example/2'], ['https://a.example/3']])
+  })
+
   it('turns the URL into its chip once the answer comes back', async () => {
     const known = new Map<string, string>()
     const ed = make(para({ type: 'text', text: `See ${URL_} now` }), known)
@@ -175,4 +192,47 @@ describe('LinkChips', () => {
     await tick()
     expect(ed.getText()).toBe(`${URL_} `)
   })
+
+  it('makes a pasted URL its chip as its own undo step: undo gives the URL back, then takes the paste away', async () => {
+    const ed = make(para({ type: 'text', text: 'See ' }), new Map([[URL_, V]]))
+    await tick()
+    ed.view.dispatch(ed.state.tr.setSelection(TextSelection.create(ed.state.doc, ed.state.doc.content.size - 1)))
+    ed.view.pasteText(URL_, new Event('paste') as ClipboardEvent)
+    expect(inline(ed).map((n) => n.type)).toEqual(['text', 'reference'])
+    ed.commands.undo()
+    expect(inline(ed)).toEqual([{ type: 'text', text: `See ${URL_}` }])
+    ed.commands.undo()
+    expect(inline(ed)).toEqual([{ type: 'text', text: 'See ' }])
+  })
+
+  it('makes a pasted URL answered later its own undo step too', async () => {
+    const known = new Map<string, string>()
+    const ed = make(para({ type: 'text', text: 'See ' }), known)
+    await tick()
+    ed.view.dispatch(ed.state.tr.setSelection(TextSelection.create(ed.state.doc, ed.state.doc.content.size - 1)))
+    ed.view.pasteText(URL_, new Event('paste') as ClipboardEvent)
+    expect(inline(ed)).toEqual([{ type: 'text', text: `See ${URL_}` }])
+    known.set(URL_, V)
+    refreshLinkChips(ed)
+    expect(inline(ed)[1].type).toBe('reference')
+    ed.commands.undo()
+    expect(inline(ed)).toEqual([{ type: 'text', text: `See ${URL_}` }])
+  })
+
+  it('turns a link whose text is its own URL into its chip, and leaves a link on words', async () => {
+    editor = new Editor({
+      // A composer's link mark: an autolink, or its paste rule, links a bare URL to itself.
+      extensions: [StarterKit.configure({ link: { autolink: false, openOnClick: false } }), BlockId, ReferenceNode, LinkChips.configure({ referenceOf: (url) => (url === URL_ ? V : undefined), ask: null })],
+      content: para(
+        { type: 'text', text: URL_, marks: [{ type: 'link', attrs: { href: URL_ } }, { type: 'bold' }] },
+        { type: 'text', text: ' and ' },
+        { type: 'text', text: 'the words', marks: [{ type: 'link', attrs: { href: URL_ } }] },
+      ),
+    })
+    await tick()
+    const [chip, , words] = inline(editor)
+    expect(chip.type).toBe('reference')
+    expect(chip.attrs).toMatchObject({ uri: V, href: URL_, marks: ['bold'] })
+    expect(words).toMatchObject({ type: 'text', text: 'the words' })
+  })
 })

package/src/LinkChips.ts

@@ -19,6 +19,7 @@
  * still at its end — where `ReferenceMenu` opens its menu.
  */
 import { Extension, type Editor } from '@tiptap/core'
+import { closeHistory } from '@tiptap/pm/history'
 import type { Node as PmNode } from '@tiptap/pm/model'
 import { Plugin, PluginKey, type EditorState, type Selection, type Transaction } from '@tiptap/pm/state'
 
@@ -111,9 +112,14 @@ export function findLinkChips(doc: PmNode, selection: Selection | null, referenc
       return false
     }
     if (!node.isText || !node.text) return true
-    // A URL in code is literal, and one already linked on purpose is the link's.
-    if (node.marks.some((m) => m.type.spec.code || m.type.name === 'code' || m.type.name === 'link')) return false
-    for (const run of urlRuns(node.text)) {
+    // A URL in code is literal.
+    if (node.marks.some((m) => m.type.spec.code || m.type.name === 'code')) return false
+    // A link on words is the link's. A link whose text is its own URL — an editor's autolink, or its paste rule — is
+    // that URL, as a document reads one (protocol's `inlineToEditor`): its chip, with the link mark left behind.
+    const link = node.marks.find((m) => m.type.name === 'link')
+    if (link && !(link.attrs.href === node.text && /^https?:\/\//.test(node.text))) return false
+    const runs = link ? [{ url: node.text, from: 0, to: node.text.length, end: node.text.length }] : urlRuns(node.text)
+    for (const run of runs) {
       const from = pos + run.from
       const to = pos + run.to
       // Being typed or selected: the caret inside it or at its end (`https://a.` is still being typed), or a
@@ -123,7 +129,7 @@ export function findLinkChips(doc: PmNode, selection: Selection | null, referenc
       const typing = selection && selection.to > from && selection.from <= pos + run.end
       if (typing && !(selection.empty && wasPasted)) continue
       const uri = referenceOf?.(run.url)
-      if (uri) found.chips.push({ from, to, url: run.url, uri, marks: node.marks.map((m) => m.type.name), pasted: wasPasted })
+      if (uri) found.chips.push({ from, to, url: run.url, uri, marks: node.marks.filter((m) => m !== link).map((m) => m.type.name), pasted: wasPasted })
       else open.add(run.url)
     }
     return false
@@ -145,9 +151,12 @@ function apply(state: EditorState, found: Found): Transaction | null {
   for (const chip of [...found.chips].reverse()) {
     tr.replaceWith(chip.from, chip.to, type.create({ uri: chip.uri, href: chip.url, marks: chip.marks }))
   }
-  // Not a step of the person's: undo takes back what they typed, not the chip it became.
   // Whether a pasted URL became its chip: `ReferenceMenu` opens on that one, never on a URL typed by hand.
-  return tr.setMeta('addToHistory', false).setMeta(CHIPS_MADE, { pasted: found.chips.some((chip) => chip.pasted) })
+  const pasted = found.chips.some((chip) => chip.pasted)
+  tr.setMeta(CHIPS_MADE, { pasted })
+  // A pasted URL's chip is its own undo step, so Ctrl+Z gives the URL back rather than taking the paste away (OPT-19,
+  // as Peek's pasted link did). Any other chip is not a step of the person's: undo takes back what they typed.
+  return pasted ? closeHistory(tr) : tr.setMeta('addToHistory', false)
 }
 
 /**
@@ -206,6 +215,10 @@ export const LinkChips = Extension.create<LinkChipsOptions>({
           const look = (state: EditorState) => {
             if (!options.ask) return
             const { open } = findLinkChips(state.doc, state.selection, options.referenceOf, key.getState(state)?.pasted)
+            // The limit counts the URLs the document still holds unanswered: a message box lives across many messages,
+            // and one that counted every URL it was ever asked would stop making chips after a day's links (OPT-19).
+            const waiting = new Set(open)
+            for (const url of asked) if (!waiting.has(url)) asked.delete(url)
             const fresh = open.filter((url) => !asked.has(url)).slice(0, Math.max(0, options.limit - asked.size))
             if (!fresh.length) return
             for (const url of fresh) asked.add(url)