@estiva-app/ui 0.82.1 → 0.83.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,60 @@
1
+ import type { Meta, StoryObj } from '@storybook/react-vite'
2
+ import { EditorContent, useEditor } from '@tiptap/react'
3
+ import StarterKit from '@tiptap/starter-kit'
4
+ import { BlockId, ReferenceNode, type ReferenceViewProps } from './BlockNodes'
5
+ import { Card } from './Card'
6
+ import { InlineChip } from './InlineChip'
7
+ import { LinkPlaces } from './LinkPlaces'
8
+ import { richTextClassName } from './RichText'
9
+
10
+ /**
11
+ * Each link in a document is told where it sits, and the app draws it there:
12
+ * its chip in a sentence, its row alone on its line, its card in the row's
13
+ * place. Here the row and card are stand-in boxes naming the place; the real
14
+ * ones are the app's, which knows how to resolve what the link points at.
15
+ */
16
+ const meta = {
17
+ title: 'Primitives/LinkPlaces',
18
+ parameters: { layout: 'padded' },
19
+ } satisfies Meta
20
+
21
+ export default meta
22
+ type Story = StoryObj
23
+
24
+ const ref = (uri: string, embed?: string) => ({ type: 'reference', attrs: { uri, ...(embed ? { embed } : {}) } })
25
+
26
+ /** A stand-in for the app's drawing of a link, by its place. */
27
+ function Placed({ uri, place = 'chip' }: ReferenceViewProps) {
28
+ const name = uri.endsWith('one') ? 'Item one' : uri.endsWith('two') ? 'Item two' : 'Item three'
29
+ if (place === 'chip') return <InlineChip>{name}</InlineChip>
30
+ return (
31
+ <Card fill="inset" className={place === 'card' ? 'flex h-24 items-start p-3' : 'flex h-9 items-center px-3'}>
32
+ <span className="text-body-2 text-text-secondary">
33
+ {name}, its {place}
34
+ </span>
35
+ </Card>
36
+ )
37
+ }
38
+
39
+ function Box() {
40
+ const editor = useEditor({
41
+ extensions: [StarterKit, BlockId, ReferenceNode.configure({ view: Placed }), LinkPlaces],
42
+ content: {
43
+ type: 'doc',
44
+ content: [
45
+ { type: 'paragraph', attrs: { blockId: 'p1' }, content: [{ type: 'text', text: 'A sentence that names ' }, ref('nostr:naddr1one'), { type: 'text', text: ' in passing.' }] },
46
+ { type: 'paragraph', attrs: { blockId: 'p2' }, content: [ref('nostr:naddr1two')] },
47
+ { type: 'paragraph', attrs: { blockId: 'p3' }, content: [ref('nostr:naddr1three', 'detailed')] },
48
+ ],
49
+ },
50
+ editorProps: { attributes: { class: richTextClassName('default', 'outline-none'), 'aria-label': 'Text' } },
51
+ })
52
+ return (
53
+ <Card fill="surface" className="flex w-[520px] flex-col gap-2 p-3">
54
+ <EditorContent editor={editor} />
55
+ </Card>
56
+ )
57
+ }
58
+
59
+ /** A chip in a sentence, a row alone on its line, and a card chosen for the third. Type beside the row: it becomes a chip. */
60
+ export const InAnEditor: Story = { render: () => <Box /> }
@@ -0,0 +1,134 @@
1
+ // @vitest-environment jsdom
2
+ /**
3
+ * Where a link in a document sits decides how it draws (SPEC §13.3, C22): its
4
+ * chip in a sentence, its row alone on its line, its card in the row's place.
5
+ * The editor reads the rule off its own tree; the protocol reads it off the
6
+ * saved document. Both must give the same answer, or a page reads one way
7
+ * while it is written and another once it is saved.
8
+ */
9
+ import { afterEach, describe, expect, it } from 'vitest'
10
+ import { Editor, type JSONContent } from '@tiptap/core'
11
+ import { TableKit } from '@tiptap/extension-table'
12
+ import { documentForEditing, documentLineDraws, encodeNaddr, encodeNpub, publishableFromEditor, toEditorDocument, toRenderTree, type EditorDocument } from '@estiva-app/protocol'
13
+ import { BlockId, Callout, Checklist, ReferenceNode, UnknownBlock } from './BlockNodes'
14
+ import { LinkPlaces, linkPlaceAt, linkPlaces, staysChip, type LinkPlace } from './LinkPlaces'
15
+ import { DocumentKit } from './links'
16
+
17
+ const naddr = (kind: number, identifier: string) => `nostr:${encodeNaddr({ kind, pubkey: 'a'.repeat(64), identifier, relays: [] })}`
18
+ const V = naddr(30851, 'item-one')
19
+ const FOLDER = naddr(39000, 'place-one')
20
+ const PERSON = `nostr:${encodeNpub('b'.repeat(64))}`
21
+
22
+ const ref = (uri: string, attrs: Record<string, unknown> = {}): JSONContent => ({ type: 'reference', attrs: { uri, ...attrs } })
23
+ const text = (t: string): JSONContent => ({ type: 'text', text: t })
24
+ const p = (...content: JSONContent[]): JSONContent => ({ type: 'paragraph', content })
25
+ const doc = (...content: JSONContent[]): JSONContent => ({ type: 'doc', content })
26
+
27
+ let editor: Editor | undefined
28
+ afterEach(() => {
29
+ editor?.destroy()
30
+ editor = undefined
31
+ })
32
+
33
+ const make = (content: JSONContent | string) => {
34
+ editor = new Editor({
35
+ extensions: [DocumentKit.configure({ link: false }), TableKit, BlockId, Checklist, Callout, ReferenceNode, UnknownBlock, LinkPlaces],
36
+ content,
37
+ })
38
+ return editor
39
+ }
40
+
41
+ /** The place of the one reference in `content`. */
42
+ function placeIn(content: JSONContent): LinkPlace {
43
+ const ed = make(content)
44
+ let at = -1
45
+ ed.state.doc.descendants((node, pos) => {
46
+ if (node.type.name === 'reference' && at < 0) at = pos
47
+ })
48
+ return linkPlaceAt(ed.state.doc, at)
49
+ }
50
+
51
+ /** Each case: a document holding one reference, and how it draws. */
52
+ const CASES: [string, JSONContent, LinkPlace][] = [
53
+ ['alone in a paragraph', doc(p(ref(V))), 'row'],
54
+ ['alone with a space after it, as a `[` pick leaves it', doc(p(ref(V), text(' '))), 'row'],
55
+ ['in a sentence', doc(p(text('See '), ref(V), text(' today.'))), 'chip'],
56
+ ['followed by a full stop', doc(p(ref(V), text('.'))), 'chip'],
57
+ ['alone on the second line of a paragraph, after a hard break', doc(p(text('First line'), { type: 'hardBreak' }, ref(V))), 'row'],
58
+ ['in a heading', doc({ type: 'heading', attrs: { level: 2 }, content: [ref(V)] }), 'chip'],
59
+ ['in a quote', doc({ type: 'blockquote', content: [p(ref(V))] }), 'chip'],
60
+ ['in a callout', doc({ type: 'blockquote', attrs: { tone: 'note' }, content: [p(ref(V))] }), 'chip'],
61
+ ['alone in a list item', doc({ type: 'bulletList', content: [{ type: 'listItem', content: [p(ref(V))] }] }), 'row'],
62
+ ['alone in a checklist item', doc({ type: 'bulletList', content: [{ type: 'listItem', attrs: { checked: false }, content: [p(ref(V))] }] }), 'row'],
63
+ ['alone in a numbered list item', doc({ type: 'orderedList', content: [{ type: 'listItem', content: [p(ref(V))] }] }), 'row'],
64
+ ['in a table cell', doc({ type: 'table', content: [{ type: 'tableRow', content: [{ type: 'tableCell', content: [p(ref(V))] }] }] }), 'chip'],
65
+ ['alone with its card chosen', doc(p(ref(V, { embed: 'detailed' }))), 'card'],
66
+ ['alone with an older writer\'s compact card', doc(p(ref(V, { embed: 'compact' }))), 'row'],
67
+ ['alone with a card value this version does not know', doc(p(ref(V, { embed: 'wide' }))), 'row'],
68
+ ['in a sentence with its card chosen', doc(p(text('See '), ref(V, { embed: 'detailed' }))), 'chip'],
69
+ ['alone but bold', doc(p(ref(V, { marks: ['bold'] }))), 'chip'],
70
+ ['a person alone', doc(p(ref(PERSON))), 'chip'],
71
+ ['a Folder alone', doc(p(ref(FOLDER))), 'chip'],
72
+ ['a Folder alone with a card chosen', doc(p(ref(FOLDER, { embed: 'detailed' }))), 'chip'],
73
+ ]
74
+
75
+ describe('linkPlaceAt', () => {
76
+ it.each(CASES)('draws a link %s as its %s', (_name, content, place) => {
77
+ expect(placeIn(content)).toBe(place)
78
+ })
79
+
80
+ it('draws two links on one line as chips', () => {
81
+ const ed = make(doc(p(ref(V), text(' '), ref(naddr(30851, 'item-two')))))
82
+ expect(linkPlaces(ed.state.doc)).toEqual([])
83
+ })
84
+
85
+ it('draws a pasted URL not resolved yet as its URL, a chip, even alone', () => {
86
+ expect(placeIn(doc(p(ref('', { href: 'https://app.example/item/one' }))))).toBe('chip')
87
+ })
88
+
89
+ it('turns a row into a chip as soon as words are typed beside it, and back when they are deleted', () => {
90
+ const ed = make(doc(p(ref(V))))
91
+ expect(linkPlaceAt(ed.state.doc, 1)).toBe('row')
92
+ ed.commands.insertContentAt(2, 'and more')
93
+ expect(linkPlaceAt(ed.state.doc, 1)).toBe('chip')
94
+ ed.commands.deleteRange({ from: 2, to: 2 + 'and more'.length })
95
+ expect(linkPlaceAt(ed.state.doc, 1)).toBe('row')
96
+ })
97
+
98
+ it('tells the view of each lone link its place, through a node decoration', () => {
99
+ const ed = make(doc(p(ref(V)), p(ref(V, { embed: 'detailed' })), p(text('See '), ref(V))))
100
+ const places = [...ed.view.dom.querySelectorAll('[data-reference]')].map((el) => el.closest('[data-link-place]')?.getAttribute('data-link-place') ?? 'chip')
101
+ expect(places).toEqual(['row', 'card', 'chip'])
102
+ })
103
+ })
104
+
105
+ describe('staysChip', () => {
106
+ it('keeps a person and a Folder as chips, and nothing else', () => {
107
+ expect(staysChip(PERSON)).toBe(true)
108
+ expect(staysChip(FOLDER)).toBe(true)
109
+ expect(staysChip(FOLDER.toUpperCase())).toBe(true)
110
+ expect(staysChip(V)).toBe(false)
111
+ expect(staysChip(naddr(30850, 'group-one'))).toBe(false)
112
+ expect(staysChip('nostr:naddr1notbech32')).toBe(false)
113
+ })
114
+ })
115
+
116
+ describe('the editor and the protocol agree', () => {
117
+ /** How the protocol draws the saved document's one link: `row` or `card` where it says so, else its chip. */
118
+ function protocolPlace(value: string): LinkPlace {
119
+ for (const draws of documentLineDraws(toRenderTree(value, 'blocks')).values()) {
120
+ for (const line of draws) if (line.draw === 'row' || line.draw === 'card') return line.draw
121
+ }
122
+ return 'chip'
123
+ }
124
+
125
+ it.each(CASES)('on a link %s, once saved and opened again', (_name, content, place) => {
126
+ const { value } = publishableFromEditor(make(content).getJSON() as EditorDocument)
127
+ editor?.destroy()
128
+ // Opened again as an app opens it: the saved bytes, read back into the editor.
129
+ const reopened = make(toEditorDocument(documentForEditing(value, 'blocks'), { links: true }) as JSONContent)
130
+ const editorPlaces = linkPlaces(reopened.state.doc).map((one) => one.place)
131
+ expect(protocolPlace(value)).toBe(place)
132
+ expect(editorPlaces[0] ?? 'chip').toBe(place)
133
+ })
134
+ })
@@ -0,0 +1,169 @@
1
+ /**
2
+ * Where a reference in a block document sits, and so how it draws — SPEC §13.3,
3
+ * "A reference's card" (C22, C24): its chip in a sentence, its row alone on its
4
+ * line, and its card in the row's place when its writer chose one.
5
+ *
6
+ * The rule is the protocol's (`documentLineDrawOf` in `@estiva-app/protocol`),
7
+ * read here off the editor's own tree so it can be asked on every keystroke
8
+ * without writing the document out. `linkPlaces.test.ts` runs the same
9
+ * documents through both and holds them to one answer.
10
+ *
11
+ * - **Alone on its line**: a top-level paragraph, or a list item's, whose line
12
+ * (up to a hard break) holds this reference and nothing but spaces besides.
13
+ * A heading, a quote, a callout and a table cell are sentences, and so is
14
+ * anything inside a block this rule does not name.
15
+ * - **A marker around it** (bold, italic, code…) makes it a sentence.
16
+ * - **A person or a Folder** alone on its line stays a chip.
17
+ * - **Its card** is `embed` `detailed`; anything else (none, `compact`, a value
18
+ * this version does not know) draws the row.
19
+ *
20
+ * `LinkPlaces` puts each reference's place on a node decoration, which
21
+ * `ReferenceNode`'s view reads and hands to the app's view as `place`.
22
+ *
23
+ * why: https://github.com/estiva-app/estiva-docs/blob/main/decisions/a-link-on-words-counts-toward-the-card.md
24
+ * why: https://github.com/estiva-app/estiva-docs/blob/main/decisions/a-lone-links-chip-menu-offers-row-or-card.md
25
+ */
26
+ import { Extension } from '@tiptap/core'
27
+ import type { Node as PmNode } from '@tiptap/pm/model'
28
+ import { Plugin, PluginKey } from '@tiptap/pm/state'
29
+ import { Decoration, DecorationSet } from '@tiptap/pm/view'
30
+
31
+ /** How a reference draws: its chip, its row, or its card in the row's place. */
32
+ export type LinkPlace = 'chip' | 'row' | 'card'
33
+
34
+ /** The blocks a line may sit inside and still be alone: a list and its items. */
35
+ const CONTAINERS = new Set(['bulletList', 'orderedList', 'listItem'])
36
+
37
+ const BECH32 = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'
38
+
39
+ /** The 5-bit words of a bech32 string's data part, checksum dropped, or null. */
40
+ function bech32Words(text: string): number[] | null {
41
+ const at = text.lastIndexOf('1')
42
+ if (at < 1 || text.length - at < 7) return null
43
+ const words: number[] = []
44
+ for (const char of text.slice(at + 1, -6)) {
45
+ const word = BECH32.indexOf(char)
46
+ if (word < 0) return null
47
+ words.push(word)
48
+ }
49
+ return words
50
+ }
51
+
52
+ /** An `naddr`'s kind (TLV type 3), or null when it does not hold one. */
53
+ function naddrKind(naddr: string): number | null {
54
+ const words = bech32Words(naddr)
55
+ if (!words) return null
56
+ const bytes: number[] = []
57
+ let acc = 0
58
+ let bits = 0
59
+ for (const word of words) {
60
+ acc = (acc << 5) | word
61
+ bits += 5
62
+ while (bits >= 8) {
63
+ bits -= 8
64
+ bytes.push((acc >> bits) & 0xff)
65
+ }
66
+ }
67
+ for (let i = 0; i + 1 < bytes.length; ) {
68
+ const type = bytes[i]
69
+ const length = bytes[i + 1]
70
+ if (type === 3 && length === 4 && i + 6 <= bytes.length) return ((bytes[i + 2] << 24) | (bytes[i + 3] << 16) | (bytes[i + 4] << 8) | bytes[i + 5]) >>> 0
71
+ i += 2 + length
72
+ }
73
+ return null
74
+ }
75
+
76
+ /** A Folder's kind. */
77
+ const FOLDER = 39000
78
+
79
+ /**
80
+ * Whether what `uri` names stays a chip alone on its line: a person (`npub`,
81
+ * `nprofile`) or a Folder (an `naddr` of kind 39000).
82
+ */
83
+ export function staysChip(uri: string): boolean {
84
+ const bare = uri.toLowerCase().replace(/^nostr:/, '')
85
+ if (bare.startsWith('npub1') || bare.startsWith('nprofile1')) return true
86
+ return bare.startsWith('naddr1') && naddrKind(bare) === FOLDER
87
+ }
88
+
89
+ /** Whether the textblock holding `pos` keeps the line rule: a paragraph at the top, or a list item's. */
90
+ function keepsLineRule(doc: PmNode, pos: number): boolean {
91
+ const $pos = doc.resolve(pos)
92
+ if ($pos.parent.type.name !== 'paragraph' && $pos.parent.type.name !== 'listItem') return false
93
+ for (let depth = 1; depth < $pos.depth; depth++) if (!CONTAINERS.has($pos.node(depth).type.name)) return false
94
+ return true
95
+ }
96
+
97
+ /** Whether the reference at `index` of `block` is alone on its line: only spaces beside it, up to a hard break either side. */
98
+ function aloneOnLine(block: PmNode, index: number): boolean {
99
+ for (const step of [-1, 1]) {
100
+ for (let i = index + step; i >= 0 && i < block.childCount; i += step) {
101
+ const child = block.child(i)
102
+ if (child.type.name === 'hardBreak') break
103
+ if (!child.isText || (child.text ?? '').trim() !== '') return false
104
+ }
105
+ }
106
+ return true
107
+ }
108
+
109
+ /** How the reference node at `pos` draws. Anything that is not a reference with a `uri` draws as a chip. */
110
+ export function linkPlaceAt(doc: PmNode, pos: number): LinkPlace {
111
+ const node = doc.nodeAt(pos)
112
+ if (!node || node.type.name !== 'reference') return 'chip'
113
+ const uri = String(node.attrs.uri ?? '')
114
+ // A URL chip whose URL is not resolved yet names nothing: it reads as the URL.
115
+ if (!uri || staysChip(uri)) return 'chip'
116
+ if (Array.isArray(node.attrs.marks) && node.attrs.marks.length > 0) return 'chip'
117
+ if (!keepsLineRule(doc, pos)) return 'chip'
118
+ const $pos = doc.resolve(pos)
119
+ if (!aloneOnLine($pos.parent, $pos.index())) return 'chip'
120
+ return node.attrs.embed === 'detailed' ? 'card' : 'row'
121
+ }
122
+
123
+ /** Every reference that does not draw as its chip, with its place. */
124
+ export function linkPlaces(doc: PmNode): { pos: number; size: number; place: Exclude<LinkPlace, 'chip'> }[] {
125
+ const out: { pos: number; size: number; place: Exclude<LinkPlace, 'chip'> }[] = []
126
+ doc.descendants((node, pos) => {
127
+ if (node.type.name !== 'reference') return true
128
+ const place = linkPlaceAt(doc, pos)
129
+ if (place !== 'chip') out.push({ pos, size: node.nodeSize, place })
130
+ return false
131
+ })
132
+ return out
133
+ }
134
+
135
+ /** The place a node view's decorations give it; `chip` without one. */
136
+ export function placeOf(decorations: readonly Decoration[] | undefined): LinkPlace {
137
+ for (const decoration of decorations ?? []) {
138
+ const place = (decoration.spec as { linkPlace?: LinkPlace }).linkPlace
139
+ if (place) return place
140
+ }
141
+ return 'chip'
142
+ }
143
+
144
+ const key = new PluginKey<DecorationSet>('linkPlaces')
145
+
146
+ /**
147
+ * Marks each reference that draws as its row or its card, for `ReferenceNode`'s
148
+ * view. Without it every reference is a chip, as in a message's box.
149
+ */
150
+ export const LinkPlaces = Extension.create({
151
+ name: 'linkPlaces',
152
+ addProseMirrorPlugins() {
153
+ const decorate = (doc: PmNode) =>
154
+ DecorationSet.create(
155
+ doc,
156
+ linkPlaces(doc).map(({ pos, size, place }) => Decoration.node(pos, pos + size, { 'data-link-place': place }, { linkPlace: place })),
157
+ )
158
+ return [
159
+ new Plugin<DecorationSet>({
160
+ key,
161
+ state: {
162
+ init: (_, state) => decorate(state.doc),
163
+ apply: (tr, set) => (tr.docChanged ? decorate(tr.doc) : set),
164
+ },
165
+ props: { decorations: (state) => key.getState(state) },
166
+ }),
167
+ ]
168
+ },
169
+ })
@@ -20,6 +20,10 @@ one, and the app draws its own card into it.
20
20
 
