@liminis/editor 0.5.0 → 0.6.0

package/dist/markdown/parse.js

@@ -566,6 +566,313 @@ function splitTextNodeEscapes(node, normalizedText) {
     flushRun(runStart, parts.length);
     return result;
 }
+// Any id shape the resolver and the reference-side wiki-link parser already
+// accept — ULID included — gated by the resolver's own position rule: the
+// caret must start a token (line-start or preceded by whitespace), and the
+// captured id must run to end of line (trailing spaces/tabs allowed). This is
+// what makes badge and resolver agree by construction for every id form with
+// no carve-out (#124/FR-002, #126/FR-001) — ULID no longer gets a permissive,
+// position-free rule of its own; Crockford Base32 (ULID's charset) is already
+// a strict subset of this charset, so every ULID that satisfies this position
+// rule keeps badging unchanged (see ADR-122's amendments).
+//
+// The charset excludes `*` (in addition to `#`/`]`/whitespace) to match
+// `liminis-app/src/main/fs.ts`'s `ANCHOR_LINE_PATTERN`
+// (`[^\s\]#*]`) as actually implemented for `liminis#1114` — that resolver
+// pattern narrowed *both* its wrapped and unwrapped branches to exclude `*`,
+// unlike the stale, pre-implementation regex the #127 issue body quoted.
+// `_` stays allowed: excluding it would break the NanoID-with-underscore
+// case (#124/FR-004), and the resolver's own pattern allows it too.
+const WIDE_ID_CHAR = /[^\s\]#*]/;
+// A symmetric emphasis wrapper (`**`, `__`, `*`, `_`) around `^<id>` at line
+// end badges too (#127), so this rule agrees with the widened resolver
+// (`liminis#1114`) for wrapped ids the same way it already agrees for plain
+// ones. The wrapped id charset matches the resolver's actual wrapped-branch
+// charset (`[^\s\]#*]+?` in
+// `ANCHOR_LINE_PATTERN`) — same as `WIDE_ID_CHAR` above; kept as a distinct,
+// separately-named constant since the wrapped and unwrapped charsets are
+// independent knobs in the resolver's pattern and could diverge again.
+// Longest markers first so a `**`/`__` candidate is tried before its `*`/`_`
+// prefix.
+const WRAPPED_ID_CHAR = /[^\s\]#*]/;
+const WRAPPER_MARKERS = ['**', '__', '*', '_'];
+const isSpaceOrTab = (ch) => ch === ' ' || ch === '\t';
+/**
+ * Look for one of `WRAPPER_MARKERS` immediately before `offset` in the raw,
+ * pre-parse `normalizedText`, itself preceded by whitespace or document
+ * start — the same left-boundary rule already applied to a bare caret, just
+ * one token further out. Returns the matched marker string, or
+ * `null` if none of them fit.
+ *
+ * This only needs to look *outside* the current text node (at `offset`, the
+ * node's own start) because a caret can only be adjacent to a *structural*
+ * wrapper marker when it is the first character of its own text node: if a
+ * literal `**`/`_` sat before the caret inside the same text node, that run
+ * of emphasis markers never found a matching closer and CommonMark left it
+ * as ordinary text, which the plain (non-wrapped) left-boundary check
+ * already handles correctly with no wrapper logic involved.
+ */
+function matchWrapperMarkerBefore(normalizedText, offset) {
+    for (const marker of WRAPPER_MARKERS) {
+        const markerStart = offset - marker.length;
+        if (markerStart < 0)
+            continue;
+        if (normalizedText.slice(markerStart, offset) !== marker)
+            continue;
+        if (markerStart === 0 || /\s/.test(normalizedText[markerStart - 1]))
+            return marker;
+    }
+    return null;
+}
+/**
+ * Find every block-anchor match in `decoded` — any id shape, position-gated
+ * by the resolver's own rule, with no separate ULID carve-out (#126) — at
+ * each unescaped `^`, left to right.
+ *
+ * The boundary checks peek one character outside this text node's own
+ * `decoded`/`source` span — into `normalizedText` at `start - 1` (left) or
+ * from `end` onward (right) — rather than inspecting sibling AST nodes: the
+ * raw source character is equivalent and needs no tree traversal (see Plan
+ * stage's "Key Decisions"). This is what lets the rule correctly refuse a
+ * match immediately followed by more prose on the same line, even when that
+ * prose lives in a following sibling node (e.g. a wiki-link right after the
+ * id), and correctly accept one immediately after a preceding sibling ends
+ * with whitespace.
+ *
+ * A symmetric emphasis wrapper (`**`, `__`, `*`, `_`) around the id at line
+ * end also badges (#127), using the same outside-the-node peek:
+ * when the caret is the first character of this text node (`i === 0`) and
+ * the plain whitespace/start rule doesn't hold, it peeks backward for a
+ * wrapper marker; when one is found, the id must then run to this text
+ * node's own end (`idEnd === decoded.length`) and be followed immediately
+ * by the *same* marker string before the usual trailing-whitespace/EOL
+ * check. Both `i === 0` and `idEnd === decoded.length` are load-bearing
+ * invariants, not incidental: they are exactly the positions at which a
+ * *structural* wrapper marker (one CommonMark parsed as real emphasis,
+ * rather than literal text left over from an unmatched delimiter run) can
+ * be adjacent to the caret/id at all — see `matchWrapperMarkerBefore`.
+ */
+function findBlockAnchorMatches(decoded, parts, normalizedText, start, end) {
+    const matches = [];
+    let cursor = 0;
+    for (let i = 0; i < decoded.length; i++) {
+        if (i < cursor)
+            continue;
+        if (decoded[i] !== '^' || parts[i].escaped)
+            continue;
+        // Left boundary: preceded by whitespace, or true document start — or,
+        // when the caret is the first character of this text node, a symmetric
+        // emphasis wrapper immediately before it (#127). That `i === 0` gate is
+        // load-bearing: it's the only position at which a *structural* wrapper
+        // marker (one CommonMark actually parsed as emphasis, not literal text)
+        // can sit immediately before the caret — see `matchWrapperMarkerBefore`.
+        const leftOk = i > 0 ? /\s/.test(decoded[i - 1]) : start === 0 || /\s/.test(normalizedText[start - 1]);
+        let wrapMarker = null;
+        if (!leftOk) {
+            if (i === 0)
+                wrapMarker = matchWrapperMarkerBefore(normalizedText, start);
+            if (!wrapMarker)
+                continue;
+        }
+        // Id capture: greedy run of non-whitespace, non-`]`, non-`#`, non-`*`,
+        // tested against `decoded` rather than raw source. A backslash-escaped `#` or
+        // `]` inside an id (`^abc\#def`) therefore truncates the capture one
+        // character earlier than a regex run over raw, undecoded file text
+        // would (the resolver's own matching model) — but this never produces a
+        // badge/resolver disagreement: whatever follows the truncation point is
+        // identical, non-whitespace content in both the decoded and raw views
+        // (backslash-escaping only ever turns `\X` into `X`, never anything
+        // into whitespace), so the right-boundary check below rejects the match
+        // in both models alike whenever this truncation is reachable. See the
+        // "does not badge an id containing a backslash-escaped delimiter"
+        // regression test.
+        //
+        // When wrapped, `WRAPPED_ID_CHAR` applies instead of `WIDE_ID_CHAR` (see
+        // their definitions) — currently identical charsets, kept as separate
+        // named constants since the resolver's wrapped/unwrapped branches are
+        // independent knobs that could diverge again.
+        const idCharTest = wrapMarker ? WRAPPED_ID_CHAR : WIDE_ID_CHAR;
+        let idEnd = i + 1;
+        while (idEnd < decoded.length && idCharTest.test(decoded[idEnd]))
+            idEnd++;
+        // Empty capture: the character right after `^` is already whitespace
+        // (or end of text), e.g. `a ^ b`, `a ^`, `x ^\t`. `a ^ b` would also be
+        // rejected by the right-boundary check below regardless (the trailing
+        // `b` isn't end-of-line), but a bare trailing caret like `a ^` or
+        // `x ^\t` reaches true end-of-line/end-of-document and would otherwise
+        // pass that check with an empty id — this guard is what actually stops
+        // that case. See "does not badge a bare trailing caret" regression test.
+        if (idEnd === i + 1)
+            continue;
+        // Right boundary: only trailing spaces/tabs before end of line or end of
+        // document — peeking past this node's own end into `normalizedText` if
+        // the capture runs all the way to it.
+        //
+        // When wrapped, the closer is required instead: the id capture must run
+        // all the way to this text node's own end (the mirror image of the
+        // `i === 0` left-boundary gate — a structural closer can only be
+        // adjacent to the id there), the exact same marker string that opened
+        // it must appear immediately after, and only trailing spaces/tabs and
+        // end-of-line/end-of-document may follow that. No fallback to the
+        // unwrapped rule on mismatch — an asymmetric wrapper (e.g. `**^id_`)
+        // must never badge with a corrupted id (#127/SC-003).
+        let rightOk;
+        if (wrapMarker) {
+            if (idEnd !== decoded.length)
+                continue;
+            const closerEnd = end + wrapMarker.length;
+            if (normalizedText.slice(end, closerEnd) !== wrapMarker)
+                continue;
+            let pos = closerEnd;
+            while (pos < normalizedText.length && isSpaceOrTab(normalizedText[pos]))
+                pos++;
+            rightOk = pos === normalizedText.length || normalizedText[pos] === '\n';
+        }
+        else {
+            let j = idEnd;
+            while (j < decoded.length && isSpaceOrTab(decoded[j]))
+                j++;
+            if (j < decoded.length) {
+                rightOk = decoded[j] === '\n';
+            }
+            else {
+                let pos = end;
+                while (pos < normalizedText.length && isSpaceOrTab(normalizedText[pos]))
+                    pos++;
+                rightOk = pos === normalizedText.length || normalizedText[pos] === '\n';
+            }
+        }
+        if (!rightOk)
+            continue;
+        matches.push({ index: i, length: idEnd - i });
+        cursor = idEnd;
+    }
+    return matches;
+}
+/**
+ * Split a single `text` node into `[before, blockAnchor, after, ...]`
+ * siblings wherever it contains a {@link findBlockAnchorMatches} match,
+ * mirroring `splitTextNodeEscapes`'s decode-replay + position-mapping
+ * machinery exactly (including its conservative bail-out when replayed
+ * decoding doesn't exactly reproduce `node.value`, e.g. a character
+ * reference in the span) rather than duplicating it (#122).
+ *
+ * Because this only ever inspects a `text` node's own `value` (plus, for
+ * the boundary checks, one character immediately outside it), it can
+ * never see into `inlineCode`, `code`, `inlineMath`, `wikiLink` or
+ * `wikiEmbed` node content — none of those are `text` nodes once mdast has
+ * typed them — which satisfies the code-span/fenced-code/math edge case and
+ * FR-006 by construction, with no "protected ranges" pre-parse machinery
+ * needed.
+ */
+function splitTextNodeBlockAnchors(node, normalizedText) {
+    const start = node.position?.start?.offset;
+    const end = node.position?.end?.offset;
+    if (start == null || end == null) {
+        return [node];
+    }
+    const source = normalizedText.slice(start, end);
+    const { decoded, parts } = replayDecodeEscapes(source);
+    if (decoded !== node.value) {
+        return [node];
+    }
+    // A caret whose leading `^` came from a backslash escape (`\^`) in the
+    // source is never a match candidate — `findBlockAnchorMatches` checks
+    // `parts[i].escaped` itself before trying either branch. `decoded` has
+    // already resolved `\^` to a plain `^`, so nothing downstream can tell the
+    // two apart on its own; an author who deliberately escaped a caret meant
+    // literal text, not an anchor, and `stringify.ts`'s `blockAnchor` handler
+    // always emits a bare `^id` with no escaping, so badging it would silently
+    // drop the escape on the next save.
+    const matches = findBlockAnchorMatches(decoded, parts, normalizedText, start, end);
+    if (matches.length === 0) {
+        return [node];
+    }
+    const startPos = node.position.start;
+    // Per-offset line/column within `source`, mirroring splitTextNodeEscapes.
+    const positionAt = new Array(source.length + 1);
+    {
+        let line = startPos.line;
+        let column = startPos.column;
+        positionAt[0] = { line, column };
+        for (let i = 0; i < source.length; i++) {
+            if (source[i] === '\n') {
+                line += 1;
+                column = 1;
+            }
+            else {
+                column += 1;
+            }
+            positionAt[i + 1] = { line, column };
+        }
+    }
+    const makePosition = (srcStart, srcEnd) => ({
+        start: { ...positionAt[srcStart - start], offset: srcStart },
+        end: { ...positionAt[srcEnd - start], offset: srcEnd },
+    });
+    const makeTextNode = (value, srcStart, srcEnd) => ({
+        type: 'text',
+        value,
+        position: makePosition(srcStart, srcEnd),
+    });
+    const result = [];
+    let cursor = 0; // index into `parts`/`decoded`
+    for (const match of matches) {
+        const matchStart = match.index;
+        const matchEnd = matchStart + match.length;
+        if (matchStart > cursor) {
+            const value = parts.slice(cursor, matchStart).map((p) => p.char).join('');
+            result.push(makeTextNode(value, start + parts[cursor].srcStart, start + parts[matchStart - 1].srcEnd));
+        }
+        // Captured from raw `source`, not `decoded`: stringify.ts's `blockAnchor`
+        // handler re-emits `^${node.id}` verbatim with no escaping, so the id
+        // must already carry any backslash the author wrote (e.g. `^ab\_cd`) or
+        // that escape is silently dropped on the next save — a round-trip
+        // corruption distinct from, and not covered by, the decoded-vs-raw
+        // truncation reasoning above (that reasoning only shows the *match
+        // boundary* never diverges; it says nothing about what ends up inside
+        // an id that does match).
+        result.push({
+            type: 'blockAnchor',
+            id: source.slice(parts[matchStart + 1].srcStart, parts[matchEnd - 1].srcEnd),
+            position: makePosition(start + parts[matchStart].srcStart, start + parts[matchEnd - 1].srcEnd),
+        });
+        cursor = matchEnd;
+    }
+    if (cursor < parts.length) {
+        const value = parts.slice(cursor, parts.length).map((p) => p.char).join('');
+        result.push(makeTextNode(value, start + parts[cursor].srcStart, start + parts[parts.length - 1].srcEnd));
+    }
+    return result;
+}
+/**
+ * Walk the tree and split every `text` node containing a block anchor (see
+ * `splitTextNodeBlockAnchors`) into siblings. Run after `resolveWikiEmbeds`/
+ * `annotateEmphasisMarkers` (so this never sees wiki-link/embed target text —
+ * FR-006) and before `splitEscapedPunctuation` (so that pass still sees, and
+ * can process, any escaped punctuation left in this split's "before"/"after"
+ * text siblings) (#122).
+ */
+function splitBlockAnchors(root, normalizedText) {
+    function walk(node) {
+        if (!node || typeof node !== 'object')
+            return node;
+        if (node.children && Array.isArray(node.children)) {
+            const children = [];
+            for (const child of node.children) {
+                if (child?.type === 'text') {
+                    children.push(...splitTextNodeBlockAnchors(child, normalizedText));
+                }
+                else {
+                    children.push(walk(child));
+                }
+            }
+            return { ...node, children };
+        }
+        return node;
+    }
+    return walk(root);
+}
 /**
  * Walk the tree and split every `text` node containing a force-escaped
  * character (see `splitTextNodeEscapes`) into siblings. Run last, after all
@@ -684,6 +991,9 @@ export function parseMarkdown(text, _options = {}) {
     root = resolveWikiEmbeds(root);
     // Post-process: annotate emphasis/strong marker characters from original source
     root = annotateEmphasisMarkers(root, text, replacements);
+    // Post-process: split a bare `^ULID` block anchor out of its surrounding
+    // text so it can render as a badge instead of raw text (#122)
+    root = splitBlockAnchors(root, normalizedText);
     // Post-process: split out backslash-escaped punctuation so its escape can
     // be carried through Lexical and restored at stringify time (#17)
     root = splitEscapedPunctuation(root, normalizedText);

package/dist/markdown/stringify.js

@@ -348,6 +348,11 @@ export function stringifyMarkdown(root, options = {}) {
                         return marker + content + marker;
                     },
                     escapedChar: (node) => `${FORCE_ESCAPE_PLACEHOLDER}${node.value}${FORCE_ESCAPE_PLACEHOLDER}`,
+                    // Block anchor badge (#122): a `blockAnchor` node produced by
+                    // `splitBlockAnchors` in parse.ts always carries exactly the id
+                    // matched from the source, so re-emitting `^id` is lossless by
+                    // construction — no escaping needed, mirroring `wikiLink`/`wikiEmbed`.
+                    blockAnchor: (node) => `^${node.id}`,
                     wikiLink: (node) => `[[${formatWikiLinkBody(node)}]]`,
                     // Transclusion/embed (#119): the `!`-prefixed form of a block-scoped
                     // wiki-link. `formatWikiLinkBody` requires `data.blockId` be present