@sillsdev/docu-notion 1.0.0-alpha.4 → 1.0.0-alpha.6

package/README.md

@@ -58,7 +58,7 @@ means that the ID is `0456aa5842946PRETEND4f37c97a0e5`.
 Try it out:
 
 ```
-npx @sillsdev/docu-notion -n secret_PRETEND123456789PRETEND123456789PRETEND6789 -r 0456aa5842946PRETEND4f37c97a0e5"
+npx @sillsdev/docu-notion -n secret_PRETEND123456789PRETEND123456789PRETEND6789 -r 0456aa5842946PRETEND4f37c97a0e5
 ```
 
 Likely, you will want to store these codes in your environment variables and then use them like this:

package/dist/plugins/internalLinks.js

@@ -29,7 +29,10 @@ function normalizeLinkBaseId(baseLinkId) {
         }
     }
     const withoutLeadingSlash = withoutQuery.replace(/^\/+/, "");
-    return withoutLeadingSlash;
+    // Newer Notion links can also use a relative "/p/<page-id>" form.
+    return withoutLeadingSlash.startsWith("p/")
+        ? withoutLeadingSlash.substring(2)
+        : withoutLeadingSlash;
 }
 // converts a url to a local link, if it is a link to a page in the Notion site
 // only here for plugins, notion won't normally be giving us raw urls (at least not that I've noticed)
@@ -125,7 +128,7 @@ exports.standardInternalLinkConversion = {
         // "Mention" links come in as full URLs, e.g. [link_to_page](https://www.notion.so/62f1187010214b0883711a1abb277d31)
         // Newer Notion links can also use app.notion.com, including /p/<page-id> URLs.
         // YOu can create them either with @+the name of a page, or by pasting a URL and then selecting the "Mention" option.
-        match: /\[([^\]]+)?\]\((?!mailto:)(https?:\/\/(?:www\.)?notion\.so\/[^),^/]+|https?:\/\/app\.notion\.com\/(?:p\/)?[^),^/]+|\/?[^),^/]+)\)/,
+        match: /\[([^\]]+)?\]\((?!mailto:)(https?:\/\/(?:www\.)?notion\.so\/[^),^/]+|https?:\/\/app\.notion\.com\/(?:p\/)?[^),^/]+|\/?(?:p\/)?[^),^/]+)\)/,
         convert: convertInternalLink,
     },
 };

package/dist/plugins/internalLinks.spec.js

@@ -121,6 +121,16 @@ test("parseLinkId extracts the page id from app.notion.com URLs", () => {
         fragmentId: "",
     });
 });
