@remigius42/morg 0.6.0 → 0.8.0

package/dist/presets/logseqOutline.js

@@ -0,0 +1,251 @@
+import { consumesBracedScripts } from "../core/bracedScripts.js";
+import { isDrawerStart, isOrgBlockStart, orgElementEnd } from "../core/passthroughSource.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
+// as a `- ` bullet indented one tab per level, continuation lines two
+// spaces further in. Both are converted block by block, so a block's
+// content (a code block, a table, lines that run on) is one fragment.
+const ORG_BLOCK_RE = /^(\*+)(?: (.*))?$/;
+const MD_BLOCK_RE = /^(\t*)-(?: (.*))?$/;
+const PLANNING_RE = /^(?:SCHEDULED|DEADLINE): /;
+const ORG_PROPERTY_RE = /^:([^\s:]+):(?: (.*))?$/;
+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 FENCE_RE = /^\s*(?:```|~~~)/;
+// md→org adds it for the text's bare `_` and `^`, which a block's
+// content holds as Logseq writes it
+const BRACED_SCRIPTS_LINE = "#+OPTIONS: ^:{}";
+function logbook(lines, bullet) {
+    return lines[0] === ":LOGBOOK:"
+        ? lines.map(line => line.replace(STATE_LINE_RE, `${bullet} `))
+        : lines;
+}
+function splitBlocks(lines, blockLevel) {
+    const page = [];
+    const blocks = [];
+    for (const line of lines) {
+        const start = blockLevel(line);
+        if (start) {
+            blocks.push({ level: start[0], lines: [start[1]] });
+        }
+        else if (blocks.length) {
+            blocks[blocks.length - 1]?.lines.push(line);
+        }
+        else {
+            page.push(line);
+        }
+    }
+    return { page, blocks };
+}
+// a block's leading planning lines and drawers, which Logseq writes
+// below the content's first line in either format
+function takeMeta(lines, isMeta) {
+    const meta = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        if (isDrawerStart(line)) {
+            const end = orgElementEnd(lines, i);
+            if (end === -1) {
+                break;
+            }
+            meta.push(lines.slice(i, end + 1));
+            i = end + 1;
+        }
+        else if (PLANNING_RE.test(line) || isMeta(line)) {
+            meta.push([line]);
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    return { meta, body: lines.slice(i) };
+}
+// the one org block whose content Logseq md writes as Markdown markup
+// (its <quote command), and org→md writes as a md quote
+const QUOTE_BLOCK_RE = /^#\+begin_quote\b/i;
+function convertOrgBlock(block, convert, preset) {
+    if (!QUOTE_BLOCK_RE.test(block[0] ?? "")) {
+        return block;
+    }
+    const content = convertContent(block.slice(1, -1), convert, preset);
+    return [block[0] ?? "", ...content, block.at(-1) ?? ""];
+}
+// md→org: a block's org blocks stay as written, as org→md writes them,
+// but for a quote's content; the text around them converts
+function convertMarkdownContent(lines, convert, preset) {
+    const result = [];
+    let text = [];
+    let fenced = false;
+    for (let i = 0; i < lines.length; i++) {
+        fenced = FENCE_RE.test(lines[i] ?? "") ? !fenced : fenced;
+        const end = fenced || !isOrgBlockStart(lines[i] ?? "") ? -1 : orgElementEnd(lines, i);
+        if (end === -1) {
+            text.push(lines[i] ?? "");
+            continue;
+        }
+        result.push(...convertContent(text, convert, preset), ...convertOrgBlock(lines.slice(i, end + 1), convert, preset));
+        text = [];
+        i = end;
+    }
+    return [...result, ...convertContent(text, convert, preset)];
+}
+function convertContent(lines, convert, preset) {
+    const content = lines.join("\n");
+    return content.trim()
+        ? convert(content, preset).replace(/\n+$/, "").split("\n")
+        : [];
+}
+function convertPage(lines, convert, preset) {
+    // Logseq ends the page properties with a blank line
+    return lines.some(line => line.trim())
+        ? [`${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
+    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, "*");
+        }
+        return lines.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));
+                return [];
+            }
+            return [`${key}::${value ? ` ${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");
+}
+/**
+ * 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) {
+    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);
+    let fenced = false;
+    const { page, blocks } = splitBlocks(lines.slice(frontmatter.length), line => {
+        const match = MD_BLOCK_RE.exec(line);
+        // a bullet starts a block, which may open a fence of its own
+        fenced = (match ? false : fenced) !== FENCE_RE.test(match?.[2] ?? line);
+        if (match) {
+            return [(match[1]?.length ?? 0) + 1, match[2] ?? ""];
+        }
+        // a heading outside the bullets is a top-level block, as Logseq
+        // 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");
+}
+// 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
+            : "";
+}
+// the md meta lines in org: `key::` lines 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, "-"));
+            continue;
+        }
+        if (!lines.includes(null)) {
+            lines.push(null);
+        }
+        properties.push(`:${property[1]}:${property[2] ? ` ${property[2]}` : ""}`);
+    }
+    if (properties.length && !lines.includes(null)) {
+        lines.splice(lines.filter(line => PLANNING_RE.test(line ?? "")).length, 0, null);
+    }
+    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];
+}
+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);
+    return [
+        `${"*".repeat(block.level)}${title ? ` ${title}` : ""}`,
+        ...more
+    ].join("\n");
+}

package/dist/presets/types.d.ts

@@ -1,12 +1,23 @@
+import type { Root as MdastRoot } from "mdast";
 import type { OrgData } from "uniorg";
 /**
  * A dialect preset: transforms applied on top of the dialect-agnostic core.
- * `applyToUniorg` runs in the md→org pipeline after the generic transform;
+ * `applyToMdast` runs in the md→org pipeline before the generic
+ * transform, with the Markdown source at hand; `applyToUniorg` runs in the md→org pipeline after the generic transform;
  * `extractFromUniorg` runs in the org→md pipeline before the generic
  * transform, normalizing dialect conventions back to generic uniorg.
+ * `convertOrg` and `convertMarkdown` take a whole conversion over, for a
+ * dialect whose documents are no single org or Markdown document (an
+ * outline of blocks, each its own fragment); `convert` runs the core on
+ * a fragment, with the given preset's hooks.
  */
 export interface Preset {
     name: string;
+    applyToMdast?: (mdast: MdastRoot, markdown: string) => void;
     applyToUniorg?: (uniorgAst: OrgData) => OrgData;
     extractFromUniorg?: (uniorgAst: OrgData) => OrgData;
+    convertOrg?: (org: string, convert: FragmentConverter) => string;
+    convertMarkdown?: (markdown: string, convert: FragmentConverter) => string;
 }
+/** Converts a fragment with the core and the given preset's AST hooks. */
+export type FragmentConverter = (fragment: string, preset?: Preset) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remigius42/morg",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Bidirectional Markdown ↔ Org-mode converter with round-trip convergence",
   "keywords": [
     "org-mode",