@glw907/cairn-cms 0.51.0 → 0.52.1

package/src/lib/components/editor-modes.ts

@@ -0,0 +1,106 @@
+// The iA writing modes: focus mode dims every line outside the caret's paragraph, and typewriter
+// scroll holds the cursor line at vertical center while typing. Client-only, like editor-highlight:
+// MarkdownEditor reaches this module through a dynamic import, so the static @codemirror imports
+// here never enter a server bundle (guarded by the editor-boundary test).
+import {
+  Decoration,
+  EditorView,
+  ViewPlugin,
+  type DecorationSet,
+  type ViewUpdate,
+} from '@codemirror/view';
+import { RangeSetBuilder, type Extension } from '@codemirror/state';
+
+/** An inclusive 0-based line range. */
+export interface LineRange {
+  fromLine: number;
+  toLine: number;
+}
+
+const isBlank = (line: string | undefined) => !line || /^\s*$/.test(line);
+
+/**
+ * The contiguous non-blank block around the caret line, the unit focus mode keeps at full ink.
+ * On a blank line the caret stands alone; the walk clamps at the document edges, and an
+ * out-of-range caret clamps into the document first.
+ */
+export function paragraphRange(lines: string[], caretLine: number): LineRange {
+  const last = Math.max(lines.length - 1, 0);
+  const caret = Math.min(Math.max(caretLine, 0), last);
+  if (isBlank(lines[caret])) return { fromLine: caret, toLine: caret };
+  let fromLine = caret;
+  while (fromLine > 0 && !isBlank(lines[fromLine - 1])) fromLine--;
+  let toLine = caret;
+  while (toLine < last && !isBlank(lines[toLine + 1])) toLine++;
+  return { fromLine, toLine };
+}
+
+const dimLine = Decoration.line({ class: 'cm-cairn-focus-dim' });
+
+// The line cache mirrors editor-highlight's: one full-document read per doc change, so a caret
+// move or scroll rebuilds the viewport decorations from the cached array.
+function docLines(view: EditorView): string[] {
+  const doc = view.state.doc;
+  const lines: string[] = [];
+  for (let n = 1; n <= doc.lines; n++) lines.push(doc.line(n).text);
+  return lines;
+}
+
+function buildFocusDecorations(view: EditorView, lines: string[]): DecorationSet {
+  const builder = new RangeSetBuilder<Decoration>();
+  const caretLine = view.state.doc.lineAt(view.state.selection.main.head).number - 1;
+  const paragraph = paragraphRange(lines, caretLine);
+  for (const { from, to } of view.visibleRanges) {
+    for (let pos = from; pos <= to; ) {
+      const line = view.state.doc.lineAt(pos);
+      const n = line.number - 1;
+      if (n < paragraph.fromLine || n > paragraph.toLine) builder.add(line.from, line.from, dimLine);
+      pos = line.to + 1;
+    }
+  }
+  return builder.finish();
+}
+
+/**
+ * Focus mode: a line class (`cm-cairn-focus-dim`) on every line outside the caret's paragraph.
+ * The class only marks the lines; the dim ink itself lives in the editor theme so the per-theme
+ * `--cairn-focus-dim-ink` variable resolves it.
+ */
+export function focusMode(): Extension {
+  return ViewPlugin.fromClass(
+    class {
+      decorations: DecorationSet;
+      lines: string[];
+      constructor(view: EditorView) {
+        this.lines = docLines(view);
+        this.decorations = buildFocusDecorations(view, this.lines);
+      }
+      update(update: ViewUpdate) {
+        if (update.docChanged) this.lines = docLines(update.view);
+        if (update.docChanged || update.viewportChanged || update.selectionSet)
+          this.decorations = buildFocusDecorations(update.view, this.lines);
+      }
+    },
+    { decorations: (v) => v.decorations },
+  );
+}
+
+/**
+ * Typewriter scroll: on every doc change, recenter the selection head vertically. An update
+ * listener may not dispatch while its update runs, so the recenter is queued as a microtask:
+ * it fires as soon as the update finishes, still ahead of the next paint, where an animation
+ * frame would trail the edit by a frame. The isConnected guard skips a view destroyed in the
+ * queue window.
+ */
+export function typewriterScroll(): Extension {
+  return EditorView.updateListener.of((update) => {
+    if (!update.docChanged) return;
+    const view = update.view;
+    queueMicrotask(() => {
+      if (!view.dom.isConnected) return;
+      view.dispatch({
+        effects: EditorView.scrollIntoView(view.state.selection.main.head, { y: 'center' }),
+      });
+    });
+  });
+}

