@sillsdev/docu-notion 0.11.1

package/dist/plugins/HeadingTransformer.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardHeadingTransformer = void 0;
+const log_1 = require("../log");
+// Makes links to headings work in docusaurus
+// https://github.com/sillsdev/docu-notion/issues/20
+function headingTransformer(notionToMarkdown, block) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // First, remove the prefix we added to the heading type
+        block.type = block.type.replace("DN_", "");
+        const markdown = yield notionToMarkdown.blockToMarkdown(block);
+        (0, log_1.logDebug)("headingTransformer, markdown of a heading before adding id", markdown);
+        // To make heading links work in docusaurus, we append an id. E.g.
+        //  ### Hello World {#my-explicit-id}
+        // See https://docusaurus.io/docs/markdown-features/toc#heading-ids.
+        // For some reason, inline links come in without the dashes, so we have to strip
+        // dashes here to match them.
+        //console.log("block.id", block.id)
+        const blockIdWithoutDashes = block.id.replaceAll("-", "");
+        // Finally, append the block id so that it can be the target of a link.
+        return `${markdown} {#${blockIdWithoutDashes}}`;
+    });
+}
+exports.standardHeadingTransformer = {
+    name: "standardHeadingTransformer",
+    // AP wrote: We have to do this because if
+    // we simply set a custom transformer to heading_n, it will keep
+    // recursively calling this code, with blockToMarkdown using the custom transformer
+    // over and over. Instead, we want blockToMarkdown to give us the normal
+    // result, to which we will append the block ID to enable heading links.
+    notionBlockModifications: [
+        {
+            modify: (block) => {
+                // "as any" needed because we're putting a value in that is not allowed by the real type
+                block.type = block.type.replace("heading", "DN_heading");
+            },
+        },
+    ],
+    // then when it comes time to do markdown conversions, we'll get called for each of these
+    notionToMarkdownTransforms: [
+        {
+            type: "DN_heading_1",
+            getStringFromBlock: (context, block) => headingTransformer(context.notionToMarkdown, block),
+        },
+        {
+            type: "DN_heading_2",
+            getStringFromBlock: (context, block) => headingTransformer(context.notionToMarkdown, block),
+        },
+        {
+            type: "DN_heading_3",
+            getStringFromBlock: (context, block) => headingTransformer(context.notionToMarkdown, block),
+        },
+    ],
+};

package/dist/plugins/NumberedListTransformer.d.ts

@@ -0,0 +1,2 @@
+import { IPlugin } from "./pluginTypes";
+export declare const standardNumberedListTransformer: IPlugin;

package/dist/plugins/NumberedListTransformer.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardNumberedListTransformer = void 0;
+// This is mostly what notion-to-markdown would normally do with a block of type
+// numbered_list_item. A patch is documented at the end.
+function numberedListTransformer(notionToMarkdown, block) {
+    var _a, _b, _c;
+    //console.log("got numbered list block " + JSON.stringify(block));
+    // In this case typescript is not able to index the types properly, hence ignoring the error
+    // @ts-ignore
+    const blockContent = 
+    // @ts-ignore
+    ((_a = block.numbered_list_item) === null || _a === void 0 ? void 0 : _a.text) || ((_b = block.numbered_list_item) === null || _b === void 0 ? void 0 : _b.rich_text) || [];
+    let parsedData = "";
+    blockContent.map((content) => {
+        const annotations = content.annotations;
+        let plain_text = content.plain_text;
+        plain_text = notionToMarkdown.annotatePlainText(plain_text, annotations);
+        if (content["href"]) {
+            plain_text = `[${plain_text}](${content["href"]})`;
+        }
+        parsedData += plain_text;
+    });
+    // There is code in notion-to-md which attempts to set an incrementing number
+    // on each of these. Somehow it fails; in my testing, block.numbered_list_item never
+    // has a field 'number'. But we don't actually need incrementing numbers;
+    // markdown will do the numbering if we just make something that looks like
+    // a member of a numbered list by starting with number followed by period and space.
+    // I'm keeping the original code in case notion-to-md gets fixed and there is actually
+    // some reason to use incrementing numbers (it would at least make the markdown more
+    // human-readable); but this at least works.
+    // A problem is that in notion, a numbered list may continue after some intermediate
+    // content. To achieve this in markdown, we'd need to indent the intermediate content
+    // by a tab. Not only is it difficult to do this, but there appears to be no way to
+    // know whether we should. The data we get from notion doesn't include the item number,
+    // and its parent is the page rather than a particular list. So there is no way I can
+    // see to distinguish a list continuation from a new list. The code here will leave
+    // it up to markdown to decide whether to start a new list; I believe it will do so
+    // if it sees any intervening lines that are not list items.
+    let num = (_c = block.numbered_list_item) === null || _c === void 0 ? void 0 : _c.number;
+    //console.log("got number " + num?.toString());
+    if (!num) {
+        num = 1;
+    }
+    return Promise.resolve(`${num}. ${parsedData.trim()}`);
+}
+exports.standardNumberedListTransformer = {
+    name: "standardNumberedListTransformer",
+    notionToMarkdownTransforms: [
+        {
+            type: "numbered_list_item",
+            getStringFromBlock: (context, block) => numberedListTransformer(context.notionToMarkdown, block),
+        },
+    ],
+};

