@remigius42/morg 0.6.0 → 0.8.0

package/dist/presets/logseq.js

@@ -1,41 +1,143 @@
 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 { keyValueEntries } from "../core/keyValueLines.js";
+import { tryParse } from "../core/render.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;
-    return {
+export function logseq() {
+    const page = {
         name: "logseq",
-        applyToUniorg: uniorgAst => applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings),
-        extractFromUniorg: extractLogseqSpecificsFromUniorgAst
+        applyToMdast: keepPagePropertySource,
+        applyToUniorg: uniorgAst => {
+            rewriteLabeledPageRefs(uniorgAst);
+            takePageProperties(uniorgAst);
+            return uniorgAst;
+        },
+        extractFromUniorg: uniorgAst => {
+            pageProperties(uniorgAst);
+            return extractInlineSpecifics(uniorgAst);
+        }
+    };
+    const bareUrls = new Map();
+    const block = {
+        name: "logseq",
+        applyToMdast: mdast => {
+            countBareUrls(mdast, bareUrls);
+            emailLinksToText(mdast);
+        },
+        applyToUniorg: uniorgAst => {
+            rewriteLabeledPageRefs(uniorgAst);
+            restoreBareUrls(uniorgAst, bareUrls);
+            return uniorgAst;
+        },
+        extractFromUniorg: uniorgAst => {
+            bareUrlsToText(uniorgAst);
+            return extractInlineSpecifics(uniorgAst);
+        }
     };
-}
-function headingProperty(level) {
-    return { type: "node-property", key: "heading", value: String(level) };
-}
-function headingDrawer(level) {
     return {
-        type: "property-drawer",
-        children: [headingProperty(level)],
-        contentsBegin: 0,
-        contentsEnd: 0
+        ...page,
+        convertOrg: (org, convert) => orgOutlineToMarkdown(org, convert, { page, block }),
+        convertMarkdown: (markdown, convert) => markdownOutlineToOrg(markdown, convert, { page, block })
     };
 }
