@folijs/core 0.4.0 → 0.6.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.
Files changed (153) hide show
  1. package/CHANGELOG.md +49 -0
  2. package/dist/model/schema.d.ts +9 -1
  3. package/dist/model/schema.d.ts.map +1 -1
  4. package/dist/model/schema.js +13 -3
  5. package/dist/model/schema.js.map +1 -1
  6. package/dist/state/commands.d.ts +10 -1
  7. package/dist/state/commands.d.ts.map +1 -1
  8. package/dist/state/commands.js +125 -40
  9. package/dist/state/commands.js.map +1 -1
  10. package/dist/state/comments.d.ts.map +1 -1
  11. package/dist/state/comments.js +15 -6
  12. package/dist/state/comments.js.map +1 -1
  13. package/dist/state/controls.d.ts +128 -0
  14. package/dist/state/controls.d.ts.map +1 -0
  15. package/dist/state/controls.js +1459 -0
  16. package/dist/state/controls.js.map +1 -0
  17. package/dist/state/editor.d.ts +86 -1
  18. package/dist/state/editor.d.ts.map +1 -1
  19. package/dist/state/editor.js +169 -41
  20. package/dist/state/editor.js.map +1 -1
  21. package/dist/state/fields.d.ts +79 -0
  22. package/dist/state/fields.d.ts.map +1 -0
  23. package/dist/state/fields.js +398 -0
  24. package/dist/state/fields.js.map +1 -0
  25. package/dist/state/fieldupdate.d.ts +178 -0
  26. package/dist/state/fieldupdate.d.ts.map +1 -0
  27. package/dist/state/fieldupdate.js +1574 -0
  28. package/dist/state/fieldupdate.js.map +1 -0
  29. package/dist/state/find.d.ts +68 -0
  30. package/dist/state/find.d.ts.map +1 -0
  31. package/dist/state/find.js +397 -0
  32. package/dist/state/find.js.map +1 -0
  33. package/dist/state/history.d.ts +12 -1
  34. package/dist/state/history.d.ts.map +1 -1
  35. package/dist/state/history.js +43 -7
  36. package/dist/state/history.js.map +1 -1
  37. package/dist/state/index.d.ts +15 -5
  38. package/dist/state/index.d.ts.map +1 -1
  39. package/dist/state/index.js +13 -3
  40. package/dist/state/index.js.map +1 -1
  41. package/dist/state/links.d.ts.map +1 -1
  42. package/dist/state/links.js +30 -19
  43. package/dist/state/links.js.map +1 -1
  44. package/dist/state/mark.d.ts.map +1 -1
  45. package/dist/state/mark.js +8 -1
  46. package/dist/state/mark.js.map +1 -1
  47. package/dist/state/navigation.d.ts +70 -0
  48. package/dist/state/navigation.d.ts.map +1 -0
  49. package/dist/state/navigation.js +226 -0
  50. package/dist/state/navigation.js.map +1 -0
  51. package/dist/state/notes.d.ts +94 -0
  52. package/dist/state/notes.d.ts.map +1 -0
  53. package/dist/state/notes.js +444 -0
  54. package/dist/state/notes.js.map +1 -0
  55. package/dist/state/pictures.d.ts +51 -0
  56. package/dist/state/pictures.d.ts.map +1 -0
  57. package/dist/state/pictures.js +140 -0
  58. package/dist/state/pictures.js.map +1 -0
  59. package/dist/state/review.d.ts +13 -4
  60. package/dist/state/review.d.ts.map +1 -1
  61. package/dist/state/review.js +223 -29
  62. package/dist/state/review.js.map +1 -1
  63. package/dist/state/sections.d.ts +101 -0
  64. package/dist/state/sections.d.ts.map +1 -0
  65. package/dist/state/sections.js +472 -0
  66. package/dist/state/sections.js.map +1 -0
  67. package/dist/state/selection.d.ts +12 -1
  68. package/dist/state/selection.d.ts.map +1 -1
  69. package/dist/state/selection.js +12 -0
  70. package/dist/state/selection.js.map +1 -1
  71. package/dist/state/state.d.ts +2 -0
  72. package/dist/state/state.d.ts.map +1 -1
  73. package/dist/state/state.js +4 -0
  74. package/dist/state/state.js.map +1 -1
  75. package/dist/state/stories.d.ts +41 -0
  76. package/dist/state/stories.d.ts.map +1 -0
  77. package/dist/state/stories.js +243 -0
  78. package/dist/state/stories.js.map +1 -0
  79. package/dist/state/tablecommands.d.ts +77 -0
  80. package/dist/state/tablecommands.d.ts.map +1 -0
  81. package/dist/state/tablecommands.js +675 -0
  82. package/dist/state/tablecommands.js.map +1 -0
  83. package/dist/state/tables.d.ts +110 -0
  84. package/dist/state/tables.d.ts.map +1 -0
  85. package/dist/state/tables.js +730 -0
  86. package/dist/state/tables.js.map +1 -0
  87. package/dist/state/track.d.ts +23 -0
  88. package/dist/state/track.d.ts.map +1 -1
  89. package/dist/state/track.js +113 -15
  90. package/dist/state/track.js.map +1 -1
  91. package/dist/state/word.d.ts +78 -16
  92. package/dist/state/word.d.ts.map +1 -1
  93. package/dist/state/word.js +231 -11
  94. package/dist/state/word.js.map +1 -1
  95. package/dist/state/wordclip.d.ts +15 -6
  96. package/dist/state/wordclip.d.ts.map +1 -1
  97. package/dist/state/wordclip.js +213 -18
  98. package/dist/state/wordclip.js.map +1 -1
  99. package/dist/state/wordformat.d.ts +10 -2
  100. package/dist/state/wordformat.d.ts.map +1 -1
  101. package/dist/state/wordformat.js +98 -17
  102. package/dist/state/wordformat.js.map +1 -1
  103. package/dist/v3/document.d.ts +237 -7
  104. package/dist/v3/document.d.ts.map +1 -1
  105. package/dist/v3/document.js +314 -15
  106. package/dist/v3/document.js.map +1 -1
  107. package/dist/v3/index.d.ts +2 -2
  108. package/dist/v3/index.d.ts.map +1 -1
  109. package/dist/v3/index.js +2 -2
  110. package/dist/v3/index.js.map +1 -1
  111. package/dist/v3/migrate.d.ts +2 -2
  112. package/dist/v3/migrate.d.ts.map +1 -1
  113. package/dist/v3/resolve.d.ts +57 -5
  114. package/dist/v3/resolve.d.ts.map +1 -1
  115. package/dist/v3/resolve.js +224 -16
  116. package/dist/v3/resolve.js.map +1 -1
  117. package/dist/v3/schema.d.ts +6 -0
  118. package/dist/v3/schema.d.ts.map +1 -1
  119. package/dist/v3/schema.js +254 -8
  120. package/dist/v3/schema.js.map +1 -1
  121. package/package.json +1 -1
  122. package/src/model/schema.ts +18 -2
  123. package/src/state/commands.ts +121 -32
  124. package/src/state/comments.ts +14 -6
  125. package/src/state/controls.ts +1596 -0
  126. package/src/state/editor.ts +292 -46
  127. package/src/state/fields.ts +432 -0
  128. package/src/state/fieldupdate.ts +1770 -0
  129. package/src/state/find.ts +510 -0
  130. package/src/state/history.ts +51 -7
  131. package/src/state/index.ts +157 -0
  132. package/src/state/links.ts +27 -17
  133. package/src/state/mark.ts +8 -1
  134. package/src/state/navigation.ts +305 -0
  135. package/src/state/notes.ts +519 -0
  136. package/src/state/numeric-pictures.word.json +172 -0
  137. package/src/state/pictures.ts +168 -0
  138. package/src/state/review.ts +265 -31
  139. package/src/state/sections.ts +571 -0
  140. package/src/state/selection.ts +15 -1
  141. package/src/state/state.ts +5 -0
  142. package/src/state/stories.ts +285 -0
  143. package/src/state/tablecommands.ts +741 -0
  144. package/src/state/tables.ts +761 -0
  145. package/src/state/track.ts +128 -16
  146. package/src/state/word.ts +276 -13
  147. package/src/state/wordclip.ts +231 -32
  148. package/src/state/wordformat.ts +96 -14
  149. package/src/v3/document.ts +572 -16
  150. package/src/v3/index.ts +21 -0
  151. package/src/v3/migrate.ts +2 -2
  152. package/src/v3/resolve.ts +289 -21
  153. package/src/v3/schema.ts +278 -9
