@whity/ui 0.0.0-stage → 0.5.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.
- package/README.md +107 -3
- package/package.json +192 -6
- package/src/access-denied.stories.tsx +179 -0
- package/src/access-denied.tsx +305 -0
- package/src/action-proposal.tsx +302 -0
- package/src/actor-chip.tsx +71 -0
- package/src/agent-activity.tsx +163 -0
- package/src/agent-collaboration.stories.tsx +156 -0
- package/src/agent-run-status.tsx +196 -0
- package/src/alert-dialog.stories.tsx +45 -0
- package/src/alert-dialog.tsx +147 -0
- package/src/alert.stories.tsx +91 -0
- package/src/alert.tsx +89 -0
- package/src/app-sidebar.stories.tsx +195 -0
- package/src/app-sidebar.tsx +500 -0
- package/src/approval-queue.tsx +108 -0
- package/src/audience-group-picker.stories.tsx +198 -0
- package/src/audience-group-picker.tsx +362 -0
- package/src/audience-people-picker.stories.tsx +102 -0
- package/src/audience-people-picker.tsx +279 -0
- package/src/avatar.tsx +83 -0
- package/src/badge.stories.tsx +105 -0
- package/src/badge.tsx +68 -0
- package/src/beta-warning.stories.tsx +79 -0
- package/src/beta-warning.tsx +189 -0
- package/src/bilingual-input.stories.tsx +82 -0
- package/src/bilingual-input.tsx +183 -0
- package/src/breadcrumb.stories.tsx +51 -0
- package/src/breadcrumb.tsx +90 -0
- package/src/button.stories.tsx +87 -0
- package/src/button.tsx +118 -0
- package/src/card.stories.tsx +423 -0
- package/src/card.tsx +180 -0
- package/src/chart.stories.tsx +66 -0
- package/src/chart.tsx +228 -0
- package/src/checkbox.stories.tsx +62 -0
- package/src/checkbox.tsx +54 -0
- package/src/collapsible.stories.tsx +48 -0
- package/src/collapsible.tsx +34 -0
- package/src/color-card.stories.tsx +61 -0
- package/src/color-card.tsx +270 -0
- package/src/color-picker.stories.tsx +65 -0
- package/src/color-picker.tsx +425 -0
- package/src/command-palette.tsx +306 -0
- package/src/copy-block.stories.tsx +38 -0
- package/src/copy-block.tsx +85 -0
- package/src/data-table.stories.tsx +200 -0
- package/src/data-table.tsx +1106 -0
- package/src/date-picker.stories.tsx +61 -0
- package/src/date-picker.tsx +422 -0
- package/src/design-cards.stories.tsx +458 -0
- package/src/dialog.stories.tsx +48 -0
- package/src/dialog.tsx +166 -0
- package/src/documents/barcode-svg.stories.tsx +72 -0
- package/src/documents/barcode-svg.tsx +79 -0
- package/src/dropdown-menu.stories.tsx +77 -0
- package/src/dropdown-menu.tsx +271 -0
- package/src/editor/behaviour.ts +279 -0
- package/src/editor/block-ids.ts +44 -0
- package/src/editor/block-list.tsx +101 -0
- package/src/editor/block-toolbar.tsx +477 -0
- package/src/editor/bubble.tsx +93 -0
- package/src/editor/catalogue.ts +103 -0
- package/src/editor/collab-rail.tsx +746 -0
- package/src/editor/collab.stories.tsx +207 -0
- package/src/editor/collab.ts +87 -0
- package/src/editor/contract.ts +408 -0
- package/src/editor/convert.ts +362 -0
- package/src/editor/doc-editor.stories.tsx +98 -0
- package/src/editor/doc-editor.tsx +1287 -0
- package/src/editor/editor.css +536 -0
- package/src/editor/extensions.ts +86 -0
- package/src/editor/field-picker.tsx +107 -0
- package/src/editor/fields.ts +100 -0
- package/src/editor/gutter.tsx +367 -0
- package/src/editor/index.ts +22 -0
- package/src/editor/label-sheet.tsx +289 -0
- package/src/editor/labels.ts +310 -0
- package/src/editor/link-tools.tsx +141 -0
- package/src/editor/node-views.tsx +450 -0
- package/src/editor/page-view.tsx +353 -0
- package/src/editor/publish-check.tsx +182 -0
- package/src/editor/rich-blocks.stories.tsx +146 -0
- package/src/editor/sample.ts +40 -0
- package/src/editor/schema-rich.ts +150 -0
- package/src/editor/schema.ts +315 -0
- package/src/editor/services.tsx +127 -0
- package/src/editor/slash.ts +64 -0
- package/src/editor/suggesting.ts +372 -0
- package/src/editor/suggestions.ts +763 -0
- package/src/editor/table-keys.ts +66 -0
- package/src/editor/templates.stories.tsx +324 -0
- package/src/editor/toolbar.tsx +358 -0
- package/src/empty-state.stories.tsx +51 -0
- package/src/empty-state.tsx +100 -0
- package/src/empty-state.usage-notes.md +30 -0
- package/src/form.stories.tsx +112 -0
- package/src/form.tsx +176 -0
- package/src/globals.css +20 -0
- package/src/icon-button.tsx +85 -0
- package/src/icon-map.ts +244 -0
- package/src/icon.tsx +41 -0
- package/src/index.ts +67 -0
- package/src/input.stories.tsx +157 -0
- package/src/input.tsx +759 -0
- package/src/locked-screen.stories.tsx +29 -0
- package/src/locked-screen.tsx +61 -0
- package/src/mark.tsx +62 -0
- package/src/math-text.stories.tsx +33 -0
- package/src/math-text.tsx +43 -0
- package/src/menu-bar.stories.tsx +198 -0
- package/src/menu-bar.tsx +373 -0
- package/src/money/currency.ts +230 -0
- package/src/page-header.stories.tsx +95 -0
- package/src/page-header.tsx +122 -0
- package/src/page-shell.stories.tsx +42 -0
- package/src/page-shell.tsx +32 -0
- package/src/pagination.stories.tsx +45 -0
- package/src/pagination.tsx +98 -0
- package/src/plugin-card.stories.tsx +180 -0
- package/src/plugin-card.tsx +848 -0
- package/src/popover.stories.tsx +48 -0
- package/src/popover.tsx +55 -0
- package/src/radio-group.stories.tsx +26 -0
- package/src/radio-group.tsx +44 -0
- package/src/route-flow/editor.tsx +1014 -0
- package/src/route-flow/model.ts +716 -0
- package/src/scope-grant.tsx +139 -0
- package/src/screen-too-small.stories.tsx +61 -0
- package/src/screen-too-small.tsx +104 -0
- package/src/select.stories.tsx +44 -0
- package/src/select.tsx +197 -0
- package/src/separator.stories.tsx +34 -0
- package/src/separator.tsx +34 -0
- package/src/sheet.stories.tsx +49 -0
- package/src/sheet.tsx +168 -0
- package/src/skeleton.stories.tsx +28 -0
- package/src/skeleton.tsx +19 -0
- package/src/slider.stories.tsx +78 -0
- package/src/slider.tsx +300 -0
- package/src/spinner.stories.tsx +33 -0
- package/src/spinner.tsx +55 -0
- package/src/switch.stories.tsx +42 -0
- package/src/switch.tsx +41 -0
- package/src/switcher.stories.tsx +111 -0
- package/src/switcher.tsx +131 -0
- package/src/table.stories.tsx +48 -0
- package/src/table.tsx +121 -0
- package/src/tabs.stories.tsx +74 -0
- package/src/tabs.tsx +90 -0
- package/src/tag-input.stories.tsx +67 -0
- package/src/tag-input.tsx +117 -0
- package/src/tenant-logo.tsx +63 -0
- package/src/tenant-switcher.stories.tsx +38 -0
- package/src/tenant-switcher.tsx +164 -0
- package/src/textarea.stories.tsx +27 -0
- package/src/textarea.tsx +18 -0
- package/src/theme-mode.ts +52 -0
- package/src/time-picker.stories.tsx +62 -0
- package/src/time-picker.tsx +615 -0
- package/src/toggle-group.tsx +138 -0
- package/src/tooltip.stories.tsx +43 -0
- package/src/tooltip.tsx +73 -0
- package/src/top-nav.stories.tsx +58 -0
- package/src/top-nav.tsx +324 -0
- package/src/undo-bar.tsx +107 -0
- package/src/utils.ts +45 -0
- package/src/view-toggle.stories.tsx +84 -0
- package/src/view-toggle.tsx +110 -0
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
import type { WhityDocument } from "./contract"
|
|
2
|
+
|
|
3
|
+
const t = (text: string) => ({ type: "text" as const, text })
|
|
4
|
+
|
|
5
|
+
/** Example data for stories and tests: Example Bakery, fictional (CLAUDE.md). */
|
|
6
|
+
export const SAMPLE_DOCUMENT: WhityDocument = {
|
|
7
|
+
id: "doc-payment-reminder",
|
|
8
|
+
kind: "note",
|
|
9
|
+
title: "Payment reminder",
|
|
10
|
+
lang: "en",
|
|
11
|
+
defaultView: "continuous",
|
|
12
|
+
blocks: [
|
|
13
|
+
{ id: "b1", type: "paragraph", content: [t("Dear Example Clinic,")] },
|
|
14
|
+
{
|
|
15
|
+
id: "b2",
|
|
16
|
+
type: "paragraph",
|
|
17
|
+
content: [
|
|
18
|
+
t("Invoice INV-1042 for JOD 301.600 was due on 14 Oct 2026. "),
|
|
19
|
+
{ type: "text", text: "Please pay within 14 days", marks: [{ type: "bold" }] },
|
|
20
|
+
t(" of this letter, by bank transfer or "),
|
|
21
|
+
{ type: "text", text: "online", marks: [{ type: "link", href: "https://example.jo/pay/INV-1042" }] },
|
|
22
|
+
t("."),
|
|
23
|
+
],
|
|
24
|
+
},
|
|
25
|
+
{ id: "b3", type: "heading", level: 1, content: [t("Open invoices")] },
|
|
26
|
+
{ id: "b4", type: "bullet", level: 0, content: [t("INV-1042, due 14 Oct 2026, JOD 301.600")] },
|
|
27
|
+
{ id: "b5", type: "bullet", level: 0, content: [t("INV-1051, due 21 Oct 2026, JOD 96.000")] },
|
|
28
|
+
{ id: "b6", type: "heading", level: 2, content: [t("Before you send it")] },
|
|
29
|
+
{ id: "b7", type: "checklist", level: 0, checked: true, content: [t("Check the amounts against the statement")] },
|
|
30
|
+
{ id: "b8", type: "checklist", level: 0, checked: false, content: [t("Ask Rana to approve the wording")] },
|
|
31
|
+
{ id: "b9", type: "quote", content: [t("If you have already paid, thank you, and please ignore this letter.")] },
|
|
32
|
+
{ id: "b10", type: "paragraph", content: [t("Kind regards,")] },
|
|
33
|
+
{ id: "b11", type: "paragraph", content: [t("Rana Haddad"), { type: "break" }, t("Example Bakery")] },
|
|
34
|
+
],
|
|
35
|
+
comments: [],
|
|
36
|
+
suggestions: [],
|
|
37
|
+
status: "draft",
|
|
38
|
+
updatedAt: "2026-10-29T14:02:00Z",
|
|
39
|
+
updatedBy: { kind: "person", id: "u-rana", name: "Rana Haddad" },
|
|
40
|
+
}
|
|
@@ -0,0 +1,150 @@
|
|
|
1
|
+
import { Node, mergeAttributes } from "@tiptap/core"
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* The rich blocks of editor milestone M3 (E.13–E.16, E.40–E.42), on top of
|
|
5
|
+
* schema.ts. Containers (toggle, columns, table) hold editable content; the
|
|
6
|
+
* rest are atoms whose contract fields live in attributes and are edited
|
|
7
|
+
* through their block toolbar (E.8). Every block keeps its `id` and optional
|
|
8
|
+
* `suggestion`, like the text blocks.
|
|
9
|
+
*/
|
|
10
|
+
|
|
11
|
+
const blockAttributes = {
|
|
12
|
+
id: { default: null, keepOnSplit: false },
|
|
13
|
+
suggestion: { default: null, rendered: false },
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
const dataAttrs = (attrs: Record<string, unknown>, type: string, extra: Record<string, unknown> = {}) =>
|
|
17
|
+
mergeAttributes({ "data-block-id": attrs.id ?? undefined, "data-type": type, ...extra })
|
|
18
|
+
|
|
19
|
+
/** An attribute that holds contract JSON (objects, arrays) and is never rendered to the DOM. */
|
|
20
|
+
const json = (fallback: unknown = null) => ({ default: fallback, rendered: false })
|
|
21
|
+
|
|
22
|
+
/** E.14: two kinds only, Note (grey) and Important (warning tint). */
|
|
23
|
+
export const Callout = Node.create({
|
|
24
|
+
name: "callout",
|
|
25
|
+
group: "block",
|
|
26
|
+
content: "inline*",
|
|
27
|
+
defining: true,
|
|
28
|
+
addAttributes: () => ({ ...blockAttributes, kind: { default: "note" } }),
|
|
29
|
+
parseHTML: () => [{ tag: "div[data-type=callout]" }],
|
|
30
|
+
renderHTML: ({ node }) => ["div", dataAttrs(node.attrs, "callout", { "data-kind": node.attrs.kind }), 0],
|
|
31
|
+
})
|
|
32
|
+
|
|
33
|
+
/** A toggle: a summary line and the blocks it hides. */
|
|
34
|
+
export const Toggle = Node.create({
|
|
35
|
+
name: "toggle",
|
|
36
|
+
group: "block",
|
|
37
|
+
content: "toggleSummary block*",
|
|
38
|
+
defining: true,
|
|
39
|
+
addAttributes: () => ({ ...blockAttributes, open: { default: true } }),
|
|
40
|
+
parseHTML: () => [{ tag: "div[data-type=toggle]" }],
|
|
41
|
+
renderHTML: ({ node }) => ["div", dataAttrs(node.attrs, "toggle", { "data-open": node.attrs.open ? "true" : "false" }), 0],
|
|
42
|
+
})
|
|
43
|
+
|
|
44
|
+
export const ToggleSummary = Node.create({
|
|
45
|
+
name: "toggleSummary",
|
|
46
|
+
content: "inline*",
|
|
47
|
+
defining: true,
|
|
48
|
+
parseHTML: () => [{ tag: "div[data-type=toggle-summary]" }],
|
|
49
|
+
renderHTML: () => ["div", { "data-type": "toggle-summary" }, 0],
|
|
50
|
+
})
|
|
51
|
+
|
|
52
|
+
/** E.13: two columns. A column may be empty, so the editor never invents content. */
|
|
53
|
+
export const Columns = Node.create({
|
|
54
|
+
name: "columns",
|
|
55
|
+
group: "block",
|
|
56
|
+
content: "column column",
|
|
57
|
+
defining: true,
|
|
58
|
+
addAttributes: () => blockAttributes,
|
|
59
|
+
parseHTML: () => [{ tag: "div[data-type=columns]" }],
|
|
60
|
+
renderHTML: ({ node }) => ["div", dataAttrs(node.attrs, "columns"), 0],
|
|
61
|
+
})
|
|
62
|
+
|
|
63
|
+
export const Column = Node.create({
|
|
64
|
+
name: "column",
|
|
65
|
+
content: "block*",
|
|
66
|
+
isolating: true,
|
|
67
|
+
parseHTML: () => [{ tag: "div[data-type=column]" }],
|
|
68
|
+
renderHTML: () => ["div", { "data-type": "column" }, 0],
|
|
69
|
+
})
|
|
70
|
+
|
|
71
|
+
/** E.15: a document table — rows, columns, an optional header row, end-aligned numbers. Not a database. */
|
|
72
|
+
export const Table = Node.create({
|
|
73
|
+
name: "table",
|
|
74
|
+
group: "block",
|
|
75
|
+
content: "tableRow*",
|
|
76
|
+
isolating: true,
|
|
77
|
+
addAttributes: () => ({ ...blockAttributes, headerRow: { default: true }, columns: json([]) }),
|
|
78
|
+
parseHTML: () => [{ tag: "table" }],
|
|
79
|
+
renderHTML: ({ node }) => ["table", dataAttrs(node.attrs, "table", { "data-header-row": node.attrs.headerRow ? "true" : "false" }), ["tbody", 0]],
|
|
80
|
+
})
|
|
81
|
+
|
|
82
|
+
export const TableRow = Node.create({
|
|
83
|
+
name: "tableRow",
|
|
84
|
+
content: "tableCell*",
|
|
85
|
+
parseHTML: () => [{ tag: "tr" }],
|
|
86
|
+
renderHTML: () => ["tr", 0],
|
|
87
|
+
})
|
|
88
|
+
|
|
89
|
+
export const TableCell = Node.create({
|
|
90
|
+
name: "tableCell",
|
|
91
|
+
content: "inline*",
|
|
92
|
+
isolating: true,
|
|
93
|
+
parseHTML: () => [{ tag: "td" }, { tag: "th" }],
|
|
94
|
+
renderHTML: () => ["td", 0],
|
|
95
|
+
})
|
|
96
|
+
|
|
97
|
+
function atom(name: string, attrs: Record<string, unknown>) {
|
|
98
|
+
return Node.create({
|
|
99
|
+
name,
|
|
100
|
+
group: "block",
|
|
101
|
+
atom: true,
|
|
102
|
+
selectable: true,
|
|
103
|
+
draggable: false,
|
|
104
|
+
addAttributes: () => ({ ...blockAttributes, ...attrs }),
|
|
105
|
+
parseHTML: () => [{ tag: `div[data-type=${name}]` }],
|
|
106
|
+
renderHTML: ({ node }) => ["div", dataAttrs(node.attrs, name)],
|
|
107
|
+
})
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
export const PageBreak = atom("pageBreak", {})
|
|
111
|
+
/** Image: half, wide or full width, alt text, an optional caption (E.13). */
|
|
112
|
+
export const Image = atom("image", { src: { default: "" }, alt: { default: "" }, width: { default: "full" }, caption: json(null) })
|
|
113
|
+
export const FileBlock = atom("file", { fileId: { default: "" }, name: { default: "" }, size: { default: 0 }, mime: { default: "" } })
|
|
114
|
+
/** E.16: live in the editor; each PDF freezes the values. */
|
|
115
|
+
export const RecordBlock = atom("record", { ref: json(null), view: { default: "card" } })
|
|
116
|
+
export const ChartBlock = atom("chart", { chart: { default: "bar" }, source: json(null), title: { default: null } })
|
|
117
|
+
/** Stage 6: signers, a date, an optional stamp. */
|
|
118
|
+
export const SignatureBlock = atom("signature", { signers: json([]), date: json([]), stamp: { default: true } })
|
|
119
|
+
/** E.40 */
|
|
120
|
+
export const BarcodeBlock = atom("barcode", {
|
|
121
|
+
symbology: { default: "code128" },
|
|
122
|
+
value: json([]),
|
|
123
|
+
showText: { default: true },
|
|
124
|
+
widthMm: { default: null },
|
|
125
|
+
heightMm: { default: null },
|
|
126
|
+
})
|
|
127
|
+
/** E.41 */
|
|
128
|
+
export const QrBlock = atom("qr", { value: json([]), caption: json(null), sizeMm: { default: null } })
|
|
129
|
+
/** E.42 */
|
|
130
|
+
export const MathBlock = atom("math", { tex: { default: "" } })
|
|
131
|
+
|
|
132
|
+
export const richSchemaExtensions = [
|
|
133
|
+
Callout,
|
|
134
|
+
Toggle,
|
|
135
|
+
ToggleSummary,
|
|
136
|
+
Columns,
|
|
137
|
+
Column,
|
|
138
|
+
Table,
|
|
139
|
+
TableRow,
|
|
140
|
+
TableCell,
|
|
141
|
+
PageBreak,
|
|
142
|
+
Image,
|
|
143
|
+
FileBlock,
|
|
144
|
+
RecordBlock,
|
|
145
|
+
ChartBlock,
|
|
146
|
+
SignatureBlock,
|
|
147
|
+
BarcodeBlock,
|
|
148
|
+
QrBlock,
|
|
149
|
+
MathBlock,
|
|
150
|
+
]
|
|
@@ -0,0 +1,315 @@
|
|
|
1
|
+
import { Mark, Node, mergeAttributes } from "@tiptap/core"
|
|
2
|
+
|
|
3
|
+
import { richSchemaExtensions } from "./schema-rich"
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* The ProseMirror schema for the WhityDocument contract (contract.ts,
|
|
7
|
+
* handoff/editor/README.md). Every block node carries a stable `id` (BlockId)
|
|
8
|
+
* and an optional `suggestion` (E.4). Lists are flat items with a `level`
|
|
9
|
+
* (Notion style), so drag-and-drop and Turn into stay simple. Blocks the
|
|
10
|
+
* editor can't edit yet (later milestones) are kept whole in `unknownBlock`,
|
|
11
|
+
* so a document never loses data by passing through the editor.
|
|
12
|
+
*
|
|
13
|
+
* Headings 1–3 render as h2–h4: the document title is the page's h1.
|
|
14
|
+
*/
|
|
15
|
+
|
|
16
|
+
/** Attributes every block node has. */
|
|
17
|
+
const blockAttributes = {
|
|
18
|
+
id: { default: null, keepOnSplit: false },
|
|
19
|
+
suggestion: { default: null, rendered: false },
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
function blockAttrs(attrs: Record<string, unknown>, extra: Record<string, unknown> = {}) {
|
|
23
|
+
return mergeAttributes({ "data-block-id": attrs.id ?? undefined, ...extra })
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
export const DocumentNode = Node.create({
|
|
27
|
+
name: "doc",
|
|
28
|
+
topNode: true,
|
|
29
|
+
content: "block+",
|
|
30
|
+
})
|
|
31
|
+
|
|
32
|
+
export const TextNode = Node.create({
|
|
33
|
+
name: "text",
|
|
34
|
+
group: "inline",
|
|
35
|
+
})
|
|
36
|
+
|
|
37
|
+
export const Paragraph = Node.create({
|
|
38
|
+
name: "paragraph",
|
|
39
|
+
group: "block",
|
|
40
|
+
content: "inline*",
|
|
41
|
+
priority: 1000,
|
|
42
|
+
addAttributes: () => blockAttributes,
|
|
43
|
+
parseHTML: () => [{ tag: "p" }],
|
|
44
|
+
renderHTML: ({ node }) => ["p", blockAttrs(node.attrs, { "data-type": "paragraph" }), 0],
|
|
45
|
+
})
|
|
46
|
+
|
|
47
|
+
export const Heading = Node.create({
|
|
48
|
+
name: "heading",
|
|
49
|
+
group: "block",
|
|
50
|
+
content: "inline*",
|
|
51
|
+
defining: true,
|
|
52
|
+
addAttributes: () => ({ ...blockAttributes, level: { default: 1 } }),
|
|
53
|
+
parseHTML: () => [
|
|
54
|
+
{ tag: "h2", attrs: { level: 1 } },
|
|
55
|
+
{ tag: "h3", attrs: { level: 2 } },
|
|
56
|
+
{ tag: "h4", attrs: { level: 3 } },
|
|
57
|
+
],
|
|
58
|
+
renderHTML: ({ node }) => [
|
|
59
|
+
`h${Number(node.attrs.level) + 1}`,
|
|
60
|
+
blockAttrs(node.attrs, { "data-type": "heading", "data-level": node.attrs.level }),
|
|
61
|
+
0,
|
|
62
|
+
],
|
|
63
|
+
})
|
|
64
|
+
|
|
65
|
+
export const Quote = Node.create({
|
|
66
|
+
name: "quote",
|
|
67
|
+
group: "block",
|
|
68
|
+
content: "inline*",
|
|
69
|
+
defining: true,
|
|
70
|
+
addAttributes: () => blockAttributes,
|
|
71
|
+
parseHTML: () => [{ tag: "blockquote" }],
|
|
72
|
+
renderHTML: ({ node }) => ["blockquote", blockAttrs(node.attrs, { "data-type": "quote" }), 0],
|
|
73
|
+
})
|
|
74
|
+
|
|
75
|
+
export const CodeBlock = Node.create({
|
|
76
|
+
name: "codeBlock",
|
|
77
|
+
group: "block",
|
|
78
|
+
content: "text*",
|
|
79
|
+
marks: "",
|
|
80
|
+
code: true,
|
|
81
|
+
defining: true,
|
|
82
|
+
addAttributes: () => ({ ...blockAttributes, language: { default: null } }),
|
|
83
|
+
parseHTML: () => [{ tag: "pre", preserveWhitespace: "full" }],
|
|
84
|
+
renderHTML: ({ node }) => [
|
|
85
|
+
"pre",
|
|
86
|
+
blockAttrs(node.attrs, { "data-type": "code", "data-language": node.attrs.language ?? undefined }),
|
|
87
|
+
["code", 0],
|
|
88
|
+
],
|
|
89
|
+
})
|
|
90
|
+
|
|
91
|
+
/** A bulleted or numbered item; `level` 0–2. Numbering is a decoration (lists.ts). */
|
|
92
|
+
export const ListItem = Node.create({
|
|
93
|
+
name: "listItem",
|
|
94
|
+
group: "block",
|
|
95
|
+
content: "inline*",
|
|
96
|
+
defining: true,
|
|
97
|
+
addAttributes: () => ({ ...blockAttributes, kind: { default: "bullet" }, level: { default: 0 } }),
|
|
98
|
+
parseHTML: () => [{ tag: "div[data-type=list-item]" }],
|
|
99
|
+
renderHTML: ({ node }) => [
|
|
100
|
+
"div",
|
|
101
|
+
blockAttrs(node.attrs, { "data-type": "list-item", "data-kind": node.attrs.kind, "data-level": node.attrs.level }),
|
|
102
|
+
0,
|
|
103
|
+
],
|
|
104
|
+
})
|
|
105
|
+
|
|
106
|
+
/** A checklist item; `level` 0–2. The checkbox is a node view (doc-editor). */
|
|
107
|
+
export const CheckItem = Node.create({
|
|
108
|
+
name: "checkItem",
|
|
109
|
+
group: "block",
|
|
110
|
+
content: "inline*",
|
|
111
|
+
defining: true,
|
|
112
|
+
addAttributes: () => ({ ...blockAttributes, level: { default: 0 }, checked: { default: false } }),
|
|
113
|
+
parseHTML: () => [{ tag: "div[data-type=check-item]" }],
|
|
114
|
+
renderHTML: ({ node }) => [
|
|
115
|
+
"div",
|
|
116
|
+
blockAttrs(node.attrs, {
|
|
117
|
+
"data-type": "check-item",
|
|
118
|
+
"data-level": node.attrs.level,
|
|
119
|
+
"data-checked": node.attrs.checked ? "true" : "false",
|
|
120
|
+
}),
|
|
121
|
+
0,
|
|
122
|
+
],
|
|
123
|
+
})
|
|
124
|
+
|
|
125
|
+
export const Divider = Node.create({
|
|
126
|
+
name: "divider",
|
|
127
|
+
group: "block",
|
|
128
|
+
atom: true,
|
|
129
|
+
selectable: true,
|
|
130
|
+
addAttributes: () => blockAttributes,
|
|
131
|
+
parseHTML: () => [{ tag: "hr" }],
|
|
132
|
+
renderHTML: ({ node }) => ["hr", blockAttrs(node.attrs, { "data-type": "divider" })],
|
|
133
|
+
})
|
|
134
|
+
|
|
135
|
+
/** A block a later milestone edits (callout, table, record, plugin…): kept whole, shown as a placeholder. */
|
|
136
|
+
export const UnknownBlock = Node.create<{ label: (blockType: string) => string }>({
|
|
137
|
+
name: "unknownBlock",
|
|
138
|
+
group: "block",
|
|
139
|
+
atom: true,
|
|
140
|
+
selectable: true,
|
|
141
|
+
draggable: false,
|
|
142
|
+
addOptions: () => ({ label: (blockType: string) => blockType }),
|
|
143
|
+
addAttributes: () => ({ ...blockAttributes, data: { default: null, rendered: false } }),
|
|
144
|
+
parseHTML: () => [{ tag: "div[data-type=unknown-block]" }],
|
|
145
|
+
renderHTML({ node }) {
|
|
146
|
+
const blockType = String(node.attrs.data?.type ?? "")
|
|
147
|
+
return [
|
|
148
|
+
"div",
|
|
149
|
+
blockAttrs(node.attrs, {
|
|
150
|
+
"data-type": "unknown-block",
|
|
151
|
+
"data-block-type": blockType,
|
|
152
|
+
"data-label": this.options.label(blockType),
|
|
153
|
+
}),
|
|
154
|
+
]
|
|
155
|
+
},
|
|
156
|
+
})
|
|
157
|
+
|
|
158
|
+
export const HardBreak = Node.create({
|
|
159
|
+
name: "hardBreak",
|
|
160
|
+
group: "inline",
|
|
161
|
+
inline: true,
|
|
162
|
+
selectable: false,
|
|
163
|
+
parseHTML: () => [{ tag: "br" }],
|
|
164
|
+
renderHTML: () => ["br"],
|
|
165
|
+
addKeyboardShortcuts() {
|
|
166
|
+
return { "Shift-Enter": () => this.editor.commands.insertContent({ type: this.name }) }
|
|
167
|
+
},
|
|
168
|
+
})
|
|
169
|
+
|
|
170
|
+
/** E.26: a merge field, one character for the caret; node-views.tsx draws the chip. */
|
|
171
|
+
export const Field = Node.create({
|
|
172
|
+
name: "field",
|
|
173
|
+
group: "inline",
|
|
174
|
+
inline: true,
|
|
175
|
+
atom: true,
|
|
176
|
+
selectable: true,
|
|
177
|
+
addAttributes: () => ({
|
|
178
|
+
path: { default: "" },
|
|
179
|
+
label: { default: "" },
|
|
180
|
+
required: { default: null },
|
|
181
|
+
perDocument: { default: null },
|
|
182
|
+
}),
|
|
183
|
+
parseHTML: () => [{ tag: "span[data-field]" }],
|
|
184
|
+
renderHTML: ({ node }) => [
|
|
185
|
+
"span",
|
|
186
|
+
{ "data-field": node.attrs.path, title: node.attrs.path, class: "wy-mf" },
|
|
187
|
+
node.attrs.label || node.attrs.path,
|
|
188
|
+
],
|
|
189
|
+
})
|
|
190
|
+
|
|
191
|
+
/** E.42: an inline formula in TeX. KaTeX renders it in M3; until then it shows its source. */
|
|
192
|
+
export const MathInline = Node.create({
|
|
193
|
+
name: "mathInline",
|
|
194
|
+
group: "inline",
|
|
195
|
+
inline: true,
|
|
196
|
+
atom: true,
|
|
197
|
+
selectable: true,
|
|
198
|
+
addAttributes: () => ({ tex: { default: "" } }),
|
|
199
|
+
parseHTML: () => [{ tag: "span[data-math]" }],
|
|
200
|
+
renderHTML: ({ node }) => ["span", { "data-math": "", dir: "ltr", class: "wy-math" }, node.attrs.tex],
|
|
201
|
+
})
|
|
202
|
+
|
|
203
|
+
/* --------------------------------------------------------------- Marks */
|
|
204
|
+
|
|
205
|
+
const simpleMark = (name: string, tag: string, extra: Record<string, string> = {}) =>
|
|
206
|
+
Mark.create({
|
|
207
|
+
name,
|
|
208
|
+
parseHTML: () => [{ tag }],
|
|
209
|
+
renderHTML: () => [tag, extra, 0],
|
|
210
|
+
})
|
|
211
|
+
|
|
212
|
+
/** Bold renders at 600, never 700 (decision 3.6). */
|
|
213
|
+
export const Bold = Mark.create({
|
|
214
|
+
name: "bold",
|
|
215
|
+
parseHTML: () => [{ tag: "strong" }, { tag: "b" }],
|
|
216
|
+
renderHTML: () => ["strong", 0],
|
|
217
|
+
})
|
|
218
|
+
export const Italic = simpleMark("italic", "em")
|
|
219
|
+
export const Underline = simpleMark("underline", "u")
|
|
220
|
+
export const Strike = simpleMark("strike", "s")
|
|
221
|
+
// Code doesn't exclude other marks: the contract allows bold code, and the
|
|
222
|
+
// editor must not drop a mark a document already has.
|
|
223
|
+
export const Code = Mark.create({
|
|
224
|
+
name: "code",
|
|
225
|
+
code: true,
|
|
226
|
+
parseHTML: () => [{ tag: "code" }],
|
|
227
|
+
renderHTML: () => ["code", 0],
|
|
228
|
+
})
|
|
229
|
+
|
|
230
|
+
export const Link = Mark.create({
|
|
231
|
+
name: "link",
|
|
232
|
+
inclusive: false,
|
|
233
|
+
addAttributes: () => ({ href: { default: "" }, recordRef: { default: null, rendered: false } }),
|
|
234
|
+
parseHTML: () => [{ tag: "a[href]", getAttrs: (el) => ({ href: (el as HTMLElement).getAttribute("href") }) }],
|
|
235
|
+
renderHTML: ({ mark }) => ["a", { href: mark.attrs.href, rel: "noopener noreferrer", target: "_blank" }, 0],
|
|
236
|
+
})
|
|
237
|
+
|
|
238
|
+
/** E.25: one highlight colour. */
|
|
239
|
+
export const Highlight = simpleMark("highlight", "mark", { "data-type": "highlight" })
|
|
240
|
+
|
|
241
|
+
/* Marks later milestones give a UI (comments M5, suggestions M5, per-document parts M7). */
|
|
242
|
+
export const CommentMark = Mark.create({
|
|
243
|
+
name: "comment",
|
|
244
|
+
inclusive: false,
|
|
245
|
+
excludes: "",
|
|
246
|
+
addAttributes: () => ({ threadId: { default: "" } }),
|
|
247
|
+
parseHTML: () => [{ tag: "span[data-comment]" }],
|
|
248
|
+
renderHTML: ({ mark }) => ["span", { "data-comment": mark.attrs.threadId }, 0],
|
|
249
|
+
})
|
|
250
|
+
// Neither suggestion mark carries on into what is typed next to it: Suggesting
|
|
251
|
+
// mode marks new text itself, and Editing must not hide typing inside a mark the draft strips.
|
|
252
|
+
export const Insertion = Mark.create({
|
|
253
|
+
name: "insertion",
|
|
254
|
+
inclusive: false,
|
|
255
|
+
excludes: "deletion",
|
|
256
|
+
addAttributes: () => ({ suggestionId: { default: "" } }),
|
|
257
|
+
parseHTML: () => [{ tag: "ins" }],
|
|
258
|
+
renderHTML: ({ mark }) => ["ins", { "data-suggestion": mark.attrs.suggestionId }, 0],
|
|
259
|
+
})
|
|
260
|
+
export const Deletion = Mark.create({
|
|
261
|
+
name: "deletion",
|
|
262
|
+
inclusive: false,
|
|
263
|
+
excludes: "insertion",
|
|
264
|
+
addAttributes: () => ({ suggestionId: { default: "" } }),
|
|
265
|
+
parseHTML: () => [{ tag: "del" }],
|
|
266
|
+
renderHTML: ({ mark }) => ["del", { "data-suggestion": mark.attrs.suggestionId }, 0],
|
|
267
|
+
})
|
|
268
|
+
export const PerDocument = Mark.create({
|
|
269
|
+
name: "perDocument",
|
|
270
|
+
parseHTML: () => [{ tag: "span[data-per-document]" }],
|
|
271
|
+
renderHTML: () => ["span", { "data-per-document": "" }, 0],
|
|
272
|
+
})
|
|
273
|
+
|
|
274
|
+
/** In schema order; the contract's marks come out of the editor in this order. */
|
|
275
|
+
export const MARK_ORDER = [
|
|
276
|
+
"link",
|
|
277
|
+
"bold",
|
|
278
|
+
"italic",
|
|
279
|
+
"underline",
|
|
280
|
+
"strike",
|
|
281
|
+
"code",
|
|
282
|
+
"highlight",
|
|
283
|
+
"comment",
|
|
284
|
+
"insertion",
|
|
285
|
+
"deletion",
|
|
286
|
+
"perDocument",
|
|
287
|
+
] as const
|
|
288
|
+
|
|
289
|
+
export const schemaExtensions = [
|
|
290
|
+
DocumentNode,
|
|
291
|
+
TextNode,
|
|
292
|
+
Paragraph,
|
|
293
|
+
Heading,
|
|
294
|
+
Quote,
|
|
295
|
+
CodeBlock,
|
|
296
|
+
ListItem,
|
|
297
|
+
CheckItem,
|
|
298
|
+
Divider,
|
|
299
|
+
UnknownBlock,
|
|
300
|
+
...richSchemaExtensions,
|
|
301
|
+
HardBreak,
|
|
302
|
+
Field,
|
|
303
|
+
MathInline,
|
|
304
|
+
Link,
|
|
305
|
+
Bold,
|
|
306
|
+
Italic,
|
|
307
|
+
Underline,
|
|
308
|
+
Strike,
|
|
309
|
+
Code,
|
|
310
|
+
Highlight,
|
|
311
|
+
CommentMark,
|
|
312
|
+
Insertion,
|
|
313
|
+
Deletion,
|
|
314
|
+
PerDocument,
|
|
315
|
+
]
|
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
"use client"
|
|
2
|
+
|
|
3
|
+
import * as React from "react"
|
|
4
|
+
|
|
5
|
+
import type { Inline, RecordRef } from "./contract"
|
|
6
|
+
import { EDITOR_LABELS, type EditorLabels } from "./labels"
|
|
7
|
+
|
|
8
|
+
/** What a Record block shows (E.16): the record as the reader may see it. */
|
|
9
|
+
export interface RecordView {
|
|
10
|
+
/** The record type's name, e.g. "Invoice". */
|
|
11
|
+
typeLabel: string
|
|
12
|
+
/** "INV-1042 · Example Clinic" */
|
|
13
|
+
title: string
|
|
14
|
+
subtitle?: string
|
|
15
|
+
/** A formatted amount, e.g. "JOD 301.600". */
|
|
16
|
+
amount?: string
|
|
17
|
+
status?: { label: string; tone: "success" | "warning" | "destructive" | "info" | "secondary" }
|
|
18
|
+
/** Where the record opens. */
|
|
19
|
+
href?: string
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
/** What a Chart block draws: one series of labelled values. */
|
|
23
|
+
export interface ChartData {
|
|
24
|
+
points: { label: string; value: number }[]
|
|
25
|
+
/** What the values are, for the table view and screen readers. */
|
|
26
|
+
valueLabel?: string
|
|
27
|
+
/** What the series covers, e.g. "Last 6 months". */
|
|
28
|
+
subtitle?: string
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export interface UploadedFile {
|
|
32
|
+
fileId: string
|
|
33
|
+
/** Where the file is served, for images. */
|
|
34
|
+
url: string
|
|
35
|
+
name: string
|
|
36
|
+
size: number
|
|
37
|
+
mime: string
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* How rich blocks reach live data and storage. The editor never fetches on its
|
|
42
|
+
* own: the screen passes these in, and every call is answered within the
|
|
43
|
+
* reader's permissions (E.16, E.31). `null` from a resolver means the reader
|
|
44
|
+
* may not see it.
|
|
45
|
+
*/
|
|
46
|
+
export interface EditorServices {
|
|
47
|
+
resolveRecord?: (ref: RecordRef) => Promise<RecordView | null>
|
|
48
|
+
loadChart?: (source: { query: string; params?: Record<string, string> }) => Promise<ChartData | null>
|
|
49
|
+
uploadFile?: (file: File) => Promise<UploadedFile>
|
|
50
|
+
/** The download address of a stored file. */
|
|
51
|
+
fileUrl?: (fileId: string) => string
|
|
52
|
+
/** What a Chart block can read from, for its source menu. */
|
|
53
|
+
chartSources?: { key: string; label: string }[]
|
|
54
|
+
/** What a Record block can point at, for its record picker. */
|
|
55
|
+
recordTypes?: { key: string; label: string }[]
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/**
|
|
59
|
+
* Preview with a record (E.12): each field's value for that record, by path.
|
|
60
|
+
* `null` is a missing value, flagged on the error tint (E.27).
|
|
61
|
+
*/
|
|
62
|
+
export interface FieldPreview {
|
|
63
|
+
/** "INV-1042 · Example Clinic" */
|
|
64
|
+
label: string
|
|
65
|
+
values: Record<string, string | null>
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
interface ServicesValue {
|
|
69
|
+
services: EditorServices
|
|
70
|
+
labels: EditorLabels
|
|
71
|
+
/** Set while previewing with a record; fields then show values, not chips. */
|
|
72
|
+
preview?: FieldPreview | null
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
const ServicesContext = React.createContext<ServicesValue>({ services: {}, labels: EDITOR_LABELS })
|
|
76
|
+
|
|
77
|
+
export function EditorServicesProvider({ services, labels, preview = null, children }: ServicesValue & { children: React.ReactNode }) {
|
|
78
|
+
const value = React.useMemo(() => ({ services, labels, preview }), [services, labels, preview])
|
|
79
|
+
return <ServicesContext.Provider value={value}>{children}</ServicesContext.Provider>
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
export function useEditorServices(): ServicesValue {
|
|
83
|
+
return React.useContext(ServicesContext)
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
/** Inline content as plain text; a merge field shows as {{its label}}. */
|
|
87
|
+
export function inlineText(content: Inline[] | null | undefined): string {
|
|
88
|
+
return (content ?? [])
|
|
89
|
+
.map((run) => (run.type === "text" ? run.text : run.type === "break" ? "\n" : run.type === "math" ? run.tex : `{{${run.label || run.path}}}`))
|
|
90
|
+
.join("")
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
/** Plain text back to inline content, keeping `{{label}}` fields that were there before. */
|
|
94
|
+
export function textToInline(text: string, previous: Inline[] | null | undefined): Inline[] {
|
|
95
|
+
const fields = new Map((previous ?? []).filter((r) => r.type === "field").map((r) => [`{{${(r as { label: string; path: string }).label || (r as { path: string }).path}}}`, r]))
|
|
96
|
+
// Scans for the known tokens rather than a {{…}} regex: only fields that were
|
|
97
|
+
// there before come back, and a run of "{" stays linear (CodeQL js/polynomial-redos).
|
|
98
|
+
const out: Inline[] = []
|
|
99
|
+
let from = 0
|
|
100
|
+
let i = text.indexOf("{{")
|
|
101
|
+
while (i !== -1) {
|
|
102
|
+
let token: string | undefined
|
|
103
|
+
for (const key of fields.keys()) {
|
|
104
|
+
if (text.startsWith(key, i)) {
|
|
105
|
+
token = key
|
|
106
|
+
break
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
if (token) {
|
|
110
|
+
if (i > from) out.push({ type: "text", text: text.slice(from, i) })
|
|
111
|
+
out.push(fields.get(token)!)
|
|
112
|
+
from = i + token.length
|
|
113
|
+
i = text.indexOf("{{", from)
|
|
114
|
+
} else {
|
|
115
|
+
i = text.indexOf("{{", i + 1)
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
if (from < text.length) out.push({ type: "text", text: text.slice(from) })
|
|
119
|
+
return out
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
/** "482 KB", "1.2 MB" — Western digits (3.7b). */
|
|
123
|
+
export function formatSize(bytes: number): string {
|
|
124
|
+
if (bytes < 1024) return `${bytes} B`
|
|
125
|
+
if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`
|
|
126
|
+
return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
|
|
127
|
+
}
|
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
import { Extension, type Range } from "@tiptap/core"
|
|
2
|
+
import { PluginKey } from "@tiptap/pm/state"
|
|
3
|
+
import Suggestion, { exitSuggestion, type SuggestionKeyDownProps } from "@tiptap/suggestion"
|
|
4
|
+
|
|
5
|
+
/** What the / menu shows; the React side (slash-menu.tsx) renders it. */
|
|
6
|
+
export interface SlashState {
|
|
7
|
+
open: boolean
|
|
8
|
+
query: string
|
|
9
|
+
range: Range | null
|
|
10
|
+
rect: DOMRect | null
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
export interface SlashOptions {
|
|
14
|
+
onState: (state: SlashState) => void
|
|
15
|
+
/** Returns true when the menu handled the key (arrows, Enter, Esc). */
|
|
16
|
+
onKeyDown: (event: KeyboardEvent) => boolean
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
export const slashKey = new PluginKey("slash")
|
|
20
|
+
|
|
21
|
+
/**
|
|
22
|
+
* Typing / at the start of a line, or after a space, opens every block
|
|
23
|
+
* (EditorInsert). Esc closes it and keeps what was typed.
|
|
24
|
+
*/
|
|
25
|
+
export const SlashCommand = Extension.create<SlashOptions>({
|
|
26
|
+
name: "slashCommand",
|
|
27
|
+
addOptions: () => ({ onState: () => {}, onKeyDown: () => false }),
|
|
28
|
+
addProseMirrorPlugins() {
|
|
29
|
+
const { onState, onKeyDown } = this.options
|
|
30
|
+
const publish = (open: boolean, props?: { query: string; range: Range; clientRect?: (() => DOMRect | null) | null }) =>
|
|
31
|
+
onState({
|
|
32
|
+
open,
|
|
33
|
+
query: props?.query ?? "",
|
|
34
|
+
range: props?.range ?? null,
|
|
35
|
+
rect: props?.clientRect?.() ?? null,
|
|
36
|
+
})
|
|
37
|
+
return [
|
|
38
|
+
Suggestion({
|
|
39
|
+
editor: this.editor,
|
|
40
|
+
pluginKey: slashKey,
|
|
41
|
+
char: "/",
|
|
42
|
+
allowSpaces: false,
|
|
43
|
+
startOfLine: false,
|
|
44
|
+
allowedPrefixes: [" "],
|
|
45
|
+
// Not inside code, where / is just a character.
|
|
46
|
+
allow: ({ state, range }) => state.doc.resolve(range.from).parent.type.name !== "codeBlock",
|
|
47
|
+
items: () => [],
|
|
48
|
+
render: () => ({
|
|
49
|
+
onStart: (props) => publish(true, props),
|
|
50
|
+
onUpdate: (props) => publish(true, props),
|
|
51
|
+
onExit: () => publish(false),
|
|
52
|
+
onKeyDown: ({ event }: SuggestionKeyDownProps) => {
|
|
53
|
+
if (event.key === "Escape") {
|
|
54
|
+
exitSuggestion(this.editor.view, slashKey)
|
|
55
|
+
publish(false)
|
|
56
|
+
return true
|
|
57
|
+
}
|
|
58
|
+
return onKeyDown(event)
|
|
59
|
+
},
|
|
60
|
+
}),
|
|
61
|
+
}),
|
|
62
|
+
]
|
|
63
|
+
},
|
|
64
|
+
})
|