@remigius42/morg 0.8.0 → 0.9.0

package/dist/orgToMarkdown.js

@@ -13,6 +13,8 @@ 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";
+import { conversionContext, fragmentSides, readOrgWriteMarkdown, takeOver } from "./presets/hooks.js";
+import { resolveSides } from "./presets/sides.js";
 // a list item's paragraph after its nested list needs a blank line, or
 // md reads it as a lazy continuation of the nested list's last item
 function separateTextAfterNestedList(left, right, parent) {
@@ -29,12 +31,15 @@ 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);
+    return convertOrgSides(org, options, resolveSides(options, "org", "markdown"));
 }
-function convertOrgDocument(org, options) {
+function convertOrgSides(org, options, sides) {
+    const over = takeOver(sides, "convertOrg");
+    return over
+        ? over.preset.convertOrg(org, (fragment, preset, carried) => convertOrgSides(fragment, options, fragmentSides(sides, over.side, preset, carried)), conversionContext(over, options))
+        : convertOrgDocument(org, options, sides);
+}
+function convertOrgDocument(org, options, sides) {
     // 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)
@@ -53,10 +58,9 @@ function convertOrgDocument(org, options) {
     unescapeFootnoteReferences(uniorgAst);
     unescapeBackslashCommands(uniorgAst);
     unescapeTablePipes(uniorgAst);
-    // Phase 2: Extract dialect preset conventions, if any
-    if (options.preset?.extractFromUniorg) {
-        uniorgAst = options.preset.extractFromUniorg(uniorgAst);
-    }
+    // Phase 2: Extract dialect preset conventions, if any: read the org
+    // dialect, then write the md dialect
+    uniorgAst = readOrgWriteMarkdown(uniorgAst, sides);
     // Phase 3: Generic uniorg-ast to mdast transformation
     const mdast = transformUniorgAstToMdast(uniorgAst, {
         ...(options.preserveOrgisms !== undefined && {

package/dist/presets/hooks.d.ts

@@ -0,0 +1,49 @@
+import type { OrgData } from "uniorg";
+import type { Sides } from "./sides.js";
+import type { ConversionContext, Preset } from "./types.js";
+/**
+ * md→org's dialect step: reads the Markdown dialect out of the generic
+ * tree, then writes the org dialect into it.
+ * @param uniorgAst The tree the generic transform produced.
+ * @param sides The preset per side.
+ * @returns The tree in the org dialect.
+ */
+export declare function readMarkdownWriteOrg(uniorgAst: OrgData, { input, output }: Sides): OrgData;
+/**
+ * org→md's dialect step: reads the org dialect out of the parsed tree,
+ * then writes the Markdown dialect into it.
+ * @param uniorgAst The parsed org tree.
+ * @param sides The preset per side.
+ * @returns The tree, ready for the generic transform.
+ */
+export declare function readOrgWriteMarkdown(uniorgAst: OrgData, { input, output }: Sides): OrgData;
+/** A preset that takes a whole conversion over, and the side it is on. */
+export interface TakeOver {
+    preset: Preset;
+    side: ConversionContext["side"];
+}
+/**
+ * Finds the preset that takes the conversion over, if any: the input's,
+ * else the output's.
+ * @param sides The preset per side.
+ * @param hook The hook that takes this direction over.
+ * @returns The preset and its side, or `undefined` for none.
+ */
+export declare function takeOver({ input, output }: Sides, hook: "convertOrg" | "convertMarkdown"): TakeOver | undefined;
+/**
+ * The sides a fragment converts with: the fragment's preset on the
+ * taking-over preset's side or sides, the other side as it was.
+ * @param sides The conversion's preset per side.
+ * @param side The taking-over preset's side.
+ * @param preset The fragment's preset.
+ * @param carried The preset for the other side where it is Vanilla.
+ * @returns The fragment's preset per side.
+ */
+export declare function fragmentSides(sides: Sides, side: ConversionContext["side"], preset: Preset | undefined, carried?: Preset): Sides;
+/**
+ * The context a taking-over preset converts in.
+ * @param over The taking-over preset and its side.
+ * @param options The conversion's options.
+ * @returns The context.
+ */
+export declare function conversionContext(over: TakeOver, options: Pick<ConversionContext, "onWarning" | "orgismKeys">): ConversionContext;

package/dist/presets/hooks.js

@@ -0,0 +1,72 @@
+/**
+ * md→org's dialect step: reads the Markdown dialect out of the generic
+ * tree, then writes the org dialect into it.
+ * @param uniorgAst The tree the generic transform produced.
+ * @param sides The preset per side.
+ * @returns The tree in the org dialect.
+ */
+export function readMarkdownWriteOrg(uniorgAst, { input, output }) {
+    const read = input?.markdown?.read?.org ?? same;
+    const write = output?.org?.write ?? same;
+    return write(read(uniorgAst));
+}
+/**
+ * org→md's dialect step: reads the org dialect out of the parsed tree,
+ * then writes the Markdown dialect into it.
+ * @param uniorgAst The parsed org tree.
+ * @param sides The preset per side.
+ * @returns The tree, ready for the generic transform.
+ */
+export function readOrgWriteMarkdown(uniorgAst, { input, output }) {
+    const read = input?.org?.read ?? same;
+    const write = output?.markdown?.write ?? same;
+    return write(read(uniorgAst));
+}
+function same(uniorgAst) {
+    return uniorgAst;
+}
+/**
+ * Finds the preset that takes the conversion over, if any: the input's,
+ * else the output's.
+ * @param sides The preset per side.
+ * @param hook The hook that takes this direction over.
+ * @returns The preset and its side, or `undefined` for none.
+ */
+export function takeOver({ input, output }, hook) {
+    if (input?.[hook]) {
+        return {
+            preset: input,
+            side: input.name === output?.name ? "both" : "input"
+        };
+    }
+    return output?.[hook] ? { preset: output, side: "output" } : undefined;
+}
+/**
+ * The sides a fragment converts with: the fragment's preset on the
+ * taking-over preset's side or sides, the other side as it was.
+ * @param sides The conversion's preset per side.
+ * @param side The taking-over preset's side.
+ * @param preset The fragment's preset.
+ * @param carried The preset for the other side where it is Vanilla.
+ * @returns The fragment's preset per side.
+ */
+export function fragmentSides(sides, side, preset, carried) {
+    // only a Vanilla side carries another preset's syntax
+    return {
+        input: side === "output" ? (sides.input ?? carried) : preset,
+        output: side === "input" ? (sides.output ?? carried) : preset
+    };
+}
+/**
+ * The context a taking-over preset converts in.
+ * @param over The taking-over preset and its side.
+ * @param options The conversion's options.
+ * @returns The context.
+ */
+export function conversionContext(over, options) {
+    return {
+        side: over.side,
+        ...(options.onWarning && { onWarning: options.onWarning }),
+        ...(options.orgismKeys && { orgismKeys: options.orgismKeys })
+    };
+}

package/dist/presets/logseq.js

@@ -1,50 +1,79 @@
 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 { isScalar, isSeq, stringify as stringifyYaml } from "yaml";
+import { fitsKeywordLine, FRONTMATTER_BLOCK_BEGIN, frontmatterBlock, isFrontmatterNode, isModeLine, isModeLineComment, takeFrontmatterEntries } from "../core/frontmatterBlock.js";
 import { keyValueEntries } from "../core/keyValueLines.js";
 import { tryParse } from "../core/render.js";
+import { orgNodeToText } from "../core/uniorgToMdast/shared.js";
 import { markdownOutlineToOrg, orgOutlineToMarkdown } from "./logseqOutline.js";
 /**
  * Logseq dialect preset: the outline of blocks, page properties, page
  * and block references, highlights and hiccup.
  */
 export function logseq() {
-    const page = {
+    const page = pagePreset();
+    const block = blockPreset();
+    const presets = {
+        page,
+        block,
+        vanillaReader,
+        vanillaPage: pagePropertiesToFrontmatter,
+        vanillaInline
+    };
+    return {
+        ...page,
+        convertOrg: (org, convert, context) => orgOutlineToMarkdown(org, convert, presets, context),
+        convertMarkdown: (markdown, convert, context) => markdownOutlineToOrg(markdown, convert, presets, context)
+    };
+}
+// the hooks for a page's properties
+function pagePreset() {
+    return {
         name: "logseq",
-        applyToMdast: keepPagePropertySource,
-        applyToUniorg: uniorgAst => {
-            rewriteLabeledPageRefs(uniorgAst);
-            takePageProperties(uniorgAst);
-            return uniorgAst;
+        markdown: {
+            read: {
+                mdast: keepPagePropertySource,
+                org: rewriteLabeledPageRefs
+            },
+            write: uniorgAst => {
+                codeToQueryBlocks(uniorgAst);
+                pageProperties(uniorgAst);
+                return extractInlineSpecifics(uniorgAst);
+            }
         },
-        extractFromUniorg: uniorgAst => {
-            pageProperties(uniorgAst);
-            return extractInlineSpecifics(uniorgAst);
+        org: {
+            read: readOrgInline,
+            write: takePageProperties
         }
     };
+}
+// the hooks for a block's content
+function blockPreset() {
     const bareUrls = new Map();
-    const block = {
+    return {
         name: "logseq",
-        applyToMdast: mdast => {
-            countBareUrls(mdast, bareUrls);
-            emailLinksToText(mdast);
-        },
-        applyToUniorg: uniorgAst => {
-            rewriteLabeledPageRefs(uniorgAst);
-            restoreBareUrls(uniorgAst, bareUrls);
-            return uniorgAst;
+        markdown: {
+            read: {
+                mdast: mdast => {
+                    countBareUrls(mdast, bareUrls);
+                    emailLinksToText(mdast);
+                },
+                org: rewriteLabeledPageRefs
+            },
+            write: uniorgAst => {
+                codeToQueryBlocks(uniorgAst);
+                bareUrlsToText(uniorgAst);
+                return extractInlineSpecifics(uniorgAst);
+            }
         },
-        extractFromUniorg: uniorgAst => {
-            bareUrlsToText(uniorgAst);
-            return extractInlineSpecifics(uniorgAst);
+        org: {
+            read: uniorgAst => {
+                bareUrlsToText(uniorgAst);
+                return readOrgInline(uniorgAst);
+            },
+            write: uniorgAst => restoreBareUrls(uniorgAst, bareUrls)
         }
     };
-    return {
-        ...page,
-        convertOrg: (org, convert) => orgOutlineToMarkdown(org, convert, { page, block }),
-        convertMarkdown: (markdown, convert) => markdownOutlineToOrg(markdown, convert, { page, block })
-    };
 }
 // 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
@@ -103,6 +132,7 @@ function restoreBareUrls(uniorgAst, counts) {
             counts.set(node.rawLink, count - 1);
         }
     });
+    return uniorgAst;
 }
 // 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,
@@ -163,6 +193,7 @@ function rewriteLabeledPageRefs(uniorgAst) {
         node.rawLink = page;
         node.path = page;
     });
+    return uniorgAst;
 }
 // Logseq reads a page's first block of `key:: value` lines (md) and its
 // leading `#+key: value` lines (org) as page properties (ADR 0005)
@@ -204,6 +235,7 @@ function takePageProperties(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 })));
+    return uniorgAst;
 }
 function takeFrontmatterKeywords(children) {
     const frontmatter = children.find(isFrontmatterNode);
@@ -264,6 +296,43 @@ function flatValue(value, text) {
         ? items.join(", ")
         : null;
 }
+const PAGE_PROPERTY_LINE_RE = /^#\+([a-z0-9_-]+):(?: (.*))?$/;
+// Vanilla Markdown: a page's properties, its leading lower-case keywords
+// as Logseq writes them, become plain frontmatter, as Markdown tools
+// read metadata (ADR 0006); the way back takes them as page properties
+// (takeFlatEntries). A keyword that acts in Emacs stays one
+function pagePropertiesToFrontmatter(lines) {
+    const begin = lines.findIndex(line => line.startsWith(FRONTMATTER_BLOCK_BEGIN));
+    const end = begin === -1 ? -1 : lines.indexOf("#+end_comment", begin);
+    // a key the frontmatter block has already stays a keyword
+    const taken = new Set(lines
+        .slice(begin + 1, begin === -1 ? 0 : end)
+        .map(line => /^([^\s:#][^:]*):/.exec(line)?.[1]));
+    const properties = {};
+    const rest = lines.filter((line, i) => {
+        const [, key, value = ""] = PAGE_PROPERTY_LINE_RE.exec(line) ?? [];
+        if (!key ||
+            (i > begin && i < end) ||
+            ACTING_KEYWORD_RE.test(key) ||
+            taken.has(key) ||
+            key in properties) {
+            return true;
+        }
+        properties[key] = value;
+        return false;
+    });
+    if (!Object.keys(properties).length) {
+        return lines;
+    }
+    // unfolded, or a long value would come back as no flat one
+    const yaml = stringifyYaml(properties, { lineWidth: 0 }).replace(/\n$/, "");
+    const block = frontmatterBlock(yaml).replace(/\n$/, "").split("\n");
+    const at = rest.findIndex(line => line.startsWith(FRONTMATTER_BLOCK_BEGIN));
+    // ahead of what the block holds, so the page properties lead
+    return at === -1
+        ? [...block, ...rest]
+        : [...rest.slice(0, at + 1), ...block.slice(1, -1), ...rest.slice(at + 1)];
+}
 // the reverse: leading keywords become the first block, verbatim, keys
 // lower-cased (uniorg upper-cases them, Logseq reads only lower case)
 function pageProperties(uniorgAst) {
@@ -288,9 +357,97 @@ function pageProperties(uniorgAst) {
         contentsEnd: 0
     });
 }
-function extractInlineSpecifics(uniorgAst) {
+// Logseq org's own inline syntax, carried in its Markdown form, which
+// Vanilla Markdown keeps as text (ADR 0006)
+function readOrgInline(uniorgAst) {
+    // first: a query's body is Logseq's query language, not org text
+    queryBlocksToCode(uniorgAst);
     keepVerbatimText(uniorgAst);
     repairHighlights(uniorgAst);
+    return uniorgAst;
+}
+// reading Vanilla Markdown as carrying Logseq Markdown's syntax: a
+// `query` code block is a query block (ADR 0006), which Logseq Markdown
+// writes as the block itself, so its code blocks stay code
+function vanillaReader(preset) {
+    const read = preset.markdown?.read;
+    return {
+        ...preset,
+        markdown: {
+            ...preset.markdown,
+            read: {
+                ...read,
+                org: uniorgAst => {
+                    const tree = read?.org?.(uniorgAst) ?? uniorgAst;
+                    codeToQueryBlocks(tree, "QUERY");
+                    return tree;
+                }
+            }
+        }
+    };
+}
+// a page ref stays a link for the output's Markdown dialect to write
+// (Obsidian's wikilink); Vanilla Markdown carries Logseq's syntax. A
+// hiccup paragraph is taken whole after its links are written, or a
+// page ref in it would be lost
+const vanillaInline = {
+    name: "logseq",
+    markdown: {
+        write: uniorgAst => {
+            fuzzyLinksToPageRefs(uniorgAst);
+            markHiccupParagraphs(uniorgAst);
+            return uniorgAst;
+        }
+    }
+};
+// a query block: Vanilla Markdown has none, so a code block in the
+// query language carries it (ADR 0006); Logseq Markdown writes the
+// block itself, as Logseq does
+const QUERY_LANGUAGE = "query";
+function queryBlocksToCode(uniorgAst) {
+    visit(uniorgAst, "special-block", (node, index, parent) => {
+        if (node.blockType.toUpperCase() !== "QUERY" ||
+            !parent ||
+            index === undefined) {
+            return undefined;
+        }
+        const lines = orgNodeToText(node).split("\n");
+        parent.children[index] = {
+            type: "src-block",
+            affiliated: node.affiliated,
+            language: QUERY_LANGUAGE,
+            // the block as written, for Logseq Markdown to write it back
+            blockType: node.blockType,
+            switches: null,
+            parameters: null,
+            value: `${lines.slice(1, -1).join("\n")}\n`
+        };
+        return undefined;
+    });
+}
+// a query block read as a code block (queryBlocksToCode) goes back as
+// it was written; with a fallback type, so does any `query` code block,
+// as Vanilla Markdown carries a query block
+function codeToQueryBlocks(uniorgAst, fallback) {
+    visit(uniorgAst, "src-block", (node, index, parent) => {
+        const type = node.blockType ?? fallback;
+        if (node.language !== QUERY_LANGUAGE ||
+            !type ||
+            !parent ||
+            index === undefined) {
+            return undefined;
+        }
+        // a Markdown code block's value ends short of its last line break
+        const body = node.value.replace(/\n?$/, "\n");
+        const [block] = tryParse(`#+begin_${type}\n${body}#+end_${type}\n`)?.children ?? [];
+        if (block) {
+            parent.children[index] = block;
+        }
+        return undefined;
+    });
+}
+function extractInlineSpecifics(uniorgAst) {
+    keepVerbatimText(uniorgAst);
     fuzzyLinksToPageRefs(uniorgAst);
     markHiccupParagraphs(uniorgAst);
     return uniorgAst;
@@ -337,6 +494,7 @@ function repairHighlights(uniorgAst) {
             }
         }
     });
+    return uniorgAst;
 }
 // Logseq page and block references: [[page]] stays a wikilink,
 // [[page][label]] becomes [label]([[page]]), [[((uuid))][label]]

package/dist/presets/logseqOutline.d.ts

@@ -1,22 +1,47 @@
-import type { FragmentConverter, Preset } from "./types.js";
+import type { ConversionContext, FragmentConverter, Preset } from "./types.js";
+export type Meta = {
+    lines: string[];
+} | {
+    key: string;
+    value: string;
+};
+/** A block of the outline, read from either format. */
+export interface Block {
+    level: number;
+    heading: number;
+    metaFirst: boolean;
+    meta: Meta[];
+    content: string[];
+}
+/** A page: its properties' source lines, then its blocks. */
+export interface Outline {
+    page: string[];
+    blocks: Block[];
+}
 interface Presets {
     page: Preset;
     block: Preset;
+    vanillaPage?: (lines: string[]) => string[];
+    vanillaReader?: (preset: Preset) => Preset;
+    vanillaInline?: Preset;
 }
 /**
- * Converts a Logseq org page to Logseq Markdown, block by block.
+ * 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 declare function orgOutlineToMarkdown(org: string, convert: FragmentConverter, presets: Presets): string;
+export declare function orgOutlineToMarkdown(org: string, convert: FragmentConverter, presets: Presets, context: ConversionContext): 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.
+ * @param context The side the preset is on.
  * @returns The org page.
  */
-export declare function markdownOutlineToOrg(markdown: string, convert: FragmentConverter, presets: Presets): string;
+export declare function markdownOutlineToOrg(markdown: string, convert: FragmentConverter, presets: Presets, context: ConversionContext): string;
 export {};