@remigius42/morg 0.6.0 → 0.8.0

package/dist/markdownToOrg.js

@@ -5,13 +5,17 @@ import remarkFrontmatter from "remark-frontmatter";
 import remarkMath from "remark-math";
 import { uniorgStringify } from "uniorg-stringify";
 import { visit } from "unist-util-visit";
-import { transformMdastToUniorgAst } from "./core/mdastToUniorg/index.js";
+import { transformMdastToUniorgDraft } from "./core/mdastToUniorg/index.js";
 import { detectMarkdownStyle, STYLE_KEYWORD } from "./core/markdownStyle.js";
 import { escapeOrgMarkup } from "./core/markupBoundary.js";
+import { renderFileHeader } from "./core/frontmatterBlock.js";
 import { escapeLineSyntax } from "./core/lineSyntax.js";
 import { escapeFootnoteReferences } from "./core/footnoteReferences.js";
+import { escapeBackslashCommands } from "./core/backslashCommands.js";
 import { escapeTablePipes } from "./core/tablePipes.js";
 import { requireBracedScripts } from "./core/bracedScripts.js";
+import { keepPassthroughSource } from "./core/passthroughSource.js";
+import { keyValueEntries } from "./core/keyValueLines.js";
 /**
  * Converts a Markdown string to an Org-mode string.
  * @param markdown The Markdown string to convert.
@@ -19,15 +23,21 @@ import { requireBracedScripts } from "./core/bracedScripts.js";
  * @returns The converted Org-mode string.
  */
 export function convertMarkdownToOrg(markdown, options = {}) {
+    const convertMarkdown = options.preset?.convertMarkdown;
+    return convertMarkdown
+        ? // a fragment's style is the preset's, not one to record
+            convertMarkdown(markdown, (fragment, preset) => convertMarkdownToOrg(fragment, {
+                ...options,
+                preset,
+                recordStyle: false
+            }))
+        : convertMarkdownDocument(markdown, options);
+}
+function convertMarkdownDocument(markdown, options) {
     // Phase 1: Parse Markdown to mdast
-    const mdast = unified()
-        .use(remarkParse)
-        .use(remarkGfm)
-        .use(remarkFrontmatter)
-        .use(remarkMath)
-        .parse(markdown);
+    const mdast = parseMarkdown(markdown, options.preset);
     // Phase 2: Generic mdast to uniorg-ast transformation
-    let uniorgAst = transformMdastToUniorgAst(mdast, {
+    let uniorgAst = transformMdastToUniorgDraft(mdast, {
         ...(options.preserveMdisms !== undefined && {
             preserveMdisms: options.preserveMdisms
         }),
@@ -60,8 +70,10 @@ export function convertMarkdownToOrg(markdown, options = {}) {
     // Phase 3b: literal footnote references, paragraph lines org would
     // read as line syntax, literal markers org would read as markup, and
     // markup touching a word character, need a zero-width space escape;
-    // a pipe in a table cell an entity
-    escapeTablePipes(uniorgAst);
+    // a pipe in a table cell an entity; a literal backslash before a
+    // letter first, the entity being none
+    escapeBackslashCommands(uniorgAst);
+    escapeTablePipes(uniorgAst, options.onWarning);
     escapeFootnoteReferences(uniorgAst);
     escapeLineSyntax(uniorgAst);
     escapeOrgMarkup(uniorgAst);
@@ -70,12 +82,29 @@ export function convertMarkdownToOrg(markdown, options = {}) {
     // rendered: after the preset, whose text rewrites (wikilink aliases)
     // org parses too, and after the escapes, next to which org reads them
     requireBracedScripts(uniorgAst);
+    // Phase 3d: the file's header (ADR 0005): mode line and file-level
+    // drawer first, keywords apart from what follows, the frontmatter as
+    // 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;
 }
-// leads the document so it survives the frontmatter keywords following it
+// a preset's dialect conventions that need the Markdown source apply
+// to the parse, before the generic transform
+function parseMarkdown(markdown, preset) {
+    const mdast = unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkFrontmatter)
+        .use(remarkMath)
+        .parse(markdown);
+    keepPassthroughSource(mdast, markdown);
+    preset?.applyToMdast?.(mdast, markdown);
+    return mdast;
+}
+// leads the document, ahead of restored keywords and the frontmatter block
 function recordStyleKeyword(uniorgAst, style) {
     if (!Object.keys(style).length) {
         return;
@@ -86,7 +115,6 @@ function recordStyleKeyword(uniorgAst, style) {
         value: JSON.stringify(style)
     });
 }
-const KEY_VALUE_LINE_RE = /^([\w-]+):: (.*)$/;
 function parseKeyValueParagraph(node) {
     if (node?.type !== "paragraph" || !node.children?.length) {
         return null;
@@ -94,19 +122,7 @@ function parseKeyValueParagraph(node) {
     if (!node.children.every(child => child.type === "text")) {
         return null;
     }
-    const lines = node.children
-        .map(child => child.value ?? "")
-        .join("")
-        .split("\n");
-    const entries = [];
-    for (const line of lines) {
-        const match = KEY_VALUE_LINE_RE.exec(line);
-        if (!match) {
-            return null;
-        }
-        entries.push([match[1], match[2]]);
-    }
-    return entries;
+    return keyValueEntries(node.children.map(child => child.value ?? "").join(""));
 }
 function makeTimestamp(rawValue) {
     return { type: "timestamp", rawValue };

package/dist/orgToMarkdown.js

@@ -5,9 +5,12 @@ import remarkFrontmatter from "remark-frontmatter";
 import remarkMath from "remark-math";
 import { transformUniorgAstToMdast } from "./core/uniorgToMdast/index.js";
 import { takeRecordedStyle } from "./core/markdownStyle.js";
+import { takeFileHeader } from "./core/frontmatterBlock.js";
 import { unescapeOrgMarkup } from "./core/markupBoundary.js";
 import { unescapeLineSyntax } from "./core/lineSyntax.js";
 import { unescapeFootnoteReferences } from "./core/footnoteReferences.js";
+import { unescapeBackslashCommands } from "./core/backslashCommands.js";
+import { unescapeTablePipes } from "./core/tablePipes.js";
 import { parseOrg } from "./core/bracedScripts.js";
 import { dropUnderscoreBulletGuards, guardUnderscoreBullets } from "./core/underscoreBullets.js";
 // a list item's paragraph after its nested list needs a blank line, or
@@ -26,18 +29,30 @@ function separateTextAfterNestedList(left, right, parent) {
  * @returns The converted Markdown string.
  */
 export function convertOrgToMarkdown(org, options = {}) {
+    const convertOrg = options.preset?.convertOrg;
+    return convertOrg
+        ? convertOrg(org, (fragment, preset) => convertOrgToMarkdown(fragment, { ...options, preset }))
+        : convertOrgDocument(org, options);
+}
+function convertOrgDocument(org, options) {
     // Phase 1: Parse Org-mode to uniorg-ast
     // md text has no scripts, so ^:{} is implied there and consumed here
     // (see markdownToOrg); uniorg misreads `_.` lines (see underscoreBullets)
-    let uniorgAst = parseOrg(guardUnderscoreBullets(org));
+    const guarded = guardUnderscoreBullets(org);
+    let uniorgAst = parseOrg(guarded);
     dropUnderscoreBulletGuards(uniorgAst);
     // Phase 1b: a recorded style is morg's own (ADR 0004), so consume it so
     // it does not travel on as frontmatter; explicit options still win
     const recordedStyle = takeRecordedStyle(uniorgAst);
+    // frontmatter travels in a block marked as morg's (ADR 0005)
+    // and so does a file-level drawer (org-roam's :ID:)
+    const fileHeader = takeFileHeader(uniorgAst, guarded, options.onWarning);
     // Phase 1c: markdown needs no zero-width space escapes (inverse of md→org)
     unescapeOrgMarkup(uniorgAst);
     unescapeLineSyntax(uniorgAst);
     unescapeFootnoteReferences(uniorgAst);
+    unescapeBackslashCommands(uniorgAst);
+    unescapeTablePipes(uniorgAst);
     // Phase 2: Extract dialect preset conventions, if any
     if (options.preset?.extractFromUniorg) {
         uniorgAst = options.preset.extractFromUniorg(uniorgAst);
@@ -54,7 +69,8 @@ export function convertOrgToMarkdown(org, options = {}) {
         ...(options.orgismKeys !== undefined && {
             orgismKeys: options.orgismKeys
         }),
-        ...(options.onWarning !== undefined && { onWarning: options.onWarning })
+        ...(options.onWarning !== undefined && { onWarning: options.onWarning }),
+        ...fileHeader
     });
     // Phase 4: Render mdast to Markdown string
     // bullet and rule "-" (not remark's default "*") are morg's canonical

package/dist/presets/logseq.d.ts

@@ -1,25 +1,6 @@
-import type { OrgData } from "uniorg";
 import type { Preset } from "./types.js";
-export interface LogseqPresetOptions {
-    /**
-     * Content following a heading becomes children of that heading's block
-     * in Logseq's outline: paragraphs turn into child block headlines one
-     * level deeper; other constructs stay in the preceding block's body.
-     * Default: `true`.
-     */
-    nestUnderHeadings?: boolean;
-}
 /**
- * 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 declare function logseq(options?: LogseqPresetOptions): Preset;
-/**
- * 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 declare function applyLogseqSpecificsToUniorgAst(uniorgAst: OrgData, nestUnderHeadings?: boolean): OrgData;
+export declare function logseq(): Preset;