package/dist/plugins/NumberedListTransformer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugins/NumberedListTransformer.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluginTestRun_1 = require("./pluginTestRun");
+const NumberedListTransformer_1 = require("./NumberedListTransformer");
+let block;
+beforeEach(() => {
+    block = {
+        has_children: false,
+        archived: false,
+        type: "callout",
+        callout: {
+            rich_text: [
+                {
+                    type: "text",
+                    text: { content: "This is information callout", link: null },
+                    annotations: {
+                        bold: false,
+                        italic: false,
+                        strikethrough: false,
+                        underline: false,
+                        code: false,
+                        color: "default",
+                    },
+                    plain_text: "This is the callout",
+                    href: null,
+                },
+            ],
+            icon: { type: "emoji", emoji: "ℹ️" },
+            color: "gray_background",
+        },
+    };
+});
+test("external link inside numbered list, italic preserved", () => __awaiter(void 0, void 0, void 0, function* () {
+    const config = { plugins: [NumberedListTransformer_1.standardNumberedListTransformer] };
+    const results = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            type: "numbered_list_item",
+            numbered_list_item: {
+                rich_text: [
+                    {
+                        type: "text",
+                        text: { content: "link ", link: null },
+                        annotations: {
+                            bold: false,
+                            italic: false,
+                            strikethrough: false,
+                            underline: false,
+                            code: false,
+                            color: "default",
+                        },
+                        plain_text: "link ",
+                        href: null,
+                    },
+                    {
+                        type: "text",
+                        text: {
+                            content: "github",
+                            link: { url: "https://github.com" },
+                        },
+                        annotations: {
+                            bold: false,
+                            italic: true,
+                            strikethrough: false,
+                            underline: false,
+                            code: false,
+                            color: "default",
+                        },
+                        plain_text: "github",
+                        href: "https://github.com",
+                    },
+                ],
+                color: "default",
+            },
+        },
+    ]);
+    expect(results.trim()).toBe(`1. link [_github_](https://github.com)`);
+}));

package/dist/plugins/TableTransformer.d.ts

@@ -0,0 +1,5 @@
+import { NotionToMarkdown } from "notion-to-md";
+import { IGetBlockChildrenFn, IPlugin } from "./pluginTypes";
+import { NotionBlock } from "../types";
+export declare function tableTransformer(notionToMarkdown: NotionToMarkdown, getBlockChildren: IGetBlockChildrenFn, block: NotionBlock): Promise<string>;
+export declare const standardTableTransformer: IPlugin;