package/src/lib/components/fonts/iAWriterMono-OFL.txt

@@ -0,0 +1,100 @@
+# iA Writer Typeface
+
+Copyright © 2018 Information Architects Inc. with Reserved Font Name "iA Writer"
+
+# Based on IBM Plex Typeface
+
+Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
+
+# License
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/src/lib/components/markdown-directives.ts

@@ -4,9 +4,11 @@
 
 // A container fence: three or more colons, then an optional name, an optional [label], and
 // optional {attrs}, in remark-directive order. The name is captured so the depth scan below can
-// tell an opener (named) from a closer (bare colons). Matching is tolerant of stray whitespace,
-// the same posture as the leaf form: a slightly off fence should still read as machinery.
-const FENCE = /^\s{0,3}:{3,}\s*([\w-]*)\s*(\[[^\]]*\])?\s*(\{[^}]*\})?\s*$/;
+// tell an opener (named) from a closer (bare colons), and the d flag records each group's span
+// so fenceTokens can split the line without re-parsing. Matching is tolerant of stray
+// whitespace, the same posture as the leaf form: a slightly off fence should still read as
+// machinery.
+const FENCE = /^\s{0,3}(:{3,})\s*([\w-]*)\s*(\[[^\]]*\])?\s*(\{[^}]*\})?\s*$/d;
 const LEAF = /^\s{0,3}::[\w-]+(\[[^\]]*\])?(\{[^}]*\})?\s*$/;
 const INLINE = /(?<![:\w]):[\w-]+\[[^\]]*\](\{[^}]*\})?/g;
 
@@ -22,17 +24,28 @@ export function directiveLineKind(line: string): 'fence' | 'leaf' | null {
   return null;
 }
 
+/** One pass over the document: each line's container depth alongside its fence role. */
+export interface FenceScan {
+  /** The 1-based container depth per line, or null outside any container. */
+  depths: (number | null)[];
+  /** Whether a line opened or closed a container, or null for everything else. A fence-shaped
+   *  line the code-block tracking disowned is null too, so the role array is the one source of
+   *  truth for pairing and no caller re-parses a line the scan already judged. */
+  roles: ('opener' | 'closer' | null)[];
+}
+
 /**
- * The 1-based container depth each line sits at, or null outside any container. A named fence
- * opens a container; a bare fence closes the most recent one (colon counts are not trusted for
- * pairing, since authors vary them). An opener and its closer share the opener's depth, and a
- * line between them carries the depth of its innermost container. Lines inside a fenced code
- * block are plain content, so a documented ::: example cannot open a phantom container running
- * to end of document. Author errors are tolerated: an unmatched closer reads as depth 1 and the
- * count never goes below zero.
+ * Scan the document's container structure in one pass. A named fence opens a container; a bare
+ * fence closes the most recent one (colon counts are not trusted for pairing, since authors
+ * vary them). An opener and its closer share the opener's depth, and a line between them
+ * carries the depth of its innermost container. Lines inside a fenced code block are plain
+ * content, so a documented ::: example cannot open a phantom container running to end of
+ * document. Author errors are tolerated: an unmatched closer reads as depth 1 and the count
+ * never goes below zero.
  */