21
21
  ## When not
22
22
 
23
+ - A new editor of a document → **LinkPlaces**: since §13.3's line rule, a
24
+ card draws in a lone link's row's place, and a card on a link in a sentence
25
+ draws nothing. **DocumentEditor** uses it; this stays for an editor that has
26
+ not moved yet.
23
27
  - A document that is only read → **RichText**, with each block's cards drawn
24
28
  after it from the text's own description of them.
25
29
  - A text whose cards travel beside it rather than on its chips → the app keeps
@@ -5,32 +5,34 @@ import * as ReferenceMenuStories from './ReferenceMenu.stories'
5
5
 
6
6
  # ReferenceMenu
7
7
 
8
- What a chip in a document offers whoever is writing it: **Open**, and its
9
- **Card** — none, compact or detailed. The card draws after the chip's line.
8
+ What a link in a document offers whoever is writing it: **Open**, and — when
9
+ it is alone on its line — **Show as** Row or Card. Card puts its card in the
10
+ row's place; Row puts the row back. A link in a sentence, and a person or a
11
+ Folder alone on its line (which stay chips), offer Open only.
10
12
 
11
13
  <Canvas of={ReferenceMenuStories.InAnEditor} />
12
14
 
13
15
  ## When
14
16
 
15
- - **An editor of a document whose chips can ask for a card**: pair it with
16
- **ReferenceNode**, which draws the chip, and **ReferenceCards**, which places
17
- the card. With **LinkChips**, a pasted URL that becomes its chip opens the
18
- menu too.
17
+ - **An editor of a document**: pair it with **ReferenceNode**, which draws the
18
+ link, and **LinkPlaces**, which tells it where it sits. With **LinkChips**, a
19
+ pasted URL that becomes its chip opens the menu too. **DocumentEditor** has
20
+ all of them.
19
21
 
