@tequila99/githuman 0.7.0 → 0.9.0

package/dist/shared/notes/external-assets.js

@@ -0,0 +1,153 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { splitNote } from "./document.js";
+import { destinationRange } from "./references.js";
+import { NOTE_IMAGE_EXTENSIONS } from "./asset-formats.js";
+import { isCredentialFreeWebUrl, webUrlFileName, webUrlLastSegment } from "../utils/web-url.js";
+/** Edits that undo `edits` when applied to the text they produced. */
+export function invertExternalAssetEdits(text, edits) {
+    let delta = 0;
+    return [...edits]
+        .sort((a, b) => a.start - b.start)
+        .map(edit => {
+        const start = edit.start + delta;
+        delta += edit.value.length - (edit.end - edit.start);
+        return {
+            start,
+            end: start + edit.value.length,
+            value: text.slice(edit.start, edit.end)
+        };
+    });
+}
+export function externalAssetOffset(offset, edits) {
+    let delta = 0;
+    for (const edit of [...edits].sort((a, b) => a.start - b.start)) {
+        if (offset < edit.start)
+            break;
+        if (offset < edit.end) {
+            return (edit.start + delta + Math.min(offset - edit.start, edit.value.length));
+        }
+        delta += edit.value.length - (edit.end - edit.start);
+    }
+    return offset + delta;
+}
+function assetDestinations(text, protocol) {
+    const { body } = splitNote(text);
+    const offset = text.length - body.length;
+    const tree = fromMarkdown(body);
+    const uses = new Map();
+    const walk = (node) => {
+        if (node.type === 'imageReference' || node.type === 'linkReference') {
+            const group = uses.get(node.identifier) ?? [];
+            group.push(node.type === 'imageReference');
+            uses.set(node.identifier, group);
+        }
+        if ('children' in node)
+            for (const child of node.children)
+                walk(child);
+    };
+    walk(tree);
+    const result = [];
+    const visit = (node) => {
+        if (node.type === 'image' ||
+            node.type === 'link' ||
+            node.type === 'definition') {
+            const references = node.type === 'definition' ? uses.get(node.identifier) : undefined;
+            const image = node.type === 'image' || references?.some(Boolean);
+            const count = node.type === 'definition' ? (references?.length ?? 0) : 1;
+            const start = node.position?.start.offset;
+            const end = node.position?.end.offset;
+            if (count && start !== undefined && end !== undefined) {
+                try {
+                    const url = new URL(node.url.startsWith('//') ? protocol + node.url : node.url);
+                    if (!isCredentialFreeWebUrl(url))
+                        return;
+                    const extension = webUrlLastSegment(url)
+                        .split('.')
+                        .at(-1)
+                        ?.toLowerCase();
+                    const kind = image
+                        ? 'image'
+                        : extension === 'pdf'
+                            ? 'pdf'
+                            : NOTE_IMAGE_EXTENSIONS.includes(extension ?? '')
+                                ? 'image'
+                                : null;
+                    const range = destinationRange(body.slice(start, end), node.type === 'definition');
+                    if (kind && range) {
+                        const fragment = url.hash;
+                        url.hash = '';
+                        result.push({
+                            url: url.href,
+                            fragment,
+                            kind,
+                            start: offset + start + range[0],
+                            end: offset + start + range[1],
+                            occurrences: count
+                        });
+                    }
+                }
+                catch {
+                    // Invalid destinations are not download candidates.
+                }
+            }
+        }
+        if ('children' in node)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(tree);
+    return result;
+}
+export function externalNoteAssets(text, protocol = 'https:') {
+    const assets = new Map();
+    for (const item of assetDestinations(text, protocol)) {
+        const existing = assets.get(item.url);
+        if (existing) {
+            existing.occurrences += item.occurrences;
+            if (item.kind === 'image')
+                existing.kind = 'image';
+        }
+        else {
+            assets.set(item.url, {
+                url: item.url,
+                kind: item.kind,
+                name: webUrlFileName(new URL(item.url)),
+                occurrences: item.occurrences
+            });
+        }
+    }
+    return [...assets.values()];
+}
+export function replaceExternalNoteAssets(text, replacements, protocol = 'https:') {
+    let result = text;
+    let count = 0;
+    const edits = assetDestinations(text, protocol)
+        .filter(item => replacements.has(item.url))
+        .sort((a, b) => b.start - a.start);
+    for (const item of edits) {
+        result =
+            result.slice(0, item.start) +
+                replacements.get(item.url) +
+                item.fragment +
+                result.slice(item.end);
+        count += item.occurrences;
+    }
+    return {
+        text: result,
+        count,
+        edits: edits.map(item => ({
+            start: item.start,
+            end: item.end,
+            value: replacements.get(item.url) + item.fragment
+        }))
+    };
+}
+export function isNoteAssetShortcut(event) {
+    return (event.code === 'KeyD' &&
+        event.ctrlKey &&
+        event.shiftKey &&
+        !event.metaKey &&
+        !event.altKey &&
+        !event.repeat &&
+        !event.isComposing);
+}

package/dist/shared/notes/identity.js

@@ -0,0 +1,24 @@
+import { isScalar, parseDocument } from 'yaml';
+import { isUuid } from "../utils/is-uuid.js";
+import { splitNote, setNoteProperty } from "./document.js";
+export function noteIdentity(text) {
+    try {
+        const doc = parseDocument(splitNote(text).yaml);
+        const value = doc.get('githuman_id', true);
+        if (value === undefined)
+            return { id: null, warning: null };
+        if (isScalar(value) && isUuid(value.value)) {
+            return { id: value.value.toLowerCase(), warning: null };
+        }
+        return {
+            id: null,
+            warning: 'githuman_id must be a UUID. The catalog identity is unchanged.'
+        };
+    }
+    catch {
+        return { id: null, warning: null };
+    }
+}
+export function withNoteIdentity(text, id) {
+    return setNoteProperty(text, 'githuman_id', id);
+}

package/dist/shared/notes/links.js

@@ -0,0 +1,44 @@
+export function noteLink(from, to) {
+    const base = from.split('/').slice(0, -1);
+    const target = to.split('/');
+    while (base.length && target.length && base[0] === target[0]) {
+        base.shift();
+        target.shift();
+    }
+    return [
+        ...base.map(() => '..'),
+        ...target.map(segment => encodeURIComponent(segment).replace(/[!'()*]/g, char => '%' + char.charCodeAt(0).toString(16)))
+    ].join('/');
+}
+export function resolveNoteLink(from, href) {
+    if (/^[a-z][a-z\d+.-]*:/i.test(href) || href.startsWith('//'))
+        return null;
+    if (href.startsWith('/') || href.includes('\\') || href.includes('?')) {
+        throw new Error('Invalid note link');
+    }
+    const [target = '', fragment = ''] = href.split('#');
+    const decoded = decodeURIComponent(target);
+    if (decoded.includes('\\') ||
+        decoded.includes('\0') ||
+        decoded.startsWith('/')) {
+        throw new Error('Invalid note link');
+    }
+    const parts = target ? from.split('/').slice(0, -1) : from.split('/');
+    for (const part of decoded.split('/')) {
+        if (!part || part === '.')
+            continue;
+        if (part === '..') {
+            if (!parts.length)
+                throw new Error('Link leaves the notes folder');
+            parts.pop();
+        }
+        else {
+            parts.push(part);
+        }
+    }
+    const path = parts.join('/');
+    if (!path.toLowerCase().endsWith('.md')) {
+        throw new Error('This link does not point to a Markdown note');
+    }
+    return { path, anchor: decodeURIComponent(fragment) };
+}

package/dist/shared/notes/note-path.js

@@ -0,0 +1,17 @@
+// Note paths use "/" on every platform and have no leading or trailing slash.
+/** Last path segment: the file or folder name. */
+export function noteBasename(path) {
+    return path.split('/').at(-1) ?? '';
+}
+/** Folder that contains the entry; empty string for the notes root. */
+export function noteParentPath(path) {
+    return path.split('/').slice(0, -1).join('/');
+}
+/** Joins a folder and an entry name; an empty folder means the notes root. */
+export function noteChildPath(parent, name) {
+    return parent ? parent + '/' + name : name;
+}
+/** Name of a note without its Markdown extension. */
+export function noteTitle(path) {
+    return noteBasename(path).replace(/\.md$/i, '');
+}

package/dist/shared/notes/reference-path.js

@@ -0,0 +1,55 @@
+import { noteBasename } from "./note-path.js";
+export function localReference(from, href) {
+    if (/^[a-z][a-z\d+.-]*:/i.test(href) ||
+        href.startsWith('/') ||
+        href.includes('?')) {
+        return null;
+    }
+    const hash = href.indexOf('#');
+    const target = hash < 0 ? href : href.slice(0, hash);
+    const anchor = hash < 0 ? '' : href.slice(hash + 1);
+    try {
+        const decoded = decodeURIComponent(target);
+        if (decoded.startsWith('/') || /[\\\0]/.test(decoded))
+            return null;
+        const parts = target ? from.split('/').slice(0, -1) : from.split('/');
+        for (const part of decoded.split('/')) {
+            if (!part || part === '.')
+                continue;
+            if (part === '..') {
+                if (!parts.length)
+                    return null;
+                parts.pop();
+            }
+            else {
+                parts.push(part);
+            }
+        }
+        return { path: parts.join('/'), anchor };
+    }
+    catch {
+        return null;
+    }
+}
+export function wikiReference(value, from, paths) {
+    const match = value.match(/^\[\[([^\]|]+)(?:\|([^\]]+))?\]\]$/);
+    if (!match)
+        return null;
+    const [name = '', anchor = ''] = match[1].split('#');
+    const target = /\.md$/i.test(name) ? name : name + '.md';
+    const local = localReference(from, target.split('/').map(encodeURIComponent).join('/'))?.path;
+    const candidates = paths.filter(path => noteBasename(path) === target);
+    const path = local && paths.includes(local)
+        ? local
+        : paths.includes(target)
+            ? target
+            : candidates.length === 1
+                ? candidates[0]
+                : null;
+    return {
+        path,
+        anchor,
+        label: match[2] ?? name.replace(/\.md$/i, ''),
+        ambiguous: candidates.length > 1 && !path
+    };
+}

package/dist/shared/notes/references.js

@@ -0,0 +1,190 @@
+import { localReference, wikiReference } from "./reference-path.js";
+export { localReference, wikiReference } from "./reference-path.js";
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { isMap, isSeq, isScalar, parseDocument } from 'yaml';
+import { splitNote } from "./document.js";
+import { noteLink } from "./links.js";
+import { safeDecodeURIComponent } from "../utils/safe-decode.js";
+// The AST excludes code and HTML; this scanner locates only a parsed destination.
+export function destinationRange(source, definition) {
+    let depth = 0;
+    let cursor = source.startsWith('!') ? 1 : 0;
+    for (; cursor < source.length; cursor++) {
+        if (source[cursor] === '\\') {
+            cursor++;
+            continue;
+        }
+        if (source[cursor] === '[')
+            depth++;
+        if (source[cursor] === ']' && --depth === 0) {
+            cursor++;
+            break;
+        }
+    }
+    while (/\s/.test(source[cursor] ?? '') && cursor < source.length)
+        cursor++;
+    if (source[cursor] !== (definition ? ':' : '('))
+        return null;
+    cursor++;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+        cursor++;
+    const angle = source[cursor] === '<';
+    if (angle)
+        cursor++;
+    const start = cursor;
+    depth = 0;
+    for (; cursor < source.length; cursor++) {
+        const char = source[cursor];
+        if (char === '\\') {
+            cursor++;
+            continue;
+        }
+        if (angle && char === '>')
+            break;
+        if (!angle) {
+            if (char === '(')
+                depth++;
+            if (char === ')') {
+                if (!depth)
+                    break;
+                depth--;
+            }
+            if (/\s/.test(char))
+                break;
+        }
+    }
+    return cursor >= start ? [start, cursor] : null;
+}
+export function noteReferences(text) {
+    let parts;
+    try {
+        parts = splitNote(text);
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    const bodyOffset = text.length - parts.body.length;
+    const tree = fromMarkdown(parts.body);
+    const uses = new Map();
+    const definitions = new Map();
+    const visit = (node) => {
+        if (node.type === 'linkReference' || node.type === 'imageReference') {
+            const group = uses.get(node.identifier) ?? [];
+            group.push({
+                position: bodyOffset + (node.position?.start.offset ?? 0),
+                image: node.type === 'imageReference'
+            });
+            uses.set(node.identifier, group);
+        }
+        if (node.type === 'link' ||
+            node.type === 'image' ||
+            node.type === 'definition') {
+            const start = node.position?.start.offset;
+            const end = node.position?.end.offset;
+            if (start !== undefined && end !== undefined) {
+                const raw = parts.body.slice(start, end);
+                const range = destinationRange(raw, node.type === 'definition');
+                if (range) {
+                    result.push({
+                        href: node.url,
+                        start: bodyOffset + start + range[0],
+                        end: bodyOffset + start + range[1],
+                        context: raw.slice(0, range[0]) + '<href>' + raw.slice(range[1]),
+                        format: 'markdown',
+                        image: node.type === 'image',
+                        displayStarts: [bodyOffset + start]
+                    });
+                }
+                if (range && node.type === 'definition') {
+                    definitions.set(result[result.length - 1], node.identifier);
+                }
+            }
+        }
+        if ('children' in node)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(tree);
+    for (const [ref, identifier] of definitions) {
+        const references = uses.get(identifier) ?? [];
+        ref.displayStarts = references.map(use => use.position);
+        ref.image = references.length > 0 && references.every(use => use.image);
+    }
+    try {
+        const doc = parseDocument(parts.yaml);
+        const offset = text.indexOf(parts.yaml, text.startsWith('\uFEFF') ? 5 : 4);
+        if (doc.errors.length || !isMap(doc.contents))
+            return result;
+        const scalar = (value, key) => {
+            if (!isScalar(value) || typeof value.value !== 'string' || !value.range) {
+                return;
+            }
+            const wiki = value.value.startsWith('[[');
+            if (!wiki && !/\.md(?:#|$)/i.test(value.value))
+                return;
+            result.push({
+                href: value.value,
+                start: offset + value.range[0],
+                end: offset + value.range[1],
+                context: 'yaml:' + key,
+                format: wiki ? 'wiki' : 'yaml',
+                image: false,
+                displayStarts: [offset + value.range[0]]
+            });
+        };
+        for (const pair of doc.contents.items) {
+            if (!isScalar(pair.key) ||
+                pair.key.value === 'githuman_id' ||
+                pair.key.value === 'tags') {
+                continue;
+            }
+            const key = String(pair.key.value);
+            if (isSeq(pair.value)) {
+                for (const value of pair.value.items)
+                    scalar(value, key);
+            }
+            else {
+                scalar(pair.value, key);
+            }
+        }
+    }
+    catch {
+        /* Invalid YAML must not prevent indexing the Markdown body. */
+    }
+    return result;
+}
+export function referenceTarget(ref, from, paths) {
+    if (ref.format === 'wiki') {
+        const wiki = wikiReference(ref.href, from, paths);
+        return wiki?.path
+            ? { path: wiki.path, anchor: encodeURIComponent(wiki.anchor) }
+            : null;
+    }
+    return localReference(from, ref.href);
+}
+export function rewriteReferences(text, changes) {
+    let result = text;
+    for (const change of [...changes].sort((a, b) => b.reference.start - a.reference.start)) {
+        const ref = change.reference;
+        const href = noteLink(change.from, change.target) +
+            (change.anchor ? '#' + change.anchor : '');
+        let replacement = href;
+        if (ref.format === 'wiki') {
+            const alias = ref.href.match(/\|([^\]]+)\]\]$/)?.[1];
+            replacement =
+                '[[' +
+                    change.target.replace(/\.md$/i, '') +
+                    (change.anchor ? '#' + safeDecodeURIComponent(change.anchor) : '') +
+                    (alias ? '|' + alias : '') +
+                    ']]';
+        }
+        if (ref.format !== 'markdown')
+            replacement = JSON.stringify(replacement);
+        result = result.slice(0, ref.start) + replacement + result.slice(ref.end);
+    }
+    return result;
+}
+export function sameReference(a, b) {
+    return a.href === b.href && a.context === b.context && a.format === b.format;
+}