@remigius42/morg 0.9.0 → 0.9.2

package/dist/core/lineSyntax.d.ts

@@ -1,5 +1,12 @@
 import type { Parent } from "unist";
 import { type Node } from "./render.js";
+/**
+ * Whether a line, indented or not, may start org line syntax: false
+ * where org surely reads it as text.
+ * @param line The line, without its line break.
+ * @returns Whether it may start an element other than a paragraph.
+ */
+export declare function mayBeLineSyntax(line: string): boolean;
 /**
  * Whether org reads a line as anything but a plain paragraph.
  * @param line The line, without its line break.

package/dist/core/lineSyntax.js

@@ -9,6 +9,15 @@ import { delimiters, isInline, locate, positionParser, renderInline, tryParse }
 // `:` (`1.`, `a)`, `CLOCK:`, `_.`); any other line (one starting with a
 // link, markup or code, say) is text, and skips the parse
 const MAY_BE_LINE_SYNTAX_RE = /^(?:[-+]|\*+)(?:\s|$)|^(?:-{5}|\+-|#(?:\s|$|\+)|[|:]|\[fn:|\\begin\{|%%\()|^[\p{L}\p{N}_]+[.):]/u;
+/**
+ * Whether a line, indented or not, may start org line syntax: false
+ * where org surely reads it as text.
+ * @param line The line, without its line break.
+ * @returns Whether it may start an element other than a paragraph.
+ */
+export function mayBeLineSyntax(line) {
+    return MAY_BE_LINE_SYNTAX_RE.test(line.trimStart());
+}
 /**
  * Whether org reads a line as anything but a plain paragraph.
  * @param line The line, without its line break.

package/dist/core/mdastToUniorg/blocks.js

@@ -43,15 +43,29 @@ function transformMdastTableRow(ctx, row) {
         }))
     };
 }
+// lines without the indentation all non-blank ones share
+function dedentLines(text) {
+    const lines = text.split("\n");
+    const indent = Math.min(...lines
+        .filter(line => line.trim())
+        .map(line => /^[ \t]*/.exec(line)?.[0].length ?? 0));
+    return Number.isFinite(indent)
+        ? lines.map(line => line.slice(indent)).join("\n")
+        : text;
+}
 export function transformMdastHtml(ctx, node) {
     // html comments are markdown's comment idiom and map natively to
     // org comments (not an md-ism)
     const comment = /^<!--([\s\S]*?)-->\s*$/.exec(node.value);
     if (comment) {
+        const body = comment[1] ?? "";
+        // a multi-line comment's own line breaks frame its lines, so an
+        // empty first or last line is the comment's, not padding
+        const lines = /^[ \t]*\n([\s\S]*)\n[ \t]*$/.exec(body);
         return {
             type: "comment",
             // inverse of the escaping applied when the comment was emitted
-            value: (comment[1] ?? "").trim().replaceAll("--&gt;", "-->")
+            value: (lines ? dedentLines(lines[1] ?? "") : body.trim()).replaceAll("--&gt;", "-->")
         };
     }
     if (ctx.options.interpretHtml) {

package/dist/markdownToOrg.js

@@ -87,10 +87,28 @@ function convertMarkdownDocument(markdown, options, sides) {
     // a marked comment block; raw text, past every pass that rewrites text
     renderFileHeader(uniorgAst);
     // Phase 4: Render uniorg-ast to Org-mode string
-    const processor = unified().use(uniorgStringify);
-    const orgContent = processor.stringify(uniorgAst);
-    return orgContent;
+    const orgContent = String(stringifier.stringify(uniorgAst));
+    return orgContent.replaceAll(SPACE_KEEPER, "");
 }
+// uniorg-stringify trims a headline's line, and the document's end, but
+// Emacs reads stars without a space after them as text; the space ends
+// in a character no trim takes, removed after. null leaves the rest to
+// uniorg-stringify
+const SPACE_KEEPER = "\u0000";
+function emptyHeadline(node) {
+    const empty = !node.children.length &&
+        !node.todoKeyword &&
+        !node.priority &&
+        !node.commented &&
+        !node.tags.length;
+    return empty ? `${"*".repeat(node.level)} ${SPACE_KEEPER}\n` : null;
+}
+// built once: a preset converts a page block by block
+const stringifier = unified()
+    .use(uniorgStringify, {
+    handlers: { headline: emptyHeadline }
+})
+    .freeze();
 // a preset's dialect conventions that need the Markdown source apply
 // to the parse, before the generic transform
 function parseMarkdown(markdown, preset) {

package/dist/presets/logseqOutline.js

@@ -1,5 +1,6 @@
 import { consumesBracedScripts } from "../core/bracedScripts.js";
-import { readsAsLineSyntax } from "../core/lineSyntax.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";
@@ -17,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
@@ -116,8 +118,10 @@ function withBracedScripts(lines) {
     return consumesBracedScripts(braced.join("\n")) ? braced : lines;
 }
 // Logseq org: a block's properties drawer, as properties; a heading
-// level is one of them, but for content that starts with the drawer
-function readOrgBlock({ level, lines }) {
+// 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: groups, body } = takeMeta(metaFirst ? lines : rest, () => false);
@@ -128,7 +132,9 @@ function readOrgBlock({ level, lines }) {
         }
         return group.slice(1, -1).flatMap(line => {
             const [, key = "", value = ""] = ORG_PROPERTY_RE.exec(line) ?? [];
-            if (!metaFirst && key === "heading" && /^[1-6]$/.test(value)) {
+            if ((!metaFirst || joined) &&
+                key === "heading" &&
+                /^[1-6]$/.test(value)) {
                 heading = Number(value);
                 return [];
             }
@@ -143,12 +149,21 @@ function readOrgBlock({ level, lines }) {
         content: metaFirst ? body : [first, ...body]
     };
 }
-function readOrgOutline(org) {
+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(readOrgBlock) };
+    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) {
@@ -246,23 +261,51 @@ function orgMetaLines(meta, heading) {
     const drawer = [":PROPERTIES:", ...properties, ":END:"];
     return lines.flatMap(line => (line === null ? drawer : [line]));
 }
-function writeOrgBlock(block) {
-    const [title = "", ...more] = arrange(block.metaFirst, orgMetaLines(block.meta, block.heading), block.content);
+// 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"));
+}
+// 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 table or a rule, which Logseq reads on a headline's line
+const TITLE_ELEMENT_RE = /^(\||-{5,}\s*$)/;
+// a block's title is a headline's, inline text but for a table or a
+// rule; 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)
+    return !block.metaFirst &&
+        !TITLE_ELEMENT_RE.test(title) &&
+        readsAsLineSyntax(title)
         ? [`${ZERO_WIDTH_SPACE}${title}`, ...rest]
         : block.content;
 }
@@ -380,15 +423,17 @@ function writeVanillaMarkdownOutline({ page, blocks }, context) {
  * @returns The Markdown page.
  */
 export function orgOutlineToMarkdown(org, convert, presets, context) {
-    const { page, blocks } = readOrgOutline(org);
+    const { page, blocks } = readOrgOutline(org, context.side === "output");
     const vanilla = context.side === "input";
+    // read as Logseq org, a block's title is inline text (ADR 0006)
+    const inline = context.side !== "output";
     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)
+            content: convertContent(withBracedScripts(inline ? inlineTitle(block) : block.content), convertCarried, presets.block)
         }))
     };
     return vanilla
@@ -422,7 +467,7 @@ export function markdownOutlineToOrg(markdown, convert, presets, context) {
                 ...block,
                 content: convertMarkdownContent(block.content, convertCarried, presets.block).filter(line => line !== BRACED_SCRIPTS_LINE)
             };
-            return vanilla ? dropTitleEscape(converted) : converted;
+            return context.side === "input" ? converted : dropTitleEscape(converted);
         })
-    }, writeOrgBlock);
+    }, block => writeOrgBlock(block, context.side === "input"));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remigius42/morg",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Bidirectional Markdown ↔ Org-mode converter with round-trip convergence",
   "keywords": [
     "org-mode",
@@ -30,7 +30,7 @@
     }
   },
   "bin": {
-    "morg": "./dist/cli.js"
+    "morg": "dist/cli.js"
   },
   "files": [
     "dist"