20
22
  ## When not
21
23
 
22
- - A document that is only read → **RichText**: a click on a chip follows it.
23
- - An editor whose chips take no card → leave it out, and a click on a chip
24
- follows it as when reading.
24
+ - A document that is only read → **RichText**: a click on a link follows it.
25
+ - A message's box, where every link is a chip and its card goes under the
26
+ message → **CardUnder**; leave this out, and a click on a chip follows it.
25
27
 
26
28
  ## How
27
29
 
28
30
  ```tsx
29
31
  import { EditorContent, useEditor } from '@tiptap/react'
30
- import { ReferenceCards, ReferenceMenu, ReferenceMenuView, ReferenceNode, isReferenceMenuOpen } from '@estiva-app/ui/editor'
32
+ import { LinkPlaces, ReferenceMenu, ReferenceMenuView, ReferenceNode, isReferenceMenuOpen } from '@estiva-app/ui/editor'
31
33
 
32
34
  const editor = useEditor({
33
- extensions: [/* … */ ReferenceNode.configure({ view: Chip }), ReferenceCards, ReferenceMenu],
35
+ extensions: [/* … */ ReferenceNode.configure({ view: Chip }), LinkPlaces, ReferenceMenu],
34
36
  editorProps: {
35
37
  handleKeyDown: (view, event) => {
36
38
  // While the menu is open, Escape is its own: it closes the menu.
@@ -44,29 +46,35 @@ const editor = useEditor({
44
46
  <ReferenceMenuView editor={editor} />
45
47
  ```