-// 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);
+        }
+    });
+}
+// 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
@@ -62,112 +164,159 @@ function rewriteLabeledPageRefs(uniorgAst) {
         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;
+// Logseq reads a page's first block of `key:: value` lines (md) and its
+// leading `#+key: value` lines (org) as page properties (ADR 0005)
+function pagePropertyEntries(text) {
+    const entries = keyValueEntries(text);
+    // a key org reads as no keyword name (begin_src) would not come back
+    return entries?.every(entry => fitsKeywordLine(...entry)) ? entries : null;
 }
-/**
- * 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);
+// md→org: the page property block's values are Logseq's, not Markdown;
+// its source text replaces the parse, so urls and markup stay verbatim
+function keepPagePropertySource(mdast, markdown) {
+    // below the frontmatter and an Emacs mode line
+    const node = mdast.children.find(child => child.type !== "yaml" &&
+        !(child.type === "html" &&
+            child.value.startsWith("<!--") &&
+            isModeLine(child.value)));
+    const start = node?.position?.start.offset;
+    const end = node?.position?.end.offset;
+    if (node?.type !== "paragraph" || start === undefined || end === undefined) {
+        return;
+    }
+    const source = markdown.slice(start, end);
+    if (pagePropertyEntries(source)) {
+        node.children = [{ type: "text", value: source }];
+    }
+}
+function 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);
+    const keywords = takeFrontmatterKeywords(children);
+    // below the keywords, the file-level drawer and a mode line
+    const index = children.findIndex(node => !["keyword", "property-drawer"].includes(node.type) &&
+        !isModeLineComment(node) &&
+        !isFrontmatterNode(node));
+    const lines = pagePropertyLines(children[index]);
+    if (lines) {
+        children.splice(index, 1);
+        keywords.push(...lines);
     }
-    settle();
-    uniorgAst.children = result;
-    return 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 })));
 }
-// 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;
+function takeFrontmatterKeywords(children) {
+    const frontmatter = children.find(isFrontmatterNode);
+    if (!frontmatter) {
+        return [];
     }
-    const marker = /^(TODO|DONE) (?:\[#([A-Z])\] )?/.exec(first.value);
-    if (!marker) {
-        return;
+    const keywords = takeFlatEntries(frontmatter);
+    // an emptied block goes
+    if (!frontmatter.yaml && keywords.length) {
+        children.splice(children.indexOf(frontmatter), 1);
     }
-    headline.todoKeyword = marker[1];
-    if (marker[2]) {
-        headline.priority = marker[2];
+    return keywords;
+}
+function pagePropertyLines(node) {
+    // plain text only: markup in a key means the source was no key:: line
+    const children = node?.children;
+    if (node?.type !== "paragraph" ||
+        !children?.every(child => child.type === "text")) {
+        return null;
     }
-    first.value = first.value.slice((marker[0] ?? "").length);
+    return pagePropertyEntries(toString(node));
 }
-/**
- * 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) {
-    extractInParent(uniorgAst);
+// keywords that act in Emacs or in export (TODO states, startup and
+// export options, file inclusion, babel calls, a dynamic block's begin
+// and end lines, citations, a table of
+// contents, index entries, raw export lines and exporter options, of
+// org's own exporters, org-info.js and KOMA letter class files among
+// them, and of ox-hugo and org-re-reveal): as frontmatter they were
+// passive data, so they stay in the block. A denylist: other
+// third-party exporters' keys pass. Export metadata (`title`, `author`)
+// passes too, and `tags`, Logseq's page tags property
+const ACTING_KEYWORD_RE = /^(?:(?:SEQ_|TYP_)?TODO|STARTUP|OPTIONS|INCLUDE|SETUPFILE|BIND|MACRO|CALL|PROPERTY|LINK|CONSTANTS|PRIORITIES|BIBLIOGRAPHY|CITE_EXPORT|PRINT_BIBLIOGRAPHY|ARCHIVE|CATEGORY|COLUMNS|FILETAGS|EXCLUDE_TAGS|SELECT_TAGS|BEGIN|END|TOC|(?:C|F|K|P|T|V)?INDEX|INFOJS_OPT|LCO|EXPORT_\w+|(?:HTML|LATEX|BEAMER|ODT|TEXINFO|MAN|ASCII|MD|MARKDOWN|ICALENDAR|HUGO|REVEAL)(?:_\w+)?)$/i;
+// flat frontmatter entries are page properties too, a sequence written
+// as Logseq writes it (`a, b`); what a keyword line cannot hold stays
+function takeFlatEntries(frontmatter) {
+    const { keywords, yaml } = takeFrontmatterEntries(frontmatter.yaml, (key, value, text) => {
+        const flat = flatValue(value, text);
+        // a key that comes back as a key:: line as written: uniorg
+        // upper-cases it, Logseq reads it lower-cased
+        return flat !== null &&
+            /^[a-z0-9_-]+$/.test(text(key)) &&
+            fitsKeywordLine(text(key), flat) &&
+            !ACTING_KEYWORD_RE.test(text(key))
+            ? [[text(key), flat]]
+            : null;
+    });
+    frontmatter.yaml = yaml;
+    return keywords;
+}
+function flatValue(value, text) {
+    const single = (item) => isScalar(item) && item.value !== null ? text(item) : null;
+    if (!isSeq(value)) {
+        return single(value);
+    }
+    const items = value.items.map(single);
+    return items.length &&
+        items.every(item => item !== null && !item.includes(","))
+        ? items.join(", ")
+        : null;
+}
+// the reverse: leading keywords become the first block, verbatim, keys
+// lower-cased (uniorg upper-cases them, Logseq reads only lower case)
+function pageProperties(uniorgAst) {
+    const children = uniorgAst.children;
+    // below a mode line, as on the way in
+    const first = children.findIndex(node => !isModeLineComment(node));
+    let count = 0;
+    while (first !== -1 && children[first + count]?.type === "keyword") {
+        count++;
+    }
+    const leading = children.slice(first, first + count);
+    // a key no `key::` line holds (`CAPTION[short]`) stays a keyword
+    const properties = leading.filter(keyword => /^[\w-]+$/.test(keyword.key));
+    if (!properties.length) {
+        return;
+    }
+    const lines = properties.map(keyword => `${keyword.key.toLowerCase()}::${keyword.value ? ` ${keyword.value}` : ""}`);
+    children.splice(first, count, ...leading.filter(keyword => !properties.includes(keyword)), {
+        type: "paragraph",
+        children: [{ type: "verbatim-inline", value: lines.join("\n") }],
+        contentsBegin: 0,
+        contentsEnd: 0
+    });
+}
+function extractInlineSpecifics(uniorgAst) {
+    keepVerbatimText(uniorgAst);
     repairHighlights(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) {
@@ -230,69 +379,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,22 @@
+import type { FragmentConverter, Preset } from "./types.js";
+interface Presets {
+    page: Preset;
+    block: Preset;
+}
+/**
+ * Converts a Logseq org page to Logseq Markdown, block by block.
+ * @param org The org page.
+ * @param convert The core's fragment converter.
+ * @param presets The presets for the page properties and for a block.
+ * @returns The Markdown page.
+ */
+export declare function orgOutlineToMarkdown(org: string, convert: FragmentConverter, presets: Presets): 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.
+ * @returns The org page.
+ */
+export declare function markdownOutlineToOrg(markdown: string, convert: FragmentConverter, presets: Presets): string;
+export {};