@@ -0,0 +1,432 @@
1
+ /**
2
+ * Word's fields in the editor (ADR-0007, 11.8): finding them over a tree of markers, what a view
3
+ * hides or shows of them, and the selection rules (a field is selected whole when the selection
4
+ * crosses its markers; the caret never rests in what is hidden). Their instructions and results:
5
+ * `fieldupdate.ts`.
6
+ */
7
+ import type { Mark, Node } from "../model/index.js";
8
+ import { type Selection, TextSelection } from "./selection.js";
9
+ import { type Command, type EditorState, Plugin, PluginKey } from "./state.js";
10
+ import { storyBody } from "./word.js";
11
+
12
+ /** A field of a tree, partners found by nesting depth. Positions are the tree's. */
13
+ export interface Field {
14
+ /** Before its `fieldStart`. */
15
+ from: number;
16
+ /** After its `fieldEnd`. */
17
+ to: number;
18
+ /** Before its `fieldSeparator`; null without one. */
19
+ separator: number | null;
20
+ /** Where the code range ends: the separator, or the `fieldEnd`. */
21
+ codeEnd: number;
22
+ resultFrom: number;
23
+ /** Before the `fieldEnd`. */
24
+ resultTo: number;
25
+ /** The instruction, nested fields in the code standing as their results. */
26
+ instruction: string;
27
+ /** Its first word in capitals (`PAGE`, `TOC`). */
28
+ name: string;
29
+ /** The result as text: tabs, line breaks as "\n", paragraphs as "\r"; deleted text left out. */
30
+ result: string;
31
+ locked: boolean;
32
+ /** Its start is a tracked deletion. */
33
+ deleted: boolean;
34
+ /** The look of its code's first part, and of its result's first text. */
35
+ codeMarks: readonly Mark[] | null;
36
+ resultMarks: readonly Mark[] | null;
37
+ /** The field around it, if any. */
38
+ parent: Field | null;
39
+ /** It stands in `parent`'s code. */
40
+ inCode: boolean;
41
+ }
42
+
43
+ const known = new WeakMap<Node, readonly Field[]>();
44
+ const isDeleted = (node: Node) => node.marks.some((m) => m.type.name === "deletion");
45
+
46
+ /** The fields of `tree` in document order (outer before inner). Unpaired markers are ignored. */
47
+ export function fieldsIn(tree: Node): readonly Field[] {
48
+ const cached = known.get(tree);
49
+ if (cached) return cached;
50
+ interface Open {
51
+ field: Field;
52
+ code: string;
53
+ text: string;
54
+ /** A paragraph ended inside its result, to be counted before more text. */
55
+ broke: boolean;
56
+ }
57
+ const fields: Field[] = [];
58
+ const open: Open[] = [];
59
+ const add = (text: string) => {
60
+ const top = open[open.length - 1];
61
+ if (!top || !text) return;
62
+ if (top.field.separator === null) top.code += text;
63
+ else {
64
+ if (top.broke) top.text += "\r";
65
+ top.broke = false;
66
+ top.text += text;
67
+ }
68
+ };
69
+ tree.descendants((node, pos) => {
70
+ if (node.isTextblock) {
71
+ for (const entry of open) if (entry.field.separator !== null) entry.broke = true;
72
+ return true;
73
+ }
74
+ if (!node.isInline) return true;
75
+ const top = open[open.length - 1];
76
+ switch (node.type.name) {
77
+ case "fieldStart":
78
+ open.push({
79
+ code: "",
80
+ text: "",
81
+ broke: false,
82
+ field: {
83
+ from: pos,
84
+ to: pos,
85
+ separator: null,
86
+ codeEnd: pos,
87
+ resultFrom: pos,
88
+ resultTo: pos,
89
+ instruction: "",
90
+ name: "",
91
+ result: "",
92
+ locked: node.attrs.locked === true,
93
+ deleted: isDeleted(node),
94
+ codeMarks: null,
95
+ resultMarks: null,
96
+ parent: top?.field ?? null,
97
+ inCode: !!top && top.field.separator === null,
98
+ },
99
+ });
100
+ break;
101
+ case "fieldCode":
102
+ if (top?.field.separator === null) {
103
+ top.code += String(node.attrs.text ?? "");
104
+ top.field.codeMarks ??= node.marks;
105
+ }
106
+ break;
107
+ case "fieldSeparator":
108
+ if (top?.field.separator === null) top.field.separator = pos;
109
+ break;
110
+ case "fieldEnd": {
111
+ const entry = open.pop();
112
+ if (!entry) break;
113
+ const { field } = entry;
114
+ field.to = pos + 1;
115
+ field.codeEnd = field.separator ?? pos;
116
+ field.resultFrom = field.separator === null ? pos : field.separator + 1;
117
+ field.resultTo = pos;
118
+ field.instruction = entry.code.trim();
119
+ field.name = (/^\S*/.exec(field.instruction)?.[0] ?? "").toUpperCase();
120
+ field.result = entry.text;
121
+ fields.push(field);
122
+ add(entry.text);
123
+ const outer = open[open.length - 1]?.field;
124
+ if (outer && outer.separator !== null) outer.resultMarks ??= field.resultMarks;
125
+ break;
126
+ }
127
+ case "text":
128
+ if (!isDeleted(node)) {
129
+ add(node.text ?? "");
130
+ if (top && top.field.separator !== null) top.field.resultMarks ??= node.marks;
131
+ }
132
+ break;
133
+ case "tab":
134
+ if (!isDeleted(node)) add("\t");
135
+ break;
136
+ case "hardBreak":
137
+ if (!isDeleted(node)) add("\n");
138
+ break;
139
+ default:
140
+ }
141
+ return false;
142
+ });
143
+ fields.sort((a, b) => a.from - b.from);
144
+ if (open.length) {
145
+ const lost = new Set(open.map((entry) => entry.field));
146
+ for (const field of fields)
147
+ if (field.parent && lost.has(field.parent)) {
148
+ field.parent = null;
149
+ field.inCode = false;
150
+ }
151
+ }
152
+ known.set(tree, fields);
153
+ return fields;
154
+ }
155
+
156
+ /** The innermost field with `pos` strictly inside it. */
157
+ export function fieldAround(tree: Node, pos: number): Field | null {
158
+ let found: Field | null = null;
159
+ for (const field of fieldsIn(tree)) {
160
+ if (field.from >= pos) break;
161
+ if (pos < field.to) found = field;
162
+ }
163
+ return found;
164
+ }
165
+
166
+ /** The innermost field holding the node at `pos`: the field a marker there belongs to. */
167
+ export function fieldOfPart(tree: Node, pos: number): Field | null {
168
+ let found: Field | null = null;
169
+ for (const field of fieldsIn(tree)) {
170
+ if (field.from > pos) break;
171
+ if (pos < field.to) found = field;
172
+ }
173
+ return found;
174
+ }
175
+
176
+ /** Field markers a caret walking over a paragraph meets. */
177
+ export const isFieldPart = (node: Node | null | undefined): boolean =>
178
+ !!node && FIELD_PARTS.has(node.type.name);
179
+ const FIELD_PARTS = new Set(["fieldStart", "fieldCode", "fieldSeparator", "fieldEnd"]);
180
+
181
+ // ---------- what is shown ----------
182
+
183
+ /** How a view draws a paragraph's inline nodes, by index. */
184
+ export interface FieldDisplay {
185
+ /** Nodes not drawn: what is in a code range or, with codes shown, in a result. */
186
+ hidden: ReadonlySet<number>;
187
+ /** With codes shown: the brace a field marker draws. */
188
+ braces: ReadonlyMap<number, "{" | "}">;
189
+ /** Nothing of the paragraph shows, its mark included: it takes no room. */
190
+ gone: boolean;
191
+ }
192
+
193
+ const NOTHING: FieldDisplay = { hidden: new Set(), braces: new Map(), gone: false };
194
+ /** Inline nodes with nothing to draw of their own. */
195
+ const UNSEEN: ReadonlySet<string> = new Set([
196
+ ...FIELD_PARTS,
197
+ "bookmarkStart",
198
+ "bookmarkEnd",
199
+ "commentStart",
200
+ "commentEnd",
201
+ "commentReference",
202
+ "controlStart",
203
+ "controlEnd",
204
+ ]);
205
+
206
+ /** @internal Whether an inline node draws nothing: text runs on across it. */
207
+ export const isUnseen = (node: Node): boolean => UNSEEN.has(node.type.name);
208
+
209
+ /**
210
+ * What a view draws of paragraphs in document order, each given as its inline nodes' type names.
211
+ * A code range is hidden; with `codes`, the codes show between braces and the results are hidden.
212
+ */
213
+ export function fieldDisplay(
214
+ paragraphs: readonly (readonly string[])[],
215
+ codes: boolean,
216
+ ): FieldDisplay[] {
217
+ // The markers that have partners, as paragraph and index.
218
+ const key = (p: number, i: number) => p * 65_536 + i;
219
+ const roles = new Map<number, "start" | "separator" | "end">();
220
+ const stack: { at: number; separator: number | null }[] = [];
221
+ paragraphs.forEach((types, p) => {
222
+ types.forEach((type, i) => {
223
+ if (type === "fieldStart") stack.push({ at: key(p, i), separator: null });
224
+ else if (type === "fieldSeparator") {
225
+ const top = stack[stack.length - 1];
226
+ if (top && top.separator === null) top.separator = key(p, i);
227
+ } else if (type === "fieldEnd") {
228
+ const top = stack.pop();
229
+ if (!top) return;
230
+ roles.set(top.at, "start");
231
+ if (top.separator !== null) roles.set(top.separator, "separator");
232
+ roles.set(key(p, i), "end");
233
+ }
234
+ });
235
+ });
236
+ if (!roles.size) return paragraphs.map(() => NOTHING);
237
+ const phases: ("code" | "result")[] = [];
238
+ let inCode = 0;
239
+ let inResult = 0;
240
+ const concealed = () => (codes ? inResult > 0 : inCode > 0);
241
+ return paragraphs.map((types, p) => {
242
+ const hidden = new Set<number>();
243
+ const braces = new Map<number, "{" | "}">();
244
+ const openAtStart = concealed();
245
+ let seen = false;
246
+ types.forEach((type, i) => {
247
+ const role = roles.get(key(p, i));
248
+ if (role === "start") {
249
+ if (codes && !inResult) braces.set(i, "{");
250
+ phases.push("code");
251
+ inCode++;
252
+ } else if (role === "separator") {
253
+ inCode--;
254
+ if (codes && !inResult) braces.set(i, "}");
255
+ inResult++;
256
+ phases[phases.length - 1] = "result";
257
+ } else if (role === "end") {
258
+ if (phases.pop() === "code") {
259
+ inCode--;
260
+ if (codes && !inResult) braces.set(i, "}");
261
+ } else inResult--;
262
+ } else if (concealed()) hidden.add(i);
263
+ else if (!UNSEEN.has(type) || (codes && type === "fieldCode")) seen = true;
264
+ });
265
+ const gone = openAtStart && concealed() && !seen && !braces.size;
266
+ return hidden.size || braces.size || gone ? { hidden, braces, gone } : NOTHING;
267
+ });
268
+ }
269
+
270
+ // ---------- codes shown, and the selection ----------
271
+
272
+ const key = new PluginKey<boolean>("fields");
273
+
274
+ /** Whether fields show their codes (one setting for the document, its stories included). */
275
+ export const fieldCodesShown = (state: EditorState): boolean =>
276
+ key.getState(storyBody(state)?.state ?? state) === true;
277
+
278
+ /** Word's Alt+F9: shows or hides every field's code. */
279
+ export const toggleFieldCodes: Command = (state, dispatch) => {
280
+ const body = storyBody(state);
281
+ if (body) return dispatch ? body.run(toggleFieldCodes) : body.can(toggleFieldCodes);
282
+ const shown = key.getState(state);
283
+ if (shown === undefined) return false;
284
+ dispatch?.(state.tr.setMeta(key, !shown));
285
+ return true;
286
+ };
287
+
288
+ /** Whether `pos` is somewhere the caret cannot be seen, in `field`. */
289
+ function concealedIn(field: Field, pos: number, codes: boolean): boolean {
290
+ // With codes shown the result is hidden and the code is drawn, not text to type in.
291
+ return pos > field.from && (codes ? pos < field.to : pos <= field.codeEnd);
292
+ }
293
+
294
+ /** `pos`, out of every hidden range: on in the direction of travel. */
295
+ function outOfHidden(fields: readonly Field[], at: number, forward: boolean, codes: boolean) {
296
+ let pos = at;
297
+ for (let again = true; again; ) {
298
+ again = false;
299
+ for (const field of fields) {
300
+ if (!concealedIn(field, pos, codes)) continue;
301
+ if (!forward) pos = field.from;
302
+ else pos = codes || field.separator === null ? field.to : field.separator + 1;
303
+ again = true;
304
+ }
305
+ }
306
+ return pos;
307
+ }
308
+
309
+ /**
310
+ * A caret at the very start or end of a result, outside the field: it looks the same, and what is
311
+ * typed there is not lost to the next update (Word's caret does this at a field's edges).
312
+ */
313
+ function outOfResultEdge(fields: readonly Field[], at: number, forward: boolean): number {
314
+ let pos = at;
315
+ for (let again = true; again; ) {
316
+ again = false;
317
+ for (const field of fields) {
318
+ if (field.separator === null || pos < field.resultFrom || pos > field.resultTo) continue;
319
+ const atEnd = pos === field.resultTo && (pos !== field.resultFrom || forward);
320
+ if (!atEnd && pos !== field.resultFrom) continue;
321
+ pos = atEnd ? field.to : field.from;
322
+ again = true;
323
+ }
324
+ }
325
+ return pos;
326
+ }
327
+
328
+ /** Whether only what takes no room stands between two positions of a paragraph. */
329
+ export function sameSpot(tree: Node, a: number, b: number): boolean {
330
+ const from = Math.min(a, b);
331
+ const to = Math.max(a, b);
332
+ if (tree.resolve(from).parent !== tree.resolve(to).parent) return false;
333
+ let seen = false;
334
+ tree.nodesBetween(from, to, (node) => {
335
+ if (node.isInline && !UNSEEN.has(node.type.name)) seen = true;
336
+ return !seen;
337
+ });
338
+ return !seen;
339
+ }
340
+
341
+ /**
342
+ * The selection `selection` should be, if it should change: out of hidden ranges, and a range with
343
+ * one end inside a field and the other outside it grown over the whole field (or, when the head
344
+ * comes back into it from outside, stopped before it).
345
+ */
346
+ function settled(state: EditorState, previous: Selection, sameDoc: boolean): Selection | null {
347
+ const { selection, doc } = state;
348
+ if (!(selection instanceof TextSelection)) return null;
349
+ const fields = fieldsIn(doc);
350
+ if (!fields.length) return null;
351
+ const codes = fieldCodesShown(state);
352
+ const movedOn = selection.head >= previous.head;
353
+ let head = outOfHidden(fields, selection.head, movedOn, codes);
354
+ // Not after an edit: text typed in place of a whole result goes on inside it.
355
+ if (selection.empty && sameDoc && !codes) head = outOfResultEdge(fields, head, movedOn);
356
+ let anchor = selection.empty
357
+ ? head
358
+ : outOfHidden(fields, selection.anchor, selection.anchor > selection.head, codes);
359
+ // A browser reads the two sides of a marker as one place: the range has not moved.
360
+ if (sameDoc && !selection.empty) {
361
+ if (!previous.empty && sameSpot(doc, head, previous.head)) head = previous.head;
362
+ if (sameSpot(doc, anchor, previous.anchor)) anchor = previous.anchor;
363
+ }
364
+ const inside = (field: Field, pos: number) => pos > field.from && pos < field.to;
365
+ if (anchor !== head)
366
+ for (let again = true, rounds = 0; again && rounds < 64; rounds++) {
367
+ again = false;
368
+ for (const field of fields) {
369
+ if (field.deleted || inside(field, anchor) === inside(field, head)) continue;
370
+ again = true;
371
+ if (inside(field, anchor)) anchor = head > field.from ? field.from : field.to;
372
+ else {
373
+ // The head coming back over the field it had taken in stops on the other side.
374
+ const [near, far] =
375
+ anchor <= field.from ? [field.to, field.from] : [field.from, field.to];
376
+ const back = anchor <= field.from ? previous.head >= near : previous.head <= near;
377
+ head = !sameSpot(doc, head, near) && back ? far : near;
378
+ }
379
+ }
380
+ }
381
+ return anchor === selection.anchor && head === selection.head
382
+ ? null
383
+ : TextSelection.create(doc, anchor, head);
384
+ }
385
+
386
+ /**
387
+ * Where a caret at `pos` really is on its way forward or back: past the field markers and hidden
388
+ * ranges next to it, up to what can be seen. `pos` itself when no field part is next to it.
389
+ */
390
+ export function caretStop(state: EditorState, pos: number, forward: boolean): number {
391
+ const { doc } = state;
392
+ const next = ($pos: ReturnType<Node["resolve"]>) => (forward ? $pos.nodeAfter : $pos.nodeBefore);
393
+ if (!isFieldPart(next(doc.resolve(pos)))) return pos;
394
+ const fields = fieldsIn(doc);
395
+ // With codes shown a field is one step: its code is drawn, not text to walk through.
396
+ if (fieldCodesShown(state)) {
397
+ const whole = fields.find((f) => (forward ? f.from : f.to) === pos);
398
+ return whole ? (forward ? whole.to : whole.from) : pos;
399
+ }
400
+ let at = pos;
401
+ for (;;) {
402
+ const out = outOfHidden(fields, at, forward, false);
403
+ const node = next(doc.resolve(out));
404
+ if (!node || !UNSEEN.has(node.type.name)) return out;
405
+ at = out + (forward ? 1 : -1);
406
+ }
407
+ }
408
+
409
+ /** The fields' state, and the selection kept to their rules. */
410
+ export function fieldsPlugin(): Plugin<boolean> {
411
+ return new Plugin({
412
+ key,
413
+ state: {
414
+ init: () => false,
415
+ apply: (tr, shown) => (tr.getMeta(key) as boolean | undefined) ?? shown,
416
+ },
417
+ appendTransaction(_transactions, before, after) {
418
+ if (
419
+ before.selection.eq(after.selection) &&
420
+ before.doc === after.doc &&
421
+ fieldCodesShown(before) === fieldCodesShown(after)
422
+ )
423
+ return null;
424
+ const next = settled(after, before.selection, before.doc === after.doc);
425
+ return next ? after.tr.setSelection(next) : null;
426
+ },
427
+ });
428
+ }
429
+
430
+ /** The whole of `field` as a selection. */
431
+ export const fieldSelection = (tree: Node, field: Field): Selection =>
432
+ TextSelection.create(tree, field.from, field.to);