+test("parseLinkId extracts the page id from relative /p/ links", () => {
+    expect((0, internalLinks_1.parseLinkId)("/p/123456781234123412341234567890ab")).toEqual({
+        baseLinkId: "123456781234123412341234567890ab",
+        fragmentId: "",
+    });
+    expect((0, internalLinks_1.parseLinkId)("/p/123456781234123412341234567890ab#heading")).toEqual({
+        baseLinkId: "123456781234123412341234567890ab",
+        fragmentId: "#heading",
+    });
+});
 test("link to an existing page on this site that has no slug", () => __awaiter(void 0, void 0, void 0, function* () {
     const targetPageId = "123";
     const targetPage = (0, pluginTestRun_1.makeSamplePageObject)({
@@ -183,6 +193,68 @@ test("link to an existing page on this site that has no slug", () => __awaiter(v
     }, targetPage);
     expect(results.trim()).toBe(`Inline [great page](/${targetPageId}) the end.`);
 }));
+test("inline link using the newer relative /p/ form", () => __awaiter(void 0, void 0, void 0, function* () {
+    const targetPageId = "123";
+    const targetPage = (0, pluginTestRun_1.makeSamplePageObject)({
+        slug: undefined,
+        name: "Hello World",
+        id: targetPageId,
+    });
+    const results = yield getMarkdown({
+        type: "paragraph",
+        paragraph: {
+            rich_text: [
+                {
+                    type: "text",
+                    text: { content: "Inline ", link: null },
+                    annotations: {
+                        bold: false,
+                        italic: false,
+                        strikethrough: false,
+                        underline: false,
+                        code: false,
+                        color: "default",
+                    },
+                    plain_text: "Inline ",
+                    href: null,
+                },
+                {
+                    type: "text",
+                    text: {
+                        content: "great page",
+                        link: { url: `/p/${targetPageId}` },
+                    },
+                    annotations: {
+                        bold: false,
+                        italic: false,
+                        strikethrough: false,
+                        underline: false,
+                        code: false,
+                        color: "default",
+                    },
+                    plain_text: "great page",
+                    href: `/p/${targetPageId}`,
+                },
+                {
+                    type: "text",
+                    text: { content: " the end.", link: null },
+                    annotations: {
+                        bold: false,
+                        italic: false,
+                        strikethrough: false,
+                        underline: false,
+                        code: false,
+                        color: "default",
+                    },
+                    plain_text: " the end.",
+                    href: null,
+                },
+            ],
+            color: "default",
+        },
+    }, targetPage);
+    expect(results.trim()).toBe(`Inline [great page](/${targetPageId}) the end.`);
+}));
 test("link to a heading block on a page", () => __awaiter(void 0, void 0, void 0, function* () {
     const targetPageId = "123";
     const blocks = {

package/dist/transform.js

@@ -113,13 +113,19 @@ function doTransformsOnMarkdown(context, config, input) {
         let body = input;
         //console.log("body before regex: " + body);
         let match;
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         for (const mod of regexMods) {
-            let replacement = undefined;
             // regex.exec is stateful, so we don't want to mess up the plugin's use of its own regex, so we clone it.
             // we also add the "g" flag to make sure we get all matches
             const regex = new RegExp(`${codeBlocks.source}|(${mod.regex.source})`, "g");
-            while ((match = regex.exec(input)) !== null) {
+            // We match against `source` (a snapshot of the current body) and build up a
+            // fresh `result`. Mutating the string we're iterating over would invalidate
+            // `match.index` for every subsequent match once a replacement changes the
+            // length, so instead we copy the spans between matches using indices that
+            // always refer to the unchanged `source`.
+            const source = body;
+            let result = "";
+            let lastIndex = 0;
+            while ((match = regex.exec(source)) !== null) {
                 if (match[0]) {
                     const original = match[0];
                     if (original.startsWith("```") &&
@@ -127,6 +133,7 @@ function doTransformsOnMarkdown(context, config, input) {
                         !mod.includeCodeBlocks) {
                         continue; // code block, and they didn't say to include them
                     }
+                    let replacement = undefined;
                     if (mod.getReplacement) {
                         // our match here has an extra group, which is an implementation detail
                         // that shouldn't be made visible to the plugin
@@ -138,11 +145,11 @@ function doTransformsOnMarkdown(context, config, input) {
                     }
                     if (replacement !== undefined) {
                         (0, log_1.verbose)(`[${mod.name}] ${original} --> ${replacement}`);
-                        const precedingPart = body.substring(0, match.index); // ?
-                        const partStartingFromThisMatch = body.substring(match.index); // ?
-                        body =
-                            precedingPart +
-                                partStartingFromThisMatch.replace(original, replacement);
+                        // copy everything since the last match, then the replacement (the
+                        // replacement is appended literally, so `$` sequences in it are not
+                        // given any special meaning)
+                        result += source.substring(lastIndex, match.index) + replacement;
+                        lastIndex = match.index + original.length;
                         // add any library imports
                         if (!context.imports)
                             context.imports = [];
@@ -150,6 +157,9 @@ function doTransformsOnMarkdown(context, config, input) {
                     }
                 }
             }
+            // copy whatever follows the last replacement (including any skipped code blocks)
+            result += source.substring(lastIndex);
+            body = result;
         }
         (0, log_1.logDebug)("doTransformsOnMarkdown", "body after regex: " + body);
         return body;

package/dist/transform.spec.d.ts

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

package/dist/transform.spec.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 });
+const log_1 = require("./log");
+const pluginTestRun_1 = require("./plugins/pluginTestRun");
+function paragraph(text) {
+    return {
+        type: "paragraph",
+        paragraph: {
+            rich_text: [
+                {
+                    type: "text",
+                    text: { content: text, link: null },
+                    annotations: {
+                        bold: false,
+                        italic: false,
+                        strikethrough: false,
+                        underline: false,
+                        code: false,
+                        color: "default",
+                    },
+                    plain_text: text,
+                    href: null,
+                },
+            ],
+        },
+    };
+}
+// Regression test for the bug where doTransformsOnMarkdown matched against the
+// original `input` but sliced/replaced the mutating `body`. Once the first
+// replacement changes the string length, every subsequent match.index is wrong.
+// We make the first replacement SHRINK the text so the second match.index lands
+// past the real match, and the inner .replace silently drops the transformation.
+test("applies every match even after a length-changing replacement", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, log_1.setLogLevel)("verbose");
+    const p = {
+        name: "test",
+        regexMarkdownModifications: [
+            {
+                regex: /REMOVE/,
+                replacementPattern: `X`, // shorter than the match, so the body shrinks
+            },
+        ],
+    };
+    const config = { plugins: [p] };
+    // Produces markdown: "REMOVE\n\nREMOVE keep"
+    const result = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        paragraph("REMOVE"),
+        paragraph("REMOVE keep"),
+    ]);
+    // Both occurrences must be transformed; none should survive.
+    expect(result).not.toContain("REMOVE");
+    expect((result.match(/X/g) || []).length).toBe(2);
+    expect(result).toContain("keep");
+}));

package/package.json

@@ -98,5 +98,5 @@
     "esbuild@0.17.17": true,
     "fsevents": false
   },
-  "version": "1.0.0-alpha.4"
+  "version": "1.0.0-alpha.6"
 }