@remigius42/morg 0.8.0 → 0.9.1

package/dist/presets/logseqOutline.js

@@ -1,5 +1,9 @@
 import { consumesBracedScripts } from "../core/bracedScripts.js";
+import { mayBeLineSyntax, readsAsLineSyntax } from "../core/lineSyntax.js";
+import { positionParser, tryParse } from "../core/render.js";
+import { ZERO_WIDTH_SPACE } from "../core/markupBoundary.js";
 import { isDrawerStart, isOrgBlockStart, orgElementEnd } from "../core/passthroughSource.js";
+import { readVanillaMarkdownOutline } from "./logseqVanillaMarkdown.js";
 // Logseq stores a page as an outline of blocks, each block a content
 // string it parses on its own: org writes a block as its level's stars,
 // a space and the content (an empty block as the bare stars), Markdown
@@ -14,6 +18,7 @@ const MD_PROPERTY_RE = /^([\w.-]+)::(?: (.*))?$/;
 // a repeated task's log line, which Logseq bullets per format
 const STATE_LINE_RE = /^[-*] (?=State ")/;
 const MD_HEADING_RE = /^(#{1,6})(?: (.*))?$/;
+const HEADLINE_RE = /^\*+ /;
 const FENCE_RE = /^\s*(?:```|~~~)/;
 // md→org adds it for the text's bare `_` and `^`, which a block's
 // content holds as Logseq writes it
@@ -106,68 +111,95 @@ function convertPage(lines, convert, preset) {
         ? [`${convert(lines.join("\n"), preset).replace(/\n+$/, "")}\n`]
         : [];
 }
-/**
- * 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 function orgOutlineToMarkdown(org, convert, presets) {
-    const { page, blocks } = splitBlocks(org.replace(/\r?\n$/, "").split(/\r?\n/), line => {
-        const match = ORG_BLOCK_RE.exec(line);
-        return match ? [match[1]?.length ?? 0, match[2] ?? ""] : null;
-    });
-    return [
-        ...convertPage(page, convert, presets.page),
-        ...blocks.map(block => orgBlockToMarkdown(block, convert, presets.block))
-    ]
-        .join("\n")
-        .concat("\n");
-}
 // org→md reads a block's bare `_` and `^` as text, as md→org writes
 // them without the setting that would say so
 function withBracedScripts(lines) {
     const braced = [BRACED_SCRIPTS_LINE, ...lines];
     return consumesBracedScripts(braced.join("\n")) ? braced : lines;
 }
-function orgBlockToMarkdown(block, convert, preset) {
-    const [first = "", ...rest] = block.lines;
-    // content that starts with the block's properties puts their drawer
-    // on the headline line; its heading level is then a property too
+// Logseq org: a block's properties drawer, as properties; a heading
+// level is one of them, but for content that starts with the drawer,
+// unless written below an empty title (Vanilla org), which both look
+// alike in
+function readOrgBlock({ level, lines }, joined = false) {
+    const [first = "", ...rest] = lines;
     const metaFirst = isDrawerStart(first);
-    const { meta, body } = takeMeta(metaFirst ? block.lines : rest, () => false);
-    let heading = "";
-    const metaLines = meta.flatMap(lines => {
-        if (lines[0] !== ":PROPERTIES:") {
-            return logbook(lines, "*");
+    const { meta: groups, body } = takeMeta(metaFirst ? lines : rest, () => false);
+    let heading = 0;
+    const meta = groups.flatMap((group) => {
+        if (group[0] !== ":PROPERTIES:") {
+            return [{ lines: group }];
         }
-        return lines.slice(1, -1).flatMap(line => {
+        return group.slice(1, -1).flatMap(line => {
             const [, key = "", value = ""] = ORG_PROPERTY_RE.exec(line) ?? [];
-            if (!metaFirst && key === "heading" && /^[1-6]$/.test(value)) {
-                heading = "#".repeat(Number(value));
+            if ((!metaFirst || joined) &&
+                key === "heading" &&
+                /^[1-6]$/.test(value)) {
+                heading = Number(value);
                 return [];
             }
-            return [`${key}::${value ? ` ${value}` : ""}`];
+            return [{ key, value }];
         });
     });
-    const content = convertContent(withBracedScripts(metaFirst ? body : [first, ...body]), convert, preset);
-    const [title = "", ...more] = arrange(metaFirst, metaLines, content);
-    const head = [heading, title].filter(Boolean).join(" ");
-    const indent = "\t".repeat(block.level - 1);
-    return [
-        `${indent}-${head ? ` ${head}` : ""}`,
-        ...more.map(line => `${indent}  ${line}`)
-    ].join("\n");
+    return {
+        level,
+        heading,
+        metaFirst,
+        meta,
+        content: metaFirst ? body : [first, ...body]
+    };
 }
-/**
- * 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 function markdownOutlineToOrg(markdown, convert, presets) {
+function readOrgOutline(org, vanilla) {
+    const { page, blocks } = splitBlocks(org.replace(/\r?\n$/, "").split(/\r?\n/), line => {
+        const match = ORG_BLOCK_RE.exec(line);
+        return match ? [match[1]?.length ?? 0, match[2] ?? ""] : null;
+    });
+    return {
+        page,
+        blocks: blocks.map(({ level, lines }) => {
+            // Vanilla org: a first line written below an empty title, as it
+            // starts an element, is the block's first line again
+            const [title, ...rest] = lines;
+            const joined = vanilla && title === "" && startsElement(rest);
+            return readOrgBlock({ level, lines: joined ? rest : lines }, joined);
+        })
+    };
+}
+// a continuation line sits two spaces inside its bullet
+function dedent(line, level) {
+    const indent = `${"\t".repeat(level - 1)}  `;
+    return line.startsWith(indent)
+        ? line.slice(indent.length)
+        : line.trim()
+            ? line
+            : "";
+}
+// `## title`: the heading level and the title
+function mdHeading(line) {
+    const match = MD_HEADING_RE.exec(line);
+    return match ? [match[1]?.length ?? 0, match[2] ?? ""] : [0, line];
+}
+function readMarkdownBlock({ level, lines: source }) {
+    const [first = "", ...rest] = source;
+    const lines = [first, ...rest.map(line => dedent(line, level))];
+    const metaFirst = MD_PROPERTY_RE.test(first);
+    const [heading, titleLine] = metaFirst ? [0, ""] : mdHeading(first);
+    const { meta: groups, body } = takeMeta(metaFirst ? lines : lines.slice(1), line => MD_PROPERTY_RE.test(line));
+    const meta = groups.map((group) => {
+        const property = MD_PROPERTY_RE.exec(group[0] ?? "");
+        return property
+            ? { key: property[1] ?? "", value: property[2] ?? "" }
+            : { lines: group };
+    });
+    return {
+        level,
+        heading,
+        metaFirst,
+        meta,
+        content: metaFirst ? body : [titleLine, ...body]
+    };
+}
+function readMarkdownOutline(markdown) {
     const lines = markdown.replace(/\r?\n$/, "").split(/\r?\n/);
     // a leading frontmatter is page content, its `- ` lines yaml items
     const frontmatter = lines.slice(0, lines[0] === "---" ? lines.indexOf("---", 1) + 1 : 0);
@@ -183,38 +215,45 @@ export function markdownOutlineToOrg(markdown, convert, presets) {
         // writes a page's first block if it is a heading
         return !fenced && MD_HEADING_RE.test(line) ? [1, line] : null;
     });
-    page.unshift(...frontmatter);
-    return [
-        ...convertPage(page, convert, presets.page),
-        ...blocks.map(block => mdBlockToOrg(block, convert, presets.block))
-    ]
-        .join("\n")
-        .concat("\n");
+    return {
+        page: [...frontmatter, ...page],
+        blocks: blocks.map(readMarkdownBlock)
+    };
 }
-// a continuation line sits two spaces inside its bullet
-function dedent(line, level) {
-    const indent = `${"\t".repeat(level - 1)}  `;
-    return line.startsWith(indent)
-        ? line.slice(indent.length)
-        : line.trim()
-            ? line
-            : "";
+// a block's content's first line, its meta lines, then the rest of the
+// content; content that starts with the meta lines keeps them first
+function arrange(metaFirst, meta, content) {
+    return metaFirst
+        ? [...meta, ...content]
+        : [content[0] ?? "", ...meta, ...content.slice(1)];
+}
+function propertyLine({ key, value }) {
+    return `${key}::${value ? ` ${value}` : ""}`;
+}
+function writeMarkdownBlock(block) {
+    const meta = block.meta.flatMap(item => "lines" in item ? logbook(item.lines, "*") : [propertyLine(item)]);
+    const [title = "", ...more] = arrange(block.metaFirst, meta, block.content);
+    const head = ["#".repeat(block.heading), title].filter(Boolean).join(" ");
+    const indent = "\t".repeat(block.level - 1);
+    return [
+        `${indent}-${head ? ` ${head}` : ""}`,
+        ...more.map(line => `${indent}  ${line}`)
+    ].join("\n");
 }
-// the md meta lines in org: `key::` lines become the property drawer,
-// where the first of them was, or below the planning lines
+// the meta in org: properties become the property drawer, where the
+// first of them was, or below the planning lines
 function orgMetaLines(meta, heading) {
     const properties = heading ? [`:heading: ${heading}`] : [];
     const lines = [];
-    for (const group of meta) {
-        const property = MD_PROPERTY_RE.exec(group[0] ?? "");
-        if (!property) {
-            lines.push(...logbook(group, "-"));
+    for (const item of meta) {
+        if ("lines" in item) {
+            lines.push(...logbook(item.lines, "-"));
             continue;
         }
         if (!lines.includes(null)) {
             lines.push(null);
         }
-        properties.push(`:${property[1]}:${property[2] ? ` ${property[2]}` : ""}`);
+        properties.push(`:${item.key}:${item.value ? ` ${item.value}` : ""}`);
     }
     if (properties.length && !lines.includes(null)) {
         lines.splice(lines.filter(line => PLANNING_RE.test(line ?? "")).length, 0, null);
@@ -222,30 +261,207 @@ function orgMetaLines(meta, heading) {
     const drawer = [":PROPERTIES:", ...properties, ":END:"];
     return lines.flatMap(line => (line === null ? drawer : [line]));
 }
-// a block's content's first line, its meta lines, then the rest of the
-// content; content that starts with the meta lines keeps them first
-function arrange(metaFirst, meta, content) {
-    return metaFirst
-        ? [...meta, ...content]
-        : [content[0] ?? "", ...meta, ...content.slice(1)];
-}
-// `## title`: the heading level and the title
-function mdHeading(line) {
-    const match = MD_HEADING_RE.exec(line);
-    return match ? [match[1]?.length ?? 0, match[2] ?? ""] : [0, line];
+// Logseq org writes a block's first line on its stars' line, where
+// Emacs reads it as the title; whether the line starts an element there
+// that runs on below it (a block, a list, a table, a drawer), which the
+// title would cut off; one line of a list or a table is a fine title,
+// as is a headline's own
+function startsElement(lines) {
+    const [first = ""] = lines;
+    if (!mayBeLineSyntax(first) || HEADLINE_RE.test(first)) {
+        return false;
+    }
+    const text = `${lines.join("\n")}\n`;
+    const [element] = tryParse(text, positionParser)?.children ?? [];
+    // its end takes in the blank lines after it
+    return (!!element &&
+        element.type !== "paragraph" &&
+        text
+            .slice(0, element.position?.end.offset ?? 0)
+            .trimEnd()
+            .includes("\n"));
 }
-function mdBlockToOrg(block, convert, preset) {
-    const [first = "", ...rest] = block.lines;
-    const lines = [first, ...rest.map(line => dedent(line, block.level))];
-    // content that starts with properties: their drawer opens on the
-    // headline line
-    const metaFirst = MD_PROPERTY_RE.test(first);
-    const [heading, titleLine] = metaFirst ? [0, ""] : mdHeading(first);
-    const { meta, body } = takeMeta(metaFirst ? lines : lines.slice(1), line => MD_PROPERTY_RE.test(line));
-    const content = convertMarkdownContent(metaFirst ? body : [titleLine, ...body], convert, preset).filter(line => line !== BRACED_SCRIPTS_LINE);
-    const [title = "", ...more] = arrange(metaFirst, orgMetaLines(meta, heading), content);
+// Vanilla org: Emacs reads stars without a space after them as text, so
+// an empty title keeps the space Logseq org leaves out, and a first line
+// that starts an element goes below the stars (ADR 0006)
+function writeOrgBlock(block, vanilla = false) {
+    const lines = arrange(block.metaFirst, orgMetaLines(block.meta, block.heading), block.content);
+    const [title = "", ...more] = vanilla && startsElement(lines) ? ["", ...lines] : lines;
     return [
-        `${"*".repeat(block.level)}${title ? ` ${title}` : ""}`,
+        `${"*".repeat(block.level)}${title || vanilla ? ` ${title}` : ""}`,
         ...more
     ].join("\n");
 }
+function writeOutline({ page, blocks }, writeBlock) {
+    return [...page, ...blocks.map(writeBlock)].join("\n").concat("\n");
+}
+// a block's title is a headline's, which Logseq reads as inline text
+// only; converted with the lines below it, it must not read as a list,
+// a headline or a fixed-width line, so an escape the core drops keeps
+// it text (ADR 0006)
+function inlineTitle(block) {
+    const [title = "", ...rest] = block.content;
+    return !block.metaFirst && readsAsLineSyntax(title)
+        ? [`${ZERO_WIDTH_SPACE}${title}`, ...rest]
+        : block.content;
+}
+// a title written from Markdown text keeps it text with an escape that
+// a headline needs none of
+function dropTitleEscape(block) {
+    const [title = "", ...rest] = block.content;
+    return block.metaFirst || !title.startsWith(ZERO_WIDTH_SPACE)
+        ? block
+        : { ...block, content: [title.slice(ZERO_WIDTH_SPACE.length), ...rest] };
+}
+// a task marker Logseq shows as a checkbox (0.10, block-checkbox), and
+// the text after it; TODO and DONE are the checkbox's own
+const CHECKBOX_MARKER_RE = /^(TODO|DONE|NOW|LATER|DOING|IN-PROGRESS|WAIT|WAITING) (.*)$/;
+// Vanilla Markdown: a task as a task item, marked as Logseq shows it,
+// so the marker comes back; CANCELED, shown without one, stays text
+function vanillaTitle(title) {
+    const [, marker, text] = CHECKBOX_MARKER_RE.exec(title) ?? [];
+    if (!marker) {
+        return title;
+    }
+    if (marker === "DONE") {
+        return `[x] ${text}`;
+    }
+    return marker === "TODO" ? `[ ] ${text}` : `[ ] ${marker} ${text}`;
+}
+const PLANNING_ENTRY_RE = /(SCHEDULED|DEADLINE): ([<[][^>\]]*[>\]])/g;
+// Vanilla Markdown: planning and properties as key:: lines, under the
+// org-ism names; a drawer and Logseq's view state have no form there
+function vanillaMeta(meta, context) {
+    return meta.flatMap(item => {
+        if ("key" in item) {
+            if (item.key === "collapsed") {
+                context.onWarning?.("collapsed is Logseq's view state; dropped");
+                return [];
+            }
+            return [propertyLine(item)];
+        }
+        const [first = ""] = item.lines;
+        if (isDrawerStart(first)) {
+            context.onWarning?.(`a ${first.slice(1, -1)} drawer has no Vanilla Markdown form; dropped`);
+            return [];
+        }
+        return [...first.matchAll(PLANNING_ENTRY_RE)].map(([, key = "", value]) => {
+            const canonical = key.toLowerCase();
+            return `${context.orgismKeys?.[canonical] ?? canonical}:: ${value}`;
+        });
+    });
+}
+// a block Logseq shows numbered, as a run of its siblings
+function isNumbered(item) {
+    return ("key" in item &&
+        item.key === "logseq.order-list-type" &&
+        item.value === "number");
+}
+function vanillaBlock(block, indent, bullet, context) {
+    const [first = "", ...more] = arrange(block.metaFirst, vanillaMeta(block.meta.filter(item => !isNumbered(item)), context), block.content);
+    const hashes = "#".repeat(block.heading);
+    // a heading no list holds is a heading of its own
+    if (block.heading && !indent) {
+        const body = more.length ? `\n\n${more.join("\n")}` : "";
+        return { heading: true, text: `${hashes} ${first}${body}` };
+    }
+    const title = [hashes, vanillaTitle(first)].filter(Boolean).join(" ");
+    return {
+        heading: false,
+        text: [
+            `${indent}${bullet}${title ? ` ${title}` : ""}`,
+            ...more.map(line => line ? `${indent}${" ".repeat(bullet.length + 1)}${line}` : "")
+        ].join("\n")
+    };
+}
+// Vanilla Markdown: a block is a list item, its children nested two
+// spaces further in; under a heading block they start a new list
+// (ADR 0006)
+function writeVanillaMarkdownOutline({ page, blocks }, context) {
+    // a parent's level, its children's indent and their numbered run
+    const parents = [{ level: 0, indent: "", run: 0 }];
+    const written = blocks.map(block => {
+        while (parents.length > 1 && (parents.at(-1)?.level ?? 0) >= block.level) {
+            parents.pop();
+        }
+        const parent = parents.at(-1) ?? { level: 0, indent: "", run: 0 };
+        parent.run = block.meta.some(isNumbered) ? parent.run + 1 : 0;
+        const bullet = parent.run ? `${parent.run}.` : "-";
+        const result = vanillaBlock(block, parent.indent, bullet, context);
+        parents.push({
+            level: block.level,
+            indent: result.heading
+                ? ""
+                : `${parent.indent}${" ".repeat(bullet.length + 1)}`,
+            run: 0
+        });
+        return result;
+    });
+    const body = written
+        .map((block, i) => i && (block.heading || written[i - 1]?.heading)
+        ? `\n${block.text}`
+        : block.text)
+        .join("\n");
+    return [
+        ...page.map(text => text.replace(/\n+$/, "")),
+        ...(body ? [body] : [])
+    ]
+        .join("\n\n")
+        .concat("\n");
+}
+/**
+ * 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 function orgOutlineToMarkdown(org, convert, presets, context) {
+    const { page, blocks } = readOrgOutline(org, context.side === "output");
+    const vanilla = context.side === "input";
+    const pageLines = vanilla ? (presets.vanillaPage?.(page) ?? page) : page;
+    const convertCarried = (fragment, preset) => convert(fragment, preset, vanilla ? presets.vanillaInline : undefined);
+    const outline = {
+        page: convertPage(pageLines, convertCarried, presets.page),
+        blocks: blocks.map(block => ({
+            ...block,
+            content: convertContent(withBracedScripts(vanilla ? inlineTitle(block) : block.content), convertCarried, presets.block)
+        }))
+    };
+    return vanilla
+        ? writeVanillaMarkdownOutline(outline, context)
+        : writeOutline(outline, writeMarkdownBlock);
+}
+/**
+ * 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 function markdownOutlineToOrg(markdown, convert, presets, context) {
+    const vanilla = context.side === "output";
+    const { page, blocks } = vanilla
+        ? readVanillaMarkdownOutline(markdown, context)
+        : readMarkdownOutline(markdown);
+    // Vanilla Markdown carries Logseq's syntax as Logseq Markdown writes
+    // it; Vanilla org is written as Logseq org, which it is (ADR 0006)
+    const convertCarried = (fragment, preset) => convert(fragment, preset, context.side === "both" || !preset
+        ? undefined
+        : vanilla
+            ? (presets.vanillaReader?.(preset) ?? preset)
+            : preset);
+    return writeOutline({
+        page: convertPage(page, convertCarried, presets.page),
+        blocks: blocks.map(block => {
+            const converted = {
+                ...block,
+                content: convertMarkdownContent(block.content, convertCarried, presets.block).filter(line => line !== BRACED_SCRIPTS_LINE)
+            };
+            return vanilla ? dropTitleEscape(converted) : converted;
+        })
+    }, block => writeOrgBlock(block, context.side === "input"));
+}

package/dist/presets/logseqVanillaMarkdown.d.ts

@@ -0,0 +1,9 @@
+import type { Outline } from "./logseqOutline.js";
+import type { ConversionContext } from "./types.js";
+/**
+ * Reads a Vanilla Markdown page into Logseq's outline.
+ * @param markdown The Markdown page.
+ * @param context The conversion's org-ism key names.
+ * @returns The outline, its blocks' content in Markdown.
+ */
+export declare function readVanillaMarkdownOutline(markdown: string, context: ConversionContext): Outline;