package/dist/plugins/TableTransformer.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardTableTransformer = exports.tableTransformer = void 0;
+const markdown_table_1 = __importDefault(require("markdown-table"));
+// This is mostly a copy of the table handler from notion-to-md. The change is to handle newlines in the
+// notion cell content.
+function tableTransformer(notionToMarkdown, getBlockChildren, block) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { id, has_children } = block;
+        const tableArr = [];
+        if (has_children) {
+            const tableRows = yield getBlockChildren(id);
+            // console.log(">>", tableRows);
+            const rowsPromise = tableRows === null || tableRows === void 0 ? void 0 : tableRows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                const { type } = row;
+                const cells = row[type]["cells"];
+                /**
+                 * this is more like a hack since matching the type text was
+                 * difficult. So converting each cell to paragraph type to
+                 * reuse the blockToMarkdown function
+                 */
+                const cellStringPromise = cells.map((cell) => __awaiter(this, void 0, void 0, function* () {
+                    return yield notionToMarkdown.blockToMarkdown({
+                        type: "paragraph",
+                        paragraph: { rich_text: cell },
+                    });
+                }));
+                const cellStringArrRaw = yield Promise.all(cellStringPromise);
+                // This is our patch to the original notion-to-md code.
+                const cellStringArr = cellStringArrRaw.map(c => c
+                    // Trailing newlines are almost certainly not wanted, and converting to br's gives weird results
+                    .replace(/[\r\n]+$/, "")
+                    // Preserving line breaks within cells can't be done in stock markdown. Since we're producing
+                    // mdx, which supports embedded HTML, we can handle it with <br/>.
+                    // I'm not sure exactly what line breaks might occur in the input, depending on platform,
+                    // so handle all the common cases.
+                    .replaceAll("\r\n", "<br/>")
+                    .replaceAll("\n", "<br/>")
+                    .replaceAll("\r", "<br/>"));
+                // console.log("~~", cellStringArr);
+                tableArr.push(cellStringArr);
+                // console.log(tableArr);
+            }));
+            yield Promise.all(rowsPromise || []);
+        }
+        return (0, markdown_table_1.default)(tableArr);
+    });
+}
+exports.tableTransformer = tableTransformer;
+exports.standardTableTransformer = {
+    name: "standardTableTransformer",
+    notionToMarkdownTransforms: [
+        {
+            type: "table",
+            getStringFromBlock: (context, block) => tableTransformer(context.notionToMarkdown, context.getBlockChildren, block),
+        },
+    ],
+};

package/dist/plugins/embedTweaks.d.ts

@@ -0,0 +1,5 @@
+import { IPlugin } from "./pluginTypes";
+export declare const gifEmbed: IPlugin;
+export declare const imgurGifEmbed: IPlugin;
+export declare const youtubeEmbed: IPlugin;
+export declare const vimeoEmbed: IPlugin;

package/dist/plugins/embedTweaks.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vimeoEmbed = exports.youtubeEmbed = exports.imgurGifEmbed = exports.gifEmbed = void 0;
+exports.gifEmbed = {
+    name: "gif",
+    regexMarkdownModifications: [
+        {
+            // I once saw a gif coming from Notion that wasn't a full
+            // url, which wouldn't work, hence the "http" requirement
+            regex: /\[.*\]\((http.*(\.(gif|GIF)))\)/,
+            replacementPattern: `![]($1)`,
+        },
+    ],
+};
+exports.imgurGifEmbed = {
+    name: "imgur",
+    regexMarkdownModifications: [
+        {
+            regex: /\[.*\]\((.*imgur\.com\/.*)\)/,
+            // imgur links to gifs need a .gif at the end, but the url they give you doesn't have one.
+            replacementPattern: `![]($1.gif)`,
+        },
+    ],
+};
+exports.youtubeEmbed = {
+    name: "youtube",
+    regexMarkdownModifications: [
+        {
+            regex: /\[.*\]\((.*youtube\.com\/watch.*)\)/,
+            imports: [`import ReactPlayer from "react-player";`],
+            replacementPattern: `<ReactPlayer controls url="$1" />`,
+        },
+    ],
+};
+exports.vimeoEmbed = {
+    name: "vimeo",
+    regexMarkdownModifications: [
+        {
+            regex: /\[.*\]\((https:\/\/.*vimeo.*)\)/,
+            // we use to have the following, but the above should handle both the player an not-player urls.
+            //regex: /\[.*\]\((.*player\.vimeo.*)\)/gm, // player.vimeo
+            imports: [`import ReactPlayer from "react-player";`],
+            replacementPattern: `<ReactPlayer controls url="$1" />`,
+        },
+    ],
+};

