@remigius42/morg 0.5.0 → 0.7.0

package/dist/presets/logseq.js

@@ -1,5 +1,8 @@
 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 { keyValueEntries } from "../core/keyValueLines.js";
 /**
  * Logseq dialect preset: `heading::` properties and outline nesting.
  */
@@ -7,6 +10,7 @@ export function logseq(options = {}) {
     const nestUnderHeadings = options.nestUnderHeadings ?? true;
     return {
         name: "logseq",
+        applyToMdast: keepPagePropertySource,
         applyToUniorg: uniorgAst => applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings),
         extractFromUniorg: extractLogseqSpecificsFromUniorgAst
     };
@@ -87,6 +91,7 @@ function toBlockHeadline(node, level) {
  */
 export function applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings = true) {
     rewriteLabeledPageRefs(uniorgAst);
+    takePageProperties(uniorgAst);
     const children = uniorgAst.children;
     const result = [];
     let currentLevel = 0;
@@ -135,6 +140,130 @@ export function applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings = t
     uniorgAst.children = result;
     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)
+function pagePropertyEntries(text) {
+    const entries = keyValueEntries(text);
+    // a key org reads as no keyword name (begin_src) would not come back
+    return entries?.every(entry => fitsKeywordLine(...entry)) ? entries : null;
+}
+// md→org: the page property block's values are Logseq's, not Markdown;
+// its source text replaces the parse, so urls and markup stay verbatim
+function keepPagePropertySource(mdast, markdown) {
+    // below the frontmatter and an Emacs mode line
+    const node = mdast.children.find(child => child.type !== "yaml" &&
+        !(child.type === "html" &&
+            child.value.startsWith("<!--") &&
+            isModeLine(child.value)));
+    const start = node?.position?.start.offset;
+    const end = node?.position?.end.offset;
+    if (node?.type !== "paragraph" || start === undefined || end === undefined) {
+        return;
+    }
+    const source = markdown.slice(start, end);
+    if (pagePropertyEntries(source)) {
+        node.children = [{ type: "text", value: source }];
+    }
+}
+function takePageProperties(uniorgAst) {
+    const children = uniorgAst.children;
+    const keywords = takeFrontmatterKeywords(children);
+    // below the keywords, the file-level drawer and a mode line
+    const index = children.findIndex(node => !["keyword", "property-drawer"].includes(node.type) &&
+        !isModeLineComment(node) &&
+        !isFrontmatterNode(node));
+    const lines = pagePropertyLines(children[index]);
+    if (lines) {
+        children.splice(index, 1);
+        keywords.push(...lines);
+    }
+    // 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 })));
+}
+function takeFrontmatterKeywords(children) {
+    const frontmatter = children.find(isFrontmatterNode);
+    if (!frontmatter) {
+        return [];
+    }
+    const keywords = takeFlatEntries(frontmatter);
+    // an emptied block goes
+    if (!frontmatter.yaml && keywords.length) {
+        children.splice(children.indexOf(frontmatter), 1);
+    }
+    return keywords;
+}
+function pagePropertyLines(node) {
+    // plain text only: markup in a key means the source was no key:: line
+    const children = node?.children;
+    if (node?.type !== "paragraph" ||
+        !children?.every(child => child.type === "text")) {
+        return null;
+    }
+    return pagePropertyEntries(toString(node));
+}
+// keywords that act in Emacs or in export (TODO states, startup and
+// export options, file inclusion, babel calls, a dynamic block's begin
+// and end lines, citations, a table of
+// contents, index entries, raw export lines and exporter options, of
+// org's own exporters, org-info.js and KOMA letter class files among
+// them, and of ox-hugo and org-re-reveal): as frontmatter they were
+// passive data, so they stay in the block. A denylist: other
+// third-party exporters' keys pass. Export metadata (`title`, `author`)
+// passes too, and `tags`, Logseq's page tags property
+const ACTING_KEYWORD_RE = /^(?:(?:SEQ_|TYP_)?TODO|STARTUP|OPTIONS|INCLUDE|SETUPFILE|BIND|MACRO|CALL|PROPERTY|LINK|CONSTANTS|PRIORITIES|BIBLIOGRAPHY|CITE_EXPORT|PRINT_BIBLIOGRAPHY|ARCHIVE|CATEGORY|COLUMNS|FILETAGS|EXCLUDE_TAGS|SELECT_TAGS|BEGIN|END|TOC|(?:C|F|K|P|T|V)?INDEX|INFOJS_OPT|LCO|EXPORT_\w+|(?:HTML|LATEX|BEAMER|ODT|TEXINFO|MAN|ASCII|MD|MARKDOWN|ICALENDAR|HUGO|REVEAL)(?:_\w+)?)$/i;
+// flat frontmatter entries are page properties too, a sequence written
+// as Logseq writes it (`a, b`); what a keyword line cannot hold stays
+function takeFlatEntries(frontmatter) {
+    const { keywords, yaml } = takeFrontmatterEntries(frontmatter.yaml, (key, value, text) => {
+        const flat = flatValue(value, text);
+        // a key that comes back as a key:: line as written: uniorg
+        // upper-cases it, Logseq reads it lower-cased
+        return flat !== null &&
+            /^[a-z0-9_-]+$/.test(text(key)) &&
+            fitsKeywordLine(text(key), flat) &&
+            !ACTING_KEYWORD_RE.test(text(key))
+            ? [[text(key), flat]]
+            : null;
+    });
+    frontmatter.yaml = yaml;
+    return keywords;
+}
+function flatValue(value, text) {
+    const single = (item) => isScalar(item) && item.value !== null ? text(item) : null;
+    if (!isSeq(value)) {
+        return single(value);
+    }
+    const items = value.items.map(single);
+    return items.length &&
+        items.every(item => item !== null && !item.includes(","))
+        ? items.join(", ")
+        : null;
+}
+// the reverse: leading keywords become the first block, verbatim, keys
+// lower-cased (uniorg upper-cases them, Logseq reads only lower case)
+function pageProperties(uniorgAst) {
+    const children = uniorgAst.children;
+    // below a mode line, as on the way in
+    const first = children.findIndex(node => !isModeLineComment(node));
+    let count = 0;
+    while (first !== -1 && children[first + count]?.type === "keyword") {
+        count++;
+    }
+    const leading = children.slice(first, first + count);
+    // a key no `key::` line holds (`CAPTION[short]`) stays a keyword
+    const properties = leading.filter(keyword => /^[\w-]+$/.test(keyword.key));
+    if (!properties.length) {
+        return;
+    }
+    const lines = properties.map(keyword => `${keyword.key.toLowerCase()}::${keyword.value ? ` ${keyword.value}` : ""}`);
+    children.splice(first, count, ...leading.filter(keyword => !properties.includes(keyword)), {
+        type: "paragraph",
+        children: [{ type: "verbatim-inline", value: lines.join("\n") }],
+        contentsBegin: 0,
+        contentsEnd: 0
+    });
+}
 // Logseq md keeps TODO/DONE as leading text markers and priorities as
 // [#A] text; in org they are the headline's TODO keyword and priority
 // (other Logseq markers like DOING are not org keywords and simply
