@remigius42/morg 0.7.0 → 0.9.0

package/dist/presets/logseq.js

@@ -1,45 +1,173 @@
 import { visit } from "unist-util-visit";
 import { toString } from "orgast-util-to-string";
-import { isScalar, isSeq } from "yaml";
-import { fitsKeywordLine, isFrontmatterNode, isModeLine, isModeLineComment, takeFrontmatterEntries } from "../core/frontmatterBlock.js";
+import { isScalar, isSeq, stringify as stringifyYaml } from "yaml";
+import { fitsKeywordLine, FRONTMATTER_BLOCK_BEGIN, frontmatterBlock, isFrontmatterNode, isModeLine, isModeLineComment, takeFrontmatterEntries } from "../core/frontmatterBlock.js";
 import { keyValueEntries } from "../core/keyValueLines.js";
+import { tryParse } from "../core/render.js";
+import { orgNodeToText } from "../core/uniorgToMdast/shared.js";
+import { markdownOutlineToOrg, orgOutlineToMarkdown } from "./logseqOutline.js";
 /**
- * Logseq dialect preset: `heading::` properties and outline nesting.
+ * Logseq dialect preset: the outline of blocks, page properties, page
+ * and block references, highlights and hiccup.
  */
-export function logseq(options = {}) {
-    const nestUnderHeadings = options.nestUnderHeadings ?? true;
+export function logseq() {
+    const page = pagePreset();
+    const block = blockPreset();
+    const presets = {
+        page,
+        block,
+        vanillaReader,
+        vanillaPage: pagePropertiesToFrontmatter,
+        vanillaInline
+    };
     return {
-        name: "logseq",
-        applyToMdast: keepPagePropertySource,
-        applyToUniorg: uniorgAst => applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings),
-        extractFromUniorg: extractLogseqSpecificsFromUniorgAst
+        ...page,
+        convertOrg: (org, convert, context) => orgOutlineToMarkdown(org, convert, presets, context),
+        convertMarkdown: (markdown, convert, context) => markdownOutlineToOrg(markdown, convert, presets, context)
     };
 }
