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

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.5"
 }