46
48
 
47
- - **A click on a chip while editing** opens the menu under it, instead of
48
- following the chip. Not editing, the click follows it.
49
- - **A chip just put in** — pasted, picked with `[`, or a pasted URL becoming its
50
- chip — opens the menu by itself. It takes no focus: typing on closes it, and
51
- the chip keeps no card.
52
- - **Open** does what a click on the chip does when reading: the app's chip gets
53
- the click. A chip with nothing to click opens its URL in a new tab.
54
- - Open is offered only when there is something to open: the chip's own link
55
- or button, or its URL. A chip whose URL names nothing yet offers Open only;
56
- one with neither has no menu, and a click goes on to it.
49
+ - **A click on a link while editing** — its chip, row or card — opens the menu
50
+ under it, instead of following it. Not editing, the click follows it. A
51
+ card's own controls (its status, its owner) take their click while editing
52
+ too.
53
+ - **A link just put in alone on its line** — pasted, picked with `[`, or a
54
+ pasted URL becoming its chip — opens the menu by itself. It takes no focus:
55
+ typing on closes it, and nothing is written. In a sentence it does not open:
56
+ Open would be all it offers.
57
+ - **What it writes:** Card writes `embed` `detailed`; Row removes `embed`.
58
+ Nothing writes `compact`; an older writer's is kept until Row or Card is
59
+ chosen, and draws, and reads in the menu, as Row.
60
+ - **Open** does what a click on the link does when reading: the app's link gets
61
+ the click. A link with nothing to click opens its URL in a new tab.
62
+ - Open is offered only when there is something to open: the link's own
63
+ control, or its URL. A link in a sentence with neither has no menu, and a
64
+ click goes on to it.
57
65
  - The menu closes when the editor loses focus, so a card is never chosen after