-export function fenceDepths(lines: string[]): (number | null)[] {
+export function fenceScan(lines: string[]): FenceScan {
   const depths: (number | null)[] = [];
+  const roles: ('opener' | 'closer' | null)[] = [];
   let open = 0;
   // The marker character that opened the current code block, or null outside one. Only a line
   // opening with the same character closes it, so tildes inside a backtick block stay literal.
@@ -43,24 +56,111 @@ export function fenceDepths(lines: string[]): (number | null)[] {
       if (codeMarker === null) codeMarker = code[1][0];
       else if (code[1][0] === codeMarker) codeMarker = null;
       depths.push(open > 0 ? open : null);
+      roles.push(null);
       continue;
     }
     if (codeMarker !== null) {
       depths.push(open > 0 ? open : null);
+      roles.push(null);
       continue;
     }
     const fence = FENCE.exec(line);
     if (!fence) {
       depths.push(open > 0 ? open : null);
-    } else if (fence[1]) {
+      roles.push(null);
+    } else if (fence[2]) {
       open += 1;
       depths.push(open);
+      roles.push('opener');
     } else {
       depths.push(Math.max(open, 1));
+      roles.push('closer');
       if (open > 0) open -= 1;
     }
   }
-  return depths;
+  return { depths, roles };
+}
+
+/** The depth half of {@link fenceScan}, for callers that need no roles. */
+export function fenceDepths(lines: string[]): (number | null)[] {
+  return fenceScan(lines).depths;
+}
+
+/** The inclusive line span of one directive container. */
+export interface ContainerRange {
+  fromLine: number;
+  toLine: number;
+  depth: number;
+}
+
+/**
+ * The innermost container around a caret line, as an inclusive line range, or null outside any
+ * container. Works from the cached scan without re-parsing: the caret line's own depth names
+ * the container (fence rows carry the depth they delimit, so a caret on a fence belongs to
+ * that fence's container), and within a container the only same-depth real fences are its
+ * opener and closer (nested containers sit deeper, siblings sit outside), so the nearest
+ * opener above and the nearest closer below bound the range. The scan's roles already disown a
+ * fence-shaped line inside a code block, so a documented example can never clip the range. An
+ * unclosed container runs to the document end.
+ */
+export function caretContainerRange(scan: FenceScan, caretLine: number): ContainerRange | null {
+  const { depths, roles } = scan;
+  const depth = depths[caretLine] ?? null;
+  if (depth === null) return null;
+  let fromLine = caretLine;
+  for (let i = caretLine; i >= 0; i--) {
+    if (depths[i] === depth && roles[i] === 'opener') {
+      fromLine = i;
+      break;
+    }
+  }
+  let toLine = depths.length - 1;
+  for (let i = caretLine; i < depths.length; i++) {
+    if (depths[i] === depth && roles[i] === 'closer') {
+      toLine = i;
+      break;
+    }
+  }
+  return { fromLine, toLine, depth };
+}
+
+/** One span of a fence line, in line-local offsets: machinery (`mark`) or meaning (`label`). */
+export interface FenceToken {
+  from: number;
+  to: number;
+  kind: 'mark' | 'label';
+}
+
+/**
+ * Split a fence line into machinery and meaning. The colon run, the label's brackets, and the
+ * whole {attrs} group are machinery; the directive name and the label text are meaning, the
+ * parts an editor reads. A bare closer is a single machinery span, and a non-fence line yields
+ * no spans at all.
+ */
+export function fenceTokens(line: string): FenceToken[] {
+  const m = FENCE.exec(line);
+  if (!m?.indices) return [];
+  // A group's span exists whenever the group matched: group 1 (the colons) always does on a
+  // fence, and the optional groups are read only behind their own m[n] guard.
+  const indices = m.indices;
+  const out: FenceToken[] = [];
+  const [colonFrom, colonTo] = indices[1]!;
+  out.push({ from: colonFrom, to: colonTo, kind: 'mark' });
+  if (m[2]) {
+    const [from, to] = indices[2]!;
+    out.push({ from, to, kind: 'label' });
+  }
+  if (m[3]) {
+    const [from, to] = indices[3]!;
+    out.push({ from, to: from + 1, kind: 'mark' });
+    if (to - from > 2) out.push({ from: from + 1, to: to - 1, kind: 'label' });
+    out.push({ from: to - 1, to, kind: 'mark' });
+  }
+  if (m[4]) {
+    const [from, to] = indices[4]!;
+    out.push({ from, to, kind: 'mark' });
+  }
+  return out;
 }
 
 /** Inline directive ranges (`:name[...]{...}`) within a line of text. */