package/dist/plugins/embedTweaks.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugins/embedTweaks.spec.js

@@ -0,0 +1,230 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../log");
+const pluginTestRun_1 = require("./pluginTestRun");
+const embedTweaks_1 = require("./embedTweaks");
+test("youtube", () => __awaiter(void 0, void 0, void 0, function* () {
+    const config = { plugins: [embedTweaks_1.youtubeEmbed] };
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            object: "block",
+            id: "e6ddd1d4-36d4-4925-94c1-5dff4662c1f3",
+            has_children: false,
+            archived: false,
+            type: "video",
+            video: {
+                caption: [
+                    {
+                        type: "text",
+                        text: {
+                            content: "A video about editing in Notion",
+                            link: null,
+                        },
+                        plain_text: "A video about editing in Notion",
+                        href: null,
+                    },
+                ],
+                type: "external",
+                external: { url: "https://www.youtube.com/watch?v=FXIrojSK3Jo" },
+            },
+        },
+    ]);
+    expect(result).toContain(`import ReactPlayer from "react-player";`);
+    expect(result).toContain(`<ReactPlayer controls url="https://www.youtube.com/watch?v=FXIrojSK3Jo" />`);
+}));
+test("vimeo", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, log_1.setLogLevel)("verbose");
+    const config = { plugins: [embedTweaks_1.vimeoEmbed] };
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            object: "block",
+            id: "39ff83a3-2fb5-4411-a715-960656a177ff",
+            type: "video",
+            video: {
+                caption: [],
+                type: "external",
+                external: { url: "https://vimeo.com/4613611xx" },
+            },
+        },
+    ]);
+    expect(result).toContain(`import ReactPlayer from "react-player";`);
+    expect(result).toContain(`<ReactPlayer controls url="https://vimeo.com/4613611xx" />`);
+}));
+test("imgur", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, log_1.setLogLevel)("verbose");
+    const config = { plugins: [embedTweaks_1.imgurGifEmbed] };
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            object: "block",
+            id: "e36710d8-98ad-40dc-b41b-b376ebdd6894",
+            type: "bookmark",
+            bookmark: { caption: [], url: "https://imgur.com/gallery/U8TTNuI" },
+        },
+    ]);
+    expect(result.trim()).toBe(`![](https://imgur.com/gallery/U8TTNuI.gif)`);
+}));
+test("gif", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, log_1.setLogLevel)("verbose");
+    const config = { plugins: [embedTweaks_1.gifEmbed] };
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            object: "block",
+            id: "e36710d8-98ad-40dc-b41b-b376ebdd6894",
+            type: "bookmark",
+            bookmark: {
+                caption: [],
+                url: "https://en.wikipedia.org/wiki/GIF#/media/File:Rotating_earth_(large).gif",
+            },
+        },
+    ]);
+    expect(result.trim()).toBe(`![](https://en.wikipedia.org/wiki/GIF#/media/File:Rotating_earth_(large).gif)`);
+}));
+test("tweaks are not applied inside code blocks", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, log_1.setLogLevel)("verbose");
+    const p = {
+        name: "test",
+        regexMarkdownModifications: [
+            {
+                regex: /find/,
+                replacementPattern: `found`,
+            },
+        ],
+    };
+    const config = { plugins: [p] };
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            type: "code",
+            code: {
+                caption: [],
+                rich_text: [
+                    {
+                        type: "text",
+                        text: {
+                            content: "don't find me",
+                            link: null,
+                        },
+                        annotations: {
+                            bold: false,
+                            italic: false,
+                            strikethrough: false,
+                            underline: false,
+                            code: false,
+                            color: "default",
+                        },
+                        plain_text: "don't find me",
+                        href: null,
+                    },
+                ],
+                language: "",
+            },
+        },
+        {
+            type: "paragraph",
+            paragraph: {
+                rich_text: [
+                    {
+                        type: "text",
+                        text: { content: "find this", link: null },
+                        annotations: {
+                            bold: false,
+                            italic: false,
+                            strikethrough: false,
+                            underline: false,
+                            code: true,
+                            color: "default",
+                        },
+                        plain_text: "find this",
+                        href: null,
+                    },
+                ],
+            },
+        },
+    ]);
+    // we should not change the code one
+    expect(result.trim()).toContain("don't find me");
+    // but we should change the non-code block one
+    expect(result.trim()).toContain("found this");
+}));
+test("simplest possible", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, log_1.setLogLevel)("verbose");
+    const p = {
+        name: "test",
+        regexMarkdownModifications: [
+            {
+                regex: /find/,
+                replacementPattern: `found`,
+            },
+        ],
+    };
+    const config = { plugins: [p] };
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            type: "paragraph",
+            paragraph: {
+                rich_text: [
+                    {
+                        type: "text",
+                        text: { content: "find this", link: null },
+                        annotations: {
+                            bold: false,
+                            italic: false,
+                            strikethrough: false,
+                            underline: false,
+                            code: true,
+                            color: "default",
+                        },
+                        plain_text: "find this",
+                        href: null,
+                    },
+                ],
+            },
+        },
+    ]);
+    expect(result.trim()).toContain("found this");
+}));
+test("use match in output", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, log_1.setLogLevel)("verbose");
+    const p = {
+        name: "test",
+        regexMarkdownModifications: [
+            {
+                regex: /(find)/,
+                replacementPattern: `found $1`,
+            },
+        ],
+    };
+    const config = { plugins: [p] };
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        {
+            type: "paragraph",
+            paragraph: {
+                rich_text: [
+                    {
+                        type: "text",
+                        text: { content: "find this", link: null },
+                        annotations: {
+                            bold: false,
+                            italic: false,
+                            strikethrough: false,
+                            underline: false,
+                            code: true,
+                            color: "default",
+                        },
+                        plain_text: "find this",
+                        href: null,
+                    },
+                ],
+            },
+        },
+    ]);
+    expect(result.trim()).toContain("found find");
+}));