-function headingProperty(level) {
-    return { type: "node-property", key: "heading", value: String(level) };
+// the hooks for a page's properties
+function pagePreset() {
+    return {
+        name: "logseq",
+        markdown: {
+            read: {
+                mdast: keepPagePropertySource,
+                org: rewriteLabeledPageRefs
+            },
+            write: uniorgAst => {
+                codeToQueryBlocks(uniorgAst);
+                pageProperties(uniorgAst);
+                return extractInlineSpecifics(uniorgAst);
+            }
+        },
+        org: {
+            read: readOrgInline,
+            write: takePageProperties
+        }
+    };
 }
-function headingDrawer(level) {
+// the hooks for a block's content
+function blockPreset() {
+    const bareUrls = new Map();
     return {
-        type: "property-drawer",
-        children: [headingProperty(level)],
-        contentsBegin: 0,
-        contentsEnd: 0
+        name: "logseq",
+        markdown: {
+            read: {
+                mdast: mdast => {
+                    countBareUrls(mdast, bareUrls);
+                    emailLinksToText(mdast);
+                },
+                org: rewriteLabeledPageRefs
+            },
+            write: uniorgAst => {
+                codeToQueryBlocks(uniorgAst);
+                bareUrlsToText(uniorgAst);
+                return extractInlineSpecifics(uniorgAst);
+            }
+        },
+        org: {
+            read: uniorgAst => {
+                bareUrlsToText(uniorgAst);
+                return readOrgInline(uniorgAst);
+            },
+            write: uniorgAst => restoreBareUrls(uniorgAst, bareUrls)
+        }
     };
 }
-// org fixes the order below a headline: the planning line first, then a
-// single property drawer. :heading: therefore has to let the planning
-// line pass and join an existing drawer rather than displace either.
-// Returns whether the property has been placed on `node`.
-function placeHeadingProperty(node, level) {
-    if (node.type === "planning") {
-        return false;
+// Logseq md writes a url bare, as org writes a plain link; the core
+// carries a md link as a [[url]] bracket link, so md→org counts the
+// links that were bare in the source and turns as many back to plain.
+// Where org's plain link ends short of md's autolink on trailing
+// punctuation (a macro's `}}`), that tail splits off as text
+function countBareUrls(mdast, counts) {
+    counts.clear();
+    visit(mdast, "link", (node, index, parent) => {
+        const url = bareUrl(node);
+        if (url === null) {
+            return undefined;
+        }
+        counts.set(url, (counts.get(url) ?? 0) + 1);
+        const tail = node.url.slice(url.length);
+        if (tail && parent && index !== undefined) {
+            node.url = url;
+            node.children = [{ type: "text", value: url }];
+            parent.children.splice(index + 1, 0, { type: "text", value: tail });
+        }
+        return undefined;
+    });
+}
+// the plain link org reads for a link written bare, if the rest is
+// trailing punctuation
+function bareUrl(node) {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start === undefined ||
+        end === undefined ||
+        end - start !== node.url.length) {
+        return null;
     }
-    if (node.type !== "property-drawer") {
-        return false;
+    const url = orgPlainLink(node.url);
+    return url !== null && /^[^\w(]*$/.test(node.url.slice(url.length))
+        ? url
+        : null;
+}
+// the url of the plain link org reads at the start of `url`, if any;
+// it ends early at a `(` (`…/Bandwidth_(signal)`) or a macro's `}}`
+function orgPlainLink(url) {
+    if (!/^https?:\/\//.test(url)) {
+        return null;
     }
-    ;
-    node.children.unshift(headingProperty(level));
-    return true;
+    const [paragraph] = tryParse(`${url}\n`)?.children ?? [];
+    const [link] = paragraph?.children ?? [];
+    return link?.format === "plain"
+        ? link.rawLink
+        : null;
+}
+function restoreBareUrls(uniorgAst, counts) {
+    visit(uniorgAst, "link", (node) => {
+        const count = counts.get(node.rawLink) ?? 0;
+        if (node.format === "bracket" && !node.children.length && count) {
+            node.format = "plain";
+            counts.set(node.rawLink, count - 1);
+        }
+    });
+    return uniorgAst;
+}
+// org→md: a plain http(s) link stays a bare url, unescaped
+// an email address is text in Logseq org and written bare in Logseq md,
+// where GFM links it: md→org takes such a link back to its text, and
+// org→md keeps the address unescaped (keepVerbatimText)
+const EMAIL_RE = /[\w.+-]+@[\w-]+(?:\.[\w-]+)+/;
+function emailLinksToText(mdast) {
+    visit(mdast, "link", (node, index, parent) => {
+        const start = node.position?.start.offset;
+        const end = node.position?.end.offset;
+        const text = node.url.replace(/^mailto:/, "");
+        if (node.url.startsWith("mailto:") &&
+            start !== undefined &&
+            end !== undefined &&
+            end - start === text.length &&
+            parent &&
+            index !== undefined) {
+            parent.children[index] = { type: "text", value: text };
+        }
+    });
+}
+function bareUrlsToText(uniorgAst) {
+    visit(uniorgAst, "link", (node, index, parent) => {
+        if (node.format !== "plain" ||
+            !/^https?$/.test(node.linkType) ||
+            !parent ||
+            index === undefined) {
+            return undefined;
+        }
+        parent.children[index] = {
+            type: "verbatim-inline",
+            value: node.rawLink
+        };
+        return undefined;
+    });
 }
 // the page name of a [[page]] link destination, or null. The core
 // transform percent-encodes brackets in urls (an org link path cannot
@@ -65,79 +193,6 @@ function rewriteLabeledPageRefs(uniorgAst) {
         node.rawLink = page;
         node.path = page;
     });
-}
-function toBlockHeadline(node, level) {
-    const blockHeadline = {
-        type: "headline",
-        level,
-        todoKeyword: null,
-        priority: null,
-        commented: false,
-        rawValue: "",
-        tags: [],
-        children: node.children
-    };
-    takeTaskMarker(blockHeadline);
-    return blockHeadline;
-}
-/**
- * Applies Logseq-specific conventions to a uniorg AST: every heading gets
- * a `:heading:` property drawer, and with `nestUnderHeadings` following
- * paragraphs become child block headlines (in Logseq's org format every
- * outline block is a headline).
- * @param uniorgAst The uniorg AST to transform.
- * @param nestUnderHeadings Nest content as child blocks. Default: `true`.
- * @returns The Logseq-flavored uniorg AST.
- */
-export function applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings = true) {
-    rewriteLabeledPageRefs(uniorgAst);
-    takePageProperties(uniorgAst);
-    const children = uniorgAst.children;
-    const result = [];
-    let currentLevel = 0;
-    // level of a headline whose :heading: property still needs a home
-    let pending = null;
-    const separate = () => {
-        if (!nestUnderHeadings) {
-            result.push({ type: "text", value: "\n" });
-        }
-    };
-    // no drawer took the property: give it one of its own
-    const settle = () => {
-        if (pending === null) {
-            return;
-        }
-        result.push(headingDrawer(pending));
-        pending = null;
-        separate();
-    };
-    for (const node of children) {
-        if (node.type === "headline") {
-            settle();
-            const headline = node;
-            currentLevel = headline.level;
-            takeTaskMarker(headline);
-            result.push(node);
-            pending = headline.level;
-            continue;
-        }
-        if (pending !== null) {
-            if (placeHeadingProperty(node, pending)) {
-                pending = null;
-                result.push(node);
-                separate();
-                continue;
-            }
-            if (node.type !== "planning") {
-                settle();
-            }
-        }
-        result.push(nestUnderHeadings && node.type === "paragraph"
-            ? toBlockHeadline(node, currentLevel + 1)
-            : node);
-    }
-    settle();
-    uniorgAst.children = result;
     return uniorgAst;
 }
 // Logseq reads a page's first block of `key:: value` lines (md) and its
@@ -180,6 +235,7 @@ function takePageProperties(uniorgAst) {
     // ahead of the block, so all of them lead the page
     const at = children.findIndex(node => node.type !== "keyword");
     children.splice(at === -1 ? children.length : at, 0, ...keywords.map(([key, value]) => ({ type: "keyword", key, value })));
+    return uniorgAst;
 }
 function takeFrontmatterKeywords(children) {
     const frontmatter = children.find(isFrontmatterNode);
@@ -240,6 +296,43 @@ function flatValue(value, text) {
         ? items.join(", ")
         : null;
 }
+const PAGE_PROPERTY_LINE_RE = /^#\+([a-z0-9_-]+):(?: (.*))?$/;
+// Vanilla Markdown: a page's properties, its leading lower-case keywords
+// as Logseq writes them, become plain frontmatter, as Markdown tools
+// read metadata (ADR 0006); the way back takes them as page properties
+// (takeFlatEntries). A keyword that acts in Emacs stays one
+function pagePropertiesToFrontmatter(lines) {
+    const begin = lines.findIndex(line => line.startsWith(FRONTMATTER_BLOCK_BEGIN));
+    const end = begin === -1 ? -1 : lines.indexOf("#+end_comment", begin);
+    // a key the frontmatter block has already stays a keyword
+    const taken = new Set(lines
+        .slice(begin + 1, begin === -1 ? 0 : end)
+        .map(line => /^([^\s:#][^:]*):/.exec(line)?.[1]));
+    const properties = {};
+    const rest = lines.filter((line, i) => {
+        const [, key, value = ""] = PAGE_PROPERTY_LINE_RE.exec(line) ?? [];
+        if (!key ||
+            (i > begin && i < end) ||
+            ACTING_KEYWORD_RE.test(key) ||
+            taken.has(key) ||
+            key in properties) {
+            return true;
+        }
+        properties[key] = value;
+        return false;
+    });
+    if (!Object.keys(properties).length) {
+        return lines;
+    }
+    // unfolded, or a long value would come back as no flat one
+    const yaml = stringifyYaml(properties, { lineWidth: 0 }).replace(/\n$/, "");
+    const block = frontmatterBlock(yaml).replace(/\n$/, "").split("\n");
+    const at = rest.findIndex(line => line.startsWith(FRONTMATTER_BLOCK_BEGIN));
+    // ahead of what the block holds, so the page properties lead
+    return at === -1
+        ? [...block, ...rest]
+        : [...rest.slice(0, at + 1), ...block.slice(1, -1), ...rest.slice(at + 1)];
+}
 // the reverse: leading keywords become the first block, verbatim, keys
 // lower-cased (uniorg upper-cases them, Logseq reads only lower case)
 function pageProperties(uniorgAst) {
@@ -264,40 +357,123 @@ function pageProperties(uniorgAst) {
         contentsEnd: 0
     });
 }
-// Logseq md keeps TODO/DONE as leading text markers and priorities as
-// [#A] text; in org they are the headline's TODO keyword and priority
-// (other Logseq markers like DOING are not org keywords and simply
-// stay in the title text)
-function takeTaskMarker(headline) {
-    const first = headline.children[0];
-    if (first?.type !== "text") {
-        return;
-    }
-    const marker = /^(TODO|DONE) (?:\[#([A-Z])\] )?/.exec(first.value);
-    if (!marker) {
-        return;
-    }
-    headline.todoKeyword = marker[1];
-    if (marker[2]) {
-        headline.priority = marker[2];
+// Logseq org's own inline syntax, carried in its Markdown form, which
+// Vanilla Markdown keeps as text (ADR 0006)
+function readOrgInline(uniorgAst) {
+    // first: a query's body is Logseq's query language, not org text
+    queryBlocksToCode(uniorgAst);
+    keepVerbatimText(uniorgAst);
+    repairHighlights(uniorgAst);
+    return uniorgAst;
+}
+// reading Vanilla Markdown as carrying Logseq Markdown's syntax: a
+// `query` code block is a query block (ADR 0006), which Logseq Markdown
+// writes as the block itself, so its code blocks stay code
+function vanillaReader(preset) {
+    const read = preset.markdown?.read;
+    return {
+        ...preset,
+        markdown: {
+            ...preset.markdown,
+            read: {
+                ...read,
+                org: uniorgAst => {
+                    const tree = read?.org?.(uniorgAst) ?? uniorgAst;
+                    codeToQueryBlocks(tree, "QUERY");
+                    return tree;
+                }
+            }
+        }
+    };
+}
+// a page ref stays a link for the output's Markdown dialect to write
+// (Obsidian's wikilink); Vanilla Markdown carries Logseq's syntax. A
+// hiccup paragraph is taken whole after its links are written, or a
+// page ref in it would be lost
+const vanillaInline = {
+    name: "logseq",
+    markdown: {
+        write: uniorgAst => {
+            fuzzyLinksToPageRefs(uniorgAst);
+            markHiccupParagraphs(uniorgAst);
+            return uniorgAst;
+        }
     }
-    first.value = first.value.slice((marker[0] ?? "").length);
+};
+// a query block: Vanilla Markdown has none, so a code block in the
+// query language carries it (ADR 0006); Logseq Markdown writes the
+// block itself, as Logseq does
+const QUERY_LANGUAGE = "query";
+function queryBlocksToCode(uniorgAst) {
+    visit(uniorgAst, "special-block", (node, index, parent) => {
+        if (node.blockType.toUpperCase() !== "QUERY" ||
+            !parent ||
+            index === undefined) {
+            return undefined;
+        }
+        const lines = orgNodeToText(node).split("\n");
+        parent.children[index] = {
+            type: "src-block",
+            affiliated: node.affiliated,
+            language: QUERY_LANGUAGE,
+            // the block as written, for Logseq Markdown to write it back
+            blockType: node.blockType,
+            switches: null,
+            parameters: null,
+            value: `${lines.slice(1, -1).join("\n")}\n`
+        };
+        return undefined;
+    });
 }
-/**
- * Extracts Logseq-specific conventions from a uniorg AST: headlines with
- * a `:heading:` property become plain headings of that level, headlines
- * without one are outline blocks and become paragraphs.
- * @param uniorgAst The Logseq-flavored uniorg AST to transform.
- * @returns The generic uniorg AST.
- */
-function extractLogseqSpecificsFromUniorgAst(uniorgAst) {
-    pageProperties(uniorgAst);
-    extractInParent(uniorgAst);
-    repairHighlights(uniorgAst);
+// a query block read as a code block (queryBlocksToCode) goes back as
+// it was written; with a fallback type, so does any `query` code block,
+// as Vanilla Markdown carries a query block
+function codeToQueryBlocks(uniorgAst, fallback) {
+    visit(uniorgAst, "src-block", (node, index, parent) => {
+        const type = node.blockType ?? fallback;
+        if (node.language !== QUERY_LANGUAGE ||
+            !type ||
+            !parent ||
+            index === undefined) {
+            return undefined;
+        }
+        // a Markdown code block's value ends short of its last line break
+        const body = node.value.replace(/\n?$/, "\n");
+        const [block] = tryParse(`#+begin_${type}\n${body}#+end_${type}\n`)?.children ?? [];
+        if (block) {
+            parent.children[index] = block;
+        }
+        return undefined;
+    });
+}
+function extractInlineSpecifics(uniorgAst) {
+    keepVerbatimText(uniorgAst);
     fuzzyLinksToPageRefs(uniorgAst);
     markHiccupParagraphs(uniorgAst);
     return uniorgAst;
 }
+// text Logseq md writes as it is, which remark would escape: a task's
+// priority ([#A]), an email address, and a tag's # (`#tag` starting a
+// line, which mldoc reads as escaped plain text once written `\#`);
+// verbatim-inline keeps it
+const VERBATIM_TEXT_RE = new RegExp(`(\\[#[A-Z]\\]|${EMAIL_RE.source}|(?<!\\S)#(?=[^\\s#]|$))`);
+function keepVerbatimText(uniorgAst) {
+    visit(uniorgAst, "text", (node, index, parent) => {
+        const parts = node.value.split(VERBATIM_TEXT_RE);
+        if (parts.length === 1 || !parent || index === undefined) {
+            return undefined;
+        }
+        // split's captures sit at the odd indices
+        const nodes = parts
+            .map((value, i) => ({
+            type: i % 2 ? "verbatim-inline" : "text",
+            value
+        }))
+            .filter(part => part.value);
+        parent.children.splice(index, 1, ...nodes);
+        return index + nodes.length;
+    });
+}
 // Logseq highlight markup (^^words^^) re-parses as a caret plus a
 // superscript; merge the pieces back into literal text
 function repairHighlights(uniorgAst) {
@@ -318,6 +494,7 @@ function repairHighlights(uniorgAst) {
             }
         }
     });
+    return uniorgAst;
 }
 // Logseq page and block references: [[page]] stays a wikilink,
 // [[page][label]] becomes [label]([[page]]), [[((uuid))][label]]
@@ -360,69 +537,3 @@ function markHiccupParagraphs(uniorgAst) {
         }
     });
 }
-function extractInParent(parent) {
-    const children = parent.children;
-    for (let i = 0; i < children.length; i++) {
-        const node = children[i];
-        if (!node) {
-            continue;
-        }
-        if (node.type === "section") {
-            extractInParent(node);
-            continue;
-        }
-        if (node.type !== "headline") {
-            continue;
-        }
-        const headline = node;
-        if (headline.todoKeyword) {
-            // back to Logseq md's text conventions (TODO [#A] Ship it);
-            // verbatim-inline keeps the [#A] brackets unescaped
-            const priority = headline.priority ? `[#${headline.priority}] ` : "";
-            headline.children.unshift({
-                type: "verbatim-inline",
-                value: `${headline.todoKeyword} ${priority}`
-            });
-            headline.todoKeyword = null;
-            headline.priority = null;
-        }
-        // a planning line sits between the headline and its drawer
-        const drawerIndex = children[i + 1]?.type === "planning" ? i + 2 : i + 1;
-        const heading = takeHeadingProperty(children, drawerIndex);
-        if (heading !== null) {
-            headline.level = heading;
-        }
-        else {
-            // a block headline (no :heading:) is outline structure only; its
-            // title is the block's content
-            children[i] = {
-                type: "paragraph",
-                children: headline.children,
-                contentsBegin: 0,
-                contentsEnd: 0
-            };
-        }
-    }
-}
-// removes the heading property from a drawer at `index` (and the drawer
-// itself if that empties it); returns the heading level or null
-function takeHeadingProperty(children, index) {
-    const drawer = children[index];
-    if (drawer?.type !== "property-drawer") {
-        return null;
-    }
-    const properties = drawer.children;
-    const heading = properties.find(property => property.key === "heading");
-    if (!heading) {
-        return null;
-    }
-    const remaining = properties.filter(property => property !== heading);
-    if (remaining.length) {
-        ;
-        drawer.children = remaining;
-    }
-    else {
-        children.splice(index, 1);
-    }
-    return parseInt(heading.value, 10) || null;
-}

package/dist/presets/logseqOutline.d.ts

@@ -0,0 +1,47 @@
+import type { ConversionContext, FragmentConverter, Preset } from "./types.js";
+export type Meta = {
+    lines: string[];
+} | {
+    key: string;
+    value: string;
+};
+/** A block of the outline, read from either format. */
+export interface Block {
+    level: number;
+    heading: number;
+    metaFirst: boolean;
+    meta: Meta[];
+    content: string[];
+}
+/** A page: its properties' source lines, then its blocks. */
+export interface Outline {
+    page: string[];
+    blocks: Block[];
+}
+interface Presets {
+    page: Preset;
+    block: Preset;
+    vanillaPage?: (lines: string[]) => string[];
+    vanillaReader?: (preset: Preset) => Preset;
+    vanillaInline?: Preset;
+}
+/**
+ * Converts a Logseq org page to Markdown, block by block: Logseq's,
+ * or Vanilla where the preset is on the input side only.
+ * @param org The org page.
+ * @param convert The core's fragment converter.
+ * @param presets The presets for the page properties and for a block.
+ * @param context The side the preset is on.
+ * @returns The Markdown page.
+ */
+export declare function orgOutlineToMarkdown(org: string, convert: FragmentConverter, presets: Presets, context: ConversionContext): string;
+/**
+ * Converts a Logseq Markdown page to Logseq org, block by block.
+ * @param markdown The Markdown page.
+ * @param convert The core's fragment converter.
+ * @param presets The presets for the page properties and for a block.
+ * @param context The side the preset is on.
+ * @returns The org page.
+ */
+export declare function markdownOutlineToOrg(markdown: string, convert: FragmentConverter, presets: Presets, context: ConversionContext): string;
+export {};