58
66
  the editor has saved on leaving.
59
- - Choosing a card is an undo step; the menu closes.
67
+ - Choosing Row or Card is an undo step; the menu closes.
60
68
 
61
69
  ## What it owns
62
70
 
63
- Nothing. Its box is the Popover; it holds which chip the menu is open on, and its keys.
71
+ Nothing. Its box is the Popover; it holds which link the menu is open on, and its keys.
64
72
 
65
73
  ## Keys
66
74
 
67
75
  | Key | Does |
68
76
  | --- | --- |
69
- | Enter, on a selected chip | Opens the menu, its first row highlighted |
77
+ | Enter, on a selected link | Opens the menu, its first row highlighted |
70
78
  | ↓ / ↑ | Moves through the rows; nothing is highlighted until then |
71
79
  | Enter | Chooses the highlighted row; with none, the editor's own Enter |
72
80
  | Escape | Closes the menu |
@@ -4,14 +4,14 @@ import StarterKit from '@tiptap/starter-kit'
4
4
  import { BlockId, ReferenceNode, type ReferenceViewProps } from './BlockNodes'
5
5
  import { Card } from './Card'
6
6
  import { InlineChip } from './InlineChip'
7
- import { ReferenceCards, useReferenceCards } from './ReferenceCards'
7
+ import { LinkPlaces } from './LinkPlaces'
8
8
  import { ReferenceMenu, ReferenceMenuView } from './ReferenceMenu'