package/dist/plugins/externalLinks.d.ts

@@ -0,0 +1,2 @@
+import { IPlugin } from "./pluginTypes";
+export declare const standardExternalLinkConversion: IPlugin;

package/dist/plugins/externalLinks.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardExternalLinkConversion = void 0;
+const log_1 = require("../log");
+exports.standardExternalLinkConversion = {
+    name: "standard external link conversion",
+    linkModifier: {
+        match: /\[.*\]\(http.*\)/,
+        convert: (context, markdownLink) => {
+            const linkRegExp = /\[([^\]]+)?\]\((http.*)\)/;
+            const match = linkRegExp.exec(markdownLink);
+            if (match === null) {
+                (0, log_1.error)(`[standardExternalLinkConversion] Could not parse link ${markdownLink}`);
+                return markdownLink;
+            }
+            const label = match[1];
+            const url = match[2];
+            if (label === "bookmark") {
+                const replacement = `[${url}](${url})`;
+                (0, log_1.warning)(`[standardExternalLinkConversion] Found Notion "Bookmark" link. In Notion this would show as an embed. The best docu-notion can do at the moment is replace "Bookmark" with the actual URL: ${replacement}`);
+                return replacement;
+            }
+            return `[${label}](${url})`;
+        },
+    },
+};

package/dist/plugins/externalLinks.spec.d.ts

@@ -0,0 +1 @@
+export {};