mdrefine 0.2.0-rc.2 → 0.2.0

package/dist/workspace/index.js

@@ -3,10 +3,22 @@ import GithubSlugger from "github-slugger";
 import { decodeNamedCharacterReference } from "decode-named-character-reference";
 import { walk } from "../syntax/walk.js";
 import { fallbackDialect } from "../config/resolve.js";
+import { blockIdentifier } from "../syntax/block-identifier.js";
 import { parse, range, textContent } from "../syntax/parse.js";
 import { headingAttributes, lastLineSource } from "./heading-attributes.js";
 import { createForgejoSlugger, createGiteaSlugger, giteaAnchor } from "./slug.js";
 import { refusal } from "./access.js";
+import { isNotUtf8 } from "./encoding.js";
+/**
+ * Whether a file is Markdown by its name: one ending in `.md` or `.markdown`,
+ * in any letter case, both of which GitHub, Forgejo, and Gitea render.
+ * Discovery selects such files in folders, and their headings are link
+ * targets. For the Obsidian dialect only `.md` counts: Obsidian opens no
+ * other file as a note.
+ */
+export function isMarkdownName(name, dialect) {
+    return (dialect === "obsidian" ? /\.md$/i : /\.(?:md|markdown)$/i).test(name);
+}
 /** GFM's tagfilter makes GitHub show these tags as text; a hard break adds nothing. */
 const github = {
     shownTags: /^<\/?(?:iframe|noembed|noframes|plaintext|script|style|title|textarea|xmp)(?=[\t\n\f\r />])/i,
@@ -250,33 +262,57 @@ function htmlParts(document) {
     });
     return parts;
 }