@@ -162,6 +291,7 @@ function takeTaskMarker(headline) {
  * @returns The generic uniorg AST.
  */
 function extractLogseqSpecificsFromUniorgAst(uniorgAst) {
+    pageProperties(uniorgAst);
     extractInParent(uniorgAst);
     repairHighlights(uniorgAst);
     fuzzyLinksToPageRefs(uniorgAst);

package/dist/presets/types.d.ts

@@ -1,12 +1,15 @@
+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.
  */
 export interface Preset {
     name: string;
+    applyToMdast?: (mdast: MdastRoot, markdown: string) => void;
     applyToUniorg?: (uniorgAst: OrgData) => OrgData;
     extractFromUniorg?: (uniorgAst: OrgData) => OrgData;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remigius42/morg",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Bidirectional Markdown ↔ Org-mode converter with round-trip convergence",
   "keywords": [
     "org-mode",
@@ -46,6 +46,7 @@
     "prepare": "husky",
     "prepack": "npm run build",
     "version": "node scripts/release-changelog.mjs && git add CHANGELOG.md",
+    "postversion": "printf '\\nNext:\\n  git push origin v%s\\n  wait for the Release run to pass\\n  git push\\n' \"$npm_package_version\"",
     "build": "tsc -p tsconfig.build.json",
     "build:web": "vite build web",
     "dev:web": "vite web",
@@ -61,6 +62,8 @@
     "lint:fix": "npm run lint:fix:prettier && npm run lint:fix:eslint",
     "lint:fix:prettier": "prettier --write '**/*'",
     "lint:fix:eslint": "eslint --fix '**/*.{ts,mts,js}'",
+    "perf": "npm run build && node scripts/perf/perf.mjs",
+    "perf:record": "node scripts/perf/perf.mjs --record",
     "test:unit": "vitest",
     "test:unit:ci": "vitest run --reporter default --coverage",
     "test:coverage": "vitest run --coverage",