9
9
  import { richTextClassName } from './RichText'
10
10
 
11
11
  /**
12
- * Click the chip: its menu opens under it — Open, and a card of none, compact
13
- * or detailed. The chip is a placeholder naming what it points at, and the
14
- * card a line naming its layout: the real ones are the app's.
12
+ * Click a link: its menu opens under it — Open, and alone on its line Show as
13
+ * Row or Card. The link is a placeholder naming where it sits: the real chip,
14
+ * row and card are the app's.
15
15
  */
16
16
  const meta = {
17
17
  title: 'Primitives/ReferenceMenu',
@@ -21,39 +21,38 @@ const meta = {
21
21
  export default meta
22
22
  type Story = StoryObj
23
23
 
24
- function Placeholder({ uri }: ReferenceViewProps) {
25
- return <InlineChip>Item for {uri}</InlineChip>
24
+ function Placeholder({ place = 'chip' }: ReferenceViewProps) {
25
+ if (place === 'chip') return <InlineChip>Item one</InlineChip>
26
+ return (
27
+ <Card fill="inset" className={place === 'card' ? 'flex h-24 items-start p-3' : 'flex h-9 items-center px-3'}>
28
+ <span className="text-body-2 text-text-secondary">Item two, its {place}</span>
29
+ </Card>
30
+ )
26
31
  }
27
32
 
28
33
  function Box() {
29
34
  const editor = useEditor({
30
- extensions: [StarterKit.configure({ link: false }), BlockId, ReferenceNode.configure({ view: Placeholder }), ReferenceCards, ReferenceMenu],
35
+ extensions: [StarterKit.configure({ link: false }), BlockId, ReferenceNode.configure({ view: Placeholder }), LinkPlaces, ReferenceMenu],
31
36
  content: {
32
37
  type: 'doc',
33
38
  content: [
34
39
  {
35
40
  type: 'paragraph',
36
41
  attrs: { blockId: 'p1' },
37
- content: [
38
- { type: 'text', text: 'See ' },
39
- { type: 'reference', attrs: { uri: 'nostr:naddr1one' } },
40
- { type: 'text', text: ' for the details.' },
41
- ],
42
+ content: [{ type: 'text', text: 'See ' }, { type: 'reference', attrs: { uri: 'nostr:naddr1one' } }, { type: 'text', text: ' for the details.' }],
42
43
  },
44
+ { type: 'paragraph', attrs: { blockId: 'p2' }, content: [{ type: 'reference', attrs: { uri: 'nostr:naddr1two' } }] },
43
45
  ],
44
46
  },
45
47
  editorProps: { attributes: { class: richTextClassName('default', 'outline-none'), 'aria-label': 'Text' } },
46
48
  })
47
- const slots = useReferenceCards(editor)
48
- const cards = slots.flatMap((slot) => slot.cards.map((card) => `${card.layout} card for ${card.uri}`))
49
49
  return (
50
50
  <Card fill="surface" className="flex w-[520px] flex-col gap-2 p-3">
51
51
  <EditorContent editor={editor} />
52
52
  <ReferenceMenuView editor={editor} />
53
- <p className="text-caption text-text-secondary">{cards.length ? cards.join(', ') : 'No card'}</p>
54
53
  </Card>
55
54
  )
56
55
  }
57
56
 
58
- /** A chip in a sentence: click it to open its menu, and choose a card. */
57
+ /** A link in a sentence, whose menu has Open only, and one alone on its line: choose Card, then Row. */
59
58
  export const InAnEditor: Story = { render: () => <Box /> }