-/** A target's anchors for Obsidian; none for a target that is not Markdown source. */
+/**
+ * Whether the outline holds a chain of headings that `parts` name, each one
+ * below the one before, within its section: `Setup#Mobile` is a heading
+ * `Mobile` of any lower level after a heading `Setup` and before the next
+ * heading of `Setup`'s level or higher. Every heading that a part names is
+ * tried, so the link is missing only when no such chain exists.
+ */
+function hasHeadingPath(outline, parts) {
+    const named = (names, part) => names.some((name) => name === part || name.toLowerCase() === part.toLowerCase());
+    const below = (part, from, depth) => {
+        for (let at = from; at < outline.length && outline[at].depth > depth; at++)
+            if (named(outline[at].names, parts[part]) &&
+                (part === parts.length - 1 || below(part + 1, at + 1, outline[at].depth)))
+                return true;
+        return false;
+    };
+    return below(0, 0, 0);
+}
+/** A target's anchors for Obsidian. */
 function obsidianAnchors(document) {
     const anchors = {
         headings: new Set(),
         foldedHeadings: new Set(),
+        outline: [],
         blocks: new Set(),
     };
-    if (!document)
-        return anchors;
-    walk(document.tree, "heading", (node) => {
-        const text = textContent(node);
-        anchors.headings.add(text);
-        anchors.foldedHeadings.add(text.toLowerCase());
-    });
-    walk(document.tree, "text", (node) => {
-        const match = /(?:^|\s)\^([A-Za-z0-9-]+)\s*$/.exec(node.value);
-        if (match)
-            anchors.blocks.add(match[1]);
+    const { source } = document;
+    walk(document.tree, (node) => {
+        const block = blockIdentifier(source, node);
+        if (block)
+            anchors.blocks.add(block.id);
+        if (node.type !== "heading")
+            return;
+        // A link may name a heading by the text it shows or as its source writes
+        // it: the heading `` `move` `` is both `move` and `` `move` ``.
+        const first = node.children[0];
+        const written = first ? source.slice(range(first)[0], range(node.children.at(-1))[1]) : "";
+        const names = [...new Set([textContent(node), written])].map(detach);
+        for (const name of names) {
+            anchors.headings.add(name);
+            anchors.foldedHeadings.add(name.toLowerCase());
+        }
+        anchors.outline.push({ depth: node.depth, names });
     });
-    detachAll(anchors.headings, anchors.foldedHeadings, anchors.blocks);
+    // The names are detached already, and so is their lowercase form.
+    detachAll(anchors.blocks);
     return anchors;
 }
-/** A target's anchors for GitHub and CommonMark; none for a target that is not Markdown source. */
+/** A target's anchors for GitHub and CommonMark. */
 function githubAnchors(document) {
     const anchors = { slugs: new Set(), explicit: new Set() };
-    if (!document)
-        return anchors;
     const slugger = new GithubSlugger();
     const parts = htmlParts(document);
     // GitHub numbers the anchors of Markdown and HTML headings together, in
@@ -298,15 +334,13 @@ function githubAnchors(document) {
     detachAll(anchors.slugs, anchors.explicit);
     return anchors;
 }
-/** A target's anchors for Forgejo and Gitea; none for a target that is not Markdown source. */
+/** A target's anchors for Forgejo and Gitea. */
 function forgeAnchors(document) {
     const anchors = {
         forgejoSlugs: new Set(),
         giteaSlugs: new Set(),
         explicit: new Set(),
     };
-    if (!document)
-        return anchors;
     const { source } = document;
     const forgejoSlugger = createForgejoSlugger();
     const giteaSlugger = createGiteaSlugger();
@@ -380,6 +414,13 @@ export function splitDestination(destination) {
         fragment: decode(hash < 0 ? "" : destination.slice(hash + 1)),
     };
 }
+/**
+ * The workspace of `files`, which maps each path, relative to the workspace
+ * root with forward slashes, to a `WorkspaceSource`. Link checks, link
+ * rewriting, and Obsidian wrapping need one. A Markdown target is parsed in
+ * `options.dialect` when a link's fragment needs its anchors, which are kept
+ * and its text is not.
+ */
 export function createWorkspace(files, options = {}) {
     const sources = new Map(Object.entries(files).map(([name, source]) => [
         name.replaceAll("\\", "/").replace(/^\.\//, ""),
@@ -480,25 +521,39 @@ export function createWorkspace(files, options = {}) {
         return foldedDirectories.has(name.toLowerCase());
     }
     const targets = new Map();
+    /** What the host's lookup found, by the matching asked for and the path. */
+    const lookedUp = new Map();
+    /** The sources of the files that the lookup found, by path. */
+    const foundSources = new Map();
+    /** What the host finds at a path that the index does not hold, asked once per path. */
+    function lookup(name, folded) {
+        if (!options.lookup)
+            return undefined;
+        const key = `${folded ? "i" : "s"}:${name}`;
+        if (lookedUp.has(key))
+            return lookedUp.get(key);
+        const result = options.lookup(name, folded);
+        lookedUp.set(key, result);
+        if (result?.type === "file")
+            foundSources.set(result.path, result.source);
+        return result;
+    }
     /**
-     * One group of a target's anchors, from the target read and parsed for it;
-     * nothing keeps the parsed document. A target that is not Markdown source has
-     * no anchors. Undefined for a target that the system refuses to let be read,
-     * which is marked and not read again.
+     * One group of a Markdown target's anchors, from the target read and parsed
+     * for it; nothing keeps the parsed document. Undefined for a target that the
+     * system refuses to let be read, or whose text is not UTF-8, which is marked
+     * and not read again.
      */
-    function compute(target, name, anchors) {
+    function compute(target, value, name, anchors) {
         if (target.unreadable)
             return undefined;
-        const value = sources.get(name);
-        if (value === null || value === undefined || !/\.md$/i.test(name))
-            return anchors(null);
         let source;
         try {
             source = typeof value === "function" ? value() : value;
         }
         catch (error) {
             // The file exists, but its anchors are unknown; any other error is a fault.
-            if (!refusal(error))
+            if (!refusal(error) && !isNotUtf8(error))
                 throw error;
             target.unreadable = true;
             return undefined;
@@ -515,20 +570,30 @@ export function createWorkspace(files, options = {}) {
      * page script also retries a fragment lowercased, and its anchors are.
      */
     function hasAnchor(name, dialect, fragment, anchor) {
+        const value = sources.has(name) ? sources.get(name) : foundSources.get(name);
+        // Only a Markdown file's anchors are known. Other files take fragments of
+        // their own, such as an image's `#gh-dark-mode-only`, a PDF's `#page=2`, or
+        // a forge's line range `#L10-L20` in source code, which are not checked; so
+        // is a file that is linted as Markdown only because it was named.
+        if (value === null || value === undefined || !isMarkdownName(name, dialect))
+            return true;
         let target = targets.get(name);
         if (!target)
             targets.set(name, (target = {}));
         if (dialect === "obsidian") {
-            const anchors = target.obsidian ?? compute(target, name, obsidianAnchors);
+            const anchors = target.obsidian ?? compute(target, value, name, obsidianAnchors);
             if (!anchors)
                 return undefined;
             target.obsidian = anchors;
-            return fragment.startsWith("^")
-                ? anchors.blocks.has(fragment.slice(1))
-                : anchors.headings.has(fragment) || anchors.foldedHeadings.has(fragment.toLowerCase());
+            if (fragment.startsWith("^"))
+                return anchors.blocks.has(fragment.slice(1));
+            if (anchors.headings.has(fragment) || anchors.foldedHeadings.has(fragment.toLowerCase()))
+                return true;
+            // A path of headings, each below the one before, such as `Setup#Mobile`.
+            return fragment.includes("#") && hasHeadingPath(anchors.outline, fragment.split("#"));
         }
         if (dialect === "forgejo" || dialect === "gitea") {
-            const forge = target.forge ?? compute(target, name, forgeAnchors);
+            const forge = target.forge ?? compute(target, value, name, forgeAnchors);
             if (!forge)
                 return undefined;
             target.forge = forge;
@@ -537,7 +602,7 @@ export function createWorkspace(files, options = {}) {
                 return true;
             return forge.explicit.has(anchor) || forge.explicit.has(fragment);
         }
-        const anchors = target.github ?? compute(target, name, githubAnchors);
+        const anchors = target.github ?? compute(target, value, name, githubAnchors);
         if (!anchors)
             return undefined;
         target.github = anchors;
@@ -639,7 +704,7 @@ export function createWorkspace(files, options = {}) {
         ...(options.strictLineBreaks !== undefined
             ? { strictLineBreaks: options.strictLineBreaks }
             : {}),
-        resolve(source, destination, dialect) {
+        resolve(source, destination, dialect, wiki = false) {
             if (/^[a-z][a-z\d+.-]*:/i.test(destination) || destination.startsWith("//"))
                 return { status: "external" };
             source = source.replaceAll("\\", "/");
@@ -664,6 +729,22 @@ export function createWorkspace(files, options = {}) {
             const partial = folded && !vault && rootFolders.length > 0;
             // Whether Obsidian would look in a place of that vault outside the workspace.
             let beyond = false;
+            // A link on the disk that the path leads through to outside the workspace root.
+            let leaves;
+            /** What the host finds at a path that the index does not hold. */
+            const look = (name, file = true) => {
+                const found = lookup(name, folded);
+                if (found?.type === "file") {
+                    if (file)
+                        candidates.add(found.path);
+                }
+                else if (found?.type === "directory")
+                    directory ||= !wiki;
+                else if (found?.type === "outside")
+                    leaves ??= found.through;
+                else if (found?.type === "unreadable")
+                    blocking.add(found.at);
+            };
             const add = (candidate) => {
                 const normalized = path.posix.normalize(candidate);
                 if (normalized === ".." || normalized.startsWith("../")) {
@@ -681,10 +762,11 @@ export function createWorkspace(files, options = {}) {
                     outside ??=
                         namesMatching(bare)[0] ??
                             (path.posix.extname(bare) ? undefined : namesMatching(`${bare}.md`)[0]) ??
-                            (isDirectory(bare, true) ? bare : undefined);
+                            (!wiki && isDirectory(bare, true) ? bare : undefined);
                     return;
                 }
-                if (isDirectory(bare, folded))
+                // Obsidian links a wikilink to a note or a file, never to a folder.
+                if (!wiki && isDirectory(bare, folded))
                     directory = true;
                 const above = unreadableAbove(bare, folded);
                 if (above !== undefined)
@@ -692,14 +774,23 @@ export function createWorkspace(files, options = {}) {
                 if (!folded) {
                     if (sources.has(normalized))
                         candidates.add(normalized);
+                    // A path that ends with a slash names a folder only.
+                    else if (!directory)
+                        look(bare, bare === normalized);
                     return;
                 }
                 // Names differing only by case all count, so such vaults report ambiguity.
+                const before = candidates.size;
                 for (const name of namesMatching(normalized))
                     candidates.add(name);
                 if (!path.posix.extname(normalized))
                     for (const name of namesMatching(`${normalized}.md`))
                         candidates.add(name);
+                if (candidates.size === before && !directory) {
+                    look(bare);
+                    if (!path.posix.extname(bare))
+                        look(`${bare}.md`);
+                }
             };
             if (!targetPath)
                 add(source);
@@ -750,6 +841,14 @@ export function createWorkspace(files, options = {}) {
             // A match is uncertain when a place that could not be looked in may hold a
             // note that Obsidian would choose instead, or as well.
             const uncertain = [...(unsearched ? hidden : obstructed ? blocking : []), ...unseen];
+            // The tool reads nothing outside the workspace root, where the link leads.
+            if (candidates.size === 0 && leaves !== undefined)
+                return {
+                    status: "unreadable",
+                    unreadable: [leaves],
+                    leavesRoot: leaves,
+                    ...(vault ? { vault } : {}),
+                };
             if (candidates.size === 0 && (blocking.size > 0 || unsearched || unseen.length > 0))
                 return {
                     status: "unreadable",