markdown-patch 0.1.1 → 0.1.2

package/dist/tests/map.test.js

@@ -0,0 +1,202 @@
+import fs from "fs";
+import path from "path";
+import { getDocumentMap } from "../map";
+describe("map", () => {
+    const sample = fs.readFileSync(path.join(__dirname, "sample.md"), "utf-8");
+    test("heading", () => {
+        const actualHeadings = getDocumentMap(sample).heading;
+        const expectedHeadings = {
+            "": {
+                content: {
+                    start: 130,
+                    end: 6988,
+                },
+                marker: {
+                    start: 0,
+                    end: 0,
+                },
+                level: 0,
+            },
+            Overview: {
+                content: {
+                    start: 142,
+                    end: 430,
+                },
+                marker: {
+                    start: 131,
+                    end: 142,
+                },
+                level: 1,
+            },
+            Problems: {
+                content: {
+                    start: 441,
+                    end: 1468,
+                },
+                marker: {
+                    start: 430,
+                    end: 441,
+                },
+                level: 1,
+            },
+            Actions: {
+                content: {
+                    start: 1478,
+                    end: 3182,
+                },
+                marker: {
+                    start: 1468,
+                    end: 1478,
+                },
+                level: 1,
+            },
+            Headers: {
+                content: {
+                    start: 3192,
+                    end: 4282,
+                },
+                marker: {
+                    start: 3182,
+                    end: 3192,
+                },
+                level: 1,
+            },
+            "Page Targets": {
+                content: {
+                    start: 4297,
+                    end: 6988,
+                },
+                marker: {
+                    start: 4282,
+                    end: 4297,
+                },
+                level: 1,
+            },
+            "Page Targets\u001fHeading": {
+                content: {
+                    start: 4309,
+                    end: 5251,
+                },
+                marker: {
+                    start: 4298,
+                    end: 4309,
+                },
+                level: 2,
+            },
+            "Page Targets\u001fBlock": {
+                content: {
+                    start: 5260,
+                    end: 6122,
+                },
+                marker: {
+                    start: 5251,
+                    end: 5260,
+                },
+                level: 2,
+            },
+            "Page Targets\u001fBlock\u001fUse Cases": {
+                content: {
+                    start: 5778,
+                    end: 6122,
+                },
+                marker: {
+                    start: 5764,
+                    end: 5778,
+                },
+                level: 3,
+            },
+            "Page Targets\u001fFrontmatter Field": {
+                content: {
+                    start: 6143,
+                    end: 6690,
+                },
+                marker: {
+                    start: 6122,
+                    end: 6143,
+                },
+                level: 2,
+            },
+            "Page Targets\u001fFrontmatter Field\u001fUse Cases": {
+                content: {
+                    start: 6510,
+                    end: 6690,
+                },
+                marker: {
+                    start: 6496,
+                    end: 6510,
+                },
+                level: 3,
+            },
+            "Page Targets\u001fDocument Properties (Exploratory)": {
+                content: {
+                    start: 6727,
+                    end: 6988,
+                },
+                marker: {
+                    start: 6690,
+                    end: 6727,
+                },
+                level: 2,
+            },
+        };
+        //console.log(JSON.stringify(actualHeadings, undefined, 4));
+        expect(actualHeadings).toEqual(expectedHeadings);
+    });
+    test("block", () => {
+        const actualBlocks = getDocumentMap(sample).block;
+        const expectedBlocks = {
+            "2c67a6": {
+                content: {
+                    start: 1478,
+                    end: 3172,
+                },
+                marker: {
+                    start: 3173,
+                    end: 3181,
+                },
+            },
+            "1d6271": {
+                content: {
+                    start: 3192,
+                    end: 4272,
+                },
+                marker: {
+                    start: 4273,
+                    end: 4281,
+                },
+            },
+            bfec1f: {
+                content: {
+                    start: 4310,
+                    end: 4606,
+                },
+                marker: {
+                    start: 4607,
+                    end: 4615,
+                },
+            },
+            "259a73": {
+                content: {
+                    start: 6570,
+                    end: 6633,
+                },
+                marker: {
+                    start: 6633,
+                    end: 6642,
+                },
+            },
+            e6068e: {
+                content: {
+                    start: 6642,
+                    end: 6681,
+                },
+                marker: {
+                    start: 6681,
+                    end: 6690,
+                },
+            },
+        };
+        //console.log(JSON.stringify(actualBlocks, undefined, 4));
+        expect(actualBlocks).toEqual(expectedBlocks);
+    });
+});

package/dist/tests/patch.test.js

@@ -0,0 +1,222 @@
+import fs from "fs";
+import path from "path";
+import { applyPatch, PatchFailed } from "../patch";
+describe("patch", () => {
+    const sample = fs.readFileSync(path.join(__dirname, "sample.md"), "utf-8");
+    describe("heading", () => {
+        test("prepend", () => {
+            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.prepend.md"), "utf-8");
+            const instruction = {
+                targetType: "heading",
+                target: ["Overview"],
+                operation: "prepend",
+                content: "Beep Boop\n",
+            };
+            const actualResult = applyPatch(sample, instruction);
+            expect(actualResult).toEqual(expected);
+        });
+        test("append", () => {
+            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.append.md"), "utf-8");
+            const instruction = {
+                targetType: "heading",
+                target: ["Overview"],
+                operation: "append",
+                content: "Beep Boop\n",
+            };
+            const actualResult = applyPatch(sample, instruction);
+            expect(actualResult).toEqual(expected);
+        });
+        test("replace", () => {
+            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.replace.md"), "utf-8");
+            const instruction = {
+                targetType: "heading",
+                target: ["Overview"],
+                operation: "replace",
+                content: "Beep Boop\n",
+            };
+            const actualResult = applyPatch(sample, instruction);
+            expect(actualResult).toEqual(expected);
+        });
+        describe("document", () => {
+            test("prepend", () => {
+                const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.document.prepend.md"), "utf-8");
+                const instruction = {
+                    targetType: "heading",
+                    target: null,
+                    operation: "prepend",
+                    content: "Beep Boop\n",
+                };
+                const actualResult = applyPatch(sample, instruction);
+                expect(actualResult).toEqual(expected);
+            });
+            test("append", () => {
+                const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.document.append.md"), "utf-8");
+                const instruction = {
+                    targetType: "heading",
+                    target: null,
+                    operation: "append",
+                    content: "Beep Boop\n",
+                };
+                const actualResult = applyPatch(sample, instruction);
+                expect(actualResult).toEqual(expected);
+            });
+        });
+    });
+    describe("parameter", () => {
+        describe("trimTargetWhitespace", () => {
+            describe("heading", () => {
+                test("prepend", () => {
+                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.trimTargetWhitespace.prepend.md"), "utf-8");
+                    const instruction = {
+                        targetType: "heading",
+                        target: ["Page Targets", "Document Properties (Exploratory)"],
+                        operation: "prepend",
+                        content: "Beep Boop",
+                        trimTargetWhitespace: true,
+                    };
+                    const actualResult = applyPatch(sample, instruction);
+                    expect(actualResult).toEqual(expected);
+                });
+                test("append", () => {
+                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.trimTargetWhitespace.append.md"), "utf-8");
+                    const instruction = {
+                        targetType: "heading",
+                        target: ["Problems"],
+                        operation: "append",
+                        content: "Beep Boop\n",
+                        trimTargetWhitespace: true,
+                    };
+                    const actualResult = applyPatch(sample, instruction);
+                    expect(actualResult).toEqual(expected);
+                });
+            });
+        });
+        describe("applyIfContentPreexists", () => {
+            describe("disabled (default)", () => {
+                describe("heading", () => {
+                    test("preexists at target", () => {
+                        const instruction = {
+                            targetType: "heading",
+                            target: ["Page Targets"],
+                            operation: "append",
+                            content: "## Frontmatter Field",
+                            // applyIfContentPreexists: false,  # default
+                        };
+                        expect(() => {
+                            applyPatch(sample, instruction);
+                        }).toThrow(PatchFailed);
+                    });
+                    test("does not preexist at target", () => {
+                        const instruction = {
+                            targetType: "heading",
+                            target: ["Headers"],
+                            operation: "append",
+                            content: "## Frontmatter Field",
+                            // applyIfContentPreexists: false,  # default
+                        };
+                        expect(() => {
+                            applyPatch(sample, instruction);
+                        }).not.toThrow(PatchFailed);
+                    });
+                });
+            });
+            describe("enabled", () => {
+                describe("heading", () => {
+                    test("preexists at target", () => {
+                        const instruction = {
+                            targetType: "heading",
+                            target: ["Page Targets"],
+                            operation: "append",
+                            content: "## Frontmatter Field",
+                            applyIfContentPreexists: true,
+                        };
+                        expect(() => {
+                            applyPatch(sample, instruction);
+                        }).not.toThrow(PatchFailed);
+                    });
+                });
+            });
+        });
+    });
+    describe("block", () => {
+        test("prepend", () => {
+            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.prepend.md"), "utf-8");
+            const instruction = {
+                targetType: "block",
+                target: "e6068e",
+                operation: "prepend",
+                content: "- OK\n",
+            };
+            const actualResult = applyPatch(sample, instruction);
+            expect(actualResult).toEqual(expected);
+        });
+        test("append", () => {
+            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.append.md"), "utf-8");
+            const instruction = {
+                targetType: "block",
+                target: "e6068e",
+                operation: "append",
+                content: "\n- OK",
+            };
+            const actualResult = applyPatch(sample, instruction);
+            expect(actualResult).toEqual(expected);
+        });
+        test("replace", () => {
+            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.replace.md"), "utf-8");
+            const instruction = {
+                targetType: "block",
+                target: "259a73",
+                operation: "replace",
+                content: "- OK",
+            };
+            const actualResult = applyPatch(sample, instruction);
+            expect(actualResult).toEqual(expected);
+        });
+        describe("tagetBlockTypeBehavior", () => {
+            describe("table", () => {
+                test("prepend", () => {
+                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.prepend.md"), "utf-8");
+                    const instruction = {
+                        targetType: "block",
+                        targetBlockTypeBehavior: "table",
+                        target: "2c67a6",
+                        operation: "prepend",
+                        content: [
+                            ["`something else`", "Some other application", "✅", "✅", "✅"],
+                        ],
+                    };
+                    const actualResult = applyPatch(sample, instruction);
+                    expect(actualResult).toEqual(expected);
+                });
+                test("append", () => {
+                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.append.md"), "utf-8");
+                    const instruction = {
+                        targetType: "block",
+                        targetBlockTypeBehavior: "table",
+                        target: "2c67a6",
+                        operation: "append",
+                        content: [
+                            ["`something else`", "Some other application", "✅", "✅", "✅"],
+                        ],
+                    };
+                    const actualResult = applyPatch(sample, instruction);
+                    expect(actualResult).toEqual(expected);
+                });
+                test("replace", () => {
+                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.replace.md"), "utf-8");
+                    const instruction = {
+                        targetType: "block",
+                        targetBlockTypeBehavior: "table",
+                        target: "2c67a6",
+                        operation: "replace",
+                        content: [
+                            ["`something else`", "Some other application", "✅", "✅", "✅"],
+                        ],
+                    };
+                    const actualResult = applyPatch(sample, instruction);
+                    expect(actualResult).toEqual(expected);
+                });
+            });
+        });
+    });
+});

package/dist/types.js

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

package/package.json

@@ -15,9 +15,10 @@
     "typescript": "^5.5.4"
   },
   "name": "markdown-patch",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "main": "./dist/index.js",
   "scripts": {
+    "build": "npx tsc",
     "test": "node node_modules/.bin/jest"
   },
   "bin": {
@@ -27,5 +28,9 @@
   "author": "",
   "license": "ISC",
   "description": "Change markdown documents by inserting or changing content relative to headings or other parts of a document's structure.",
-  "type": "module"
+  "type": "module",
+  "files": [
+    "dist/",
+    "README.md"
+  ]
 }

package/.tool-versions

@@ -1 +0,0 @@
-nodejs 20.8.0

package/.vscode/launch.json

@@ -1,21 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Jest All",
-            //"runtimeExecutable": "${workspaceFolder}/node_modules/.bin/jest",
-            "args": [
-                "--runInBand"
-            ],
-            "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen",
-            "program": "${workspaceFolder}/node_modules/.bin/jest",
-            "cwd": "${workspaceFolder}"
-        }
-    ]
-}

package/document.md

@@ -1,11 +0,0 @@
-# Main
-
-Some content
-
-## Secondary
-
-Some more content
-
-## Tertiary
-
-Even more content

package/document.mdpatch.json

@@ -1,8 +0,0 @@
-[
-	{
-		"operation": "append",
-		"targetType": "heading",
-		"target": ["Main", "Secondary"],
-		"content": "This is a test\n"
-	}
-]

package/jest.config.ts

@@ -1,9 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  // Include other configurations if needed
-  testPathIgnorePatterns: [
-	  "/node_modules/",
-	  "/dist/"
-  ]
-};

package/src/cli.ts

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import fs from "fs/promises";
-import { getDocumentMap } from "./map.js";
-import { printMap } from "./debug.js";
-import { PatchInstruction } from "./types.js";
-import { applyPatch } from "./patch.js";
-import packageJson from "../package.json" assert { type: "json" };
-
-async function readStdin(): Promise<string> {
-  return new Promise((resolve, reject) => {
-    let data = "";
-    process.stdin.on("data", (chunk) => (data += chunk));
-    process.stdin.on("end", () => resolve(data));
-    process.stdin.on("error", reject);
-  });
-}
-
-const program = new Command();
-
-// Configure the CLI
-program
-  .name(Object.keys(packageJson.bin)[0])
-  .description(packageJson.description)
-  .version(packageJson.version);
-
-program
-  .command("print-map")
-  .argument("<path>", "filepath to show identified patchable paths for")
-  .argument(
-    "[regex]",
-    "limit displayed matches to those matching the supplied regular expression"
-  )
-  .action(async (path: string, regex: string | undefined) => {
-    const document = await fs.readFile(path, "utf-8");
-    const documentMap = getDocumentMap(document);
-
-    printMap(document, documentMap, regex ? new RegExp(regex) : undefined);
-  });
-
-program
-  .command("apply")
-  .argument("<path>", "file to patch")
-  .argument("<patch>", "patch file to apply")
-  .option(
-    "-o, --output <output>",
-    "write output to the specified path instead of applying in-place; use '-' for stdout"
-  )
-  .action(async (path: string, patch: string, options) => {
-    let patchParsed: PatchInstruction[];
-    let patchData: string;
-    try {
-      if (patch === "-") {
-        patchData = await readStdin();
-      } else {
-        patchData = await fs.readFile(patch, "utf-8");
-      }
-    } catch (e) {
-      console.error("Failed to read patch: ", e);
-      process.exit(1);
-    }
-
-    try {
-      const parsedData = JSON.parse(patchData);
-      if (!Array.isArray(parsedData)) {
-        patchParsed = [parsedData];
-      } else {
-        patchParsed = parsedData;
-      }
-    } catch (e) {
-      console.error("Could not parse patch file as JSON");
-      process.exit(1);
-    }
-
-    let document = await fs.readFile(path, "utf-8");
-    console.log("Document", document);
-    for (const instruction of patchParsed) {
-      document = applyPatch(document, instruction);
-    }
-
-    if (options.output === "-") {
-      process.stdout.write(document);
-    } else {
-      await fs.writeFile(options.output ? options.output : path, document);
-    }
-  });
-
-program.parse(process.argv);

package/src/debug.ts

@@ -1,75 +0,0 @@
-import chalk from "chalk";
-import { DocumentMap } from "./types.js";
-
-export const printMap = (
-  content: string,
-  documentMap: DocumentMap,
-  regex: RegExp | undefined
-): void => {
-  for (const type in documentMap) {
-    for (const positionName in documentMap[type as keyof typeof documentMap]) {
-      const position =
-        documentMap[type as keyof typeof documentMap][positionName];
-
-      const blockName = `${type} :: ${positionName.replaceAll(
-        "\u001f",
-        " :: "
-      )}`;
-      if (regex && !blockName.match(regex)) {
-        continue;
-      }
-      console.log("\n" + chalk.blue(blockName));
-      if (position.content.start < position.marker.start) {
-        console.log(
-          content
-            .slice(position.content.start - 100, position.content.start)
-            .replaceAll("\n", "\\n\n") +
-            chalk.black.bgGreen(
-              content
-                .slice(position.content.start, position.content.end)
-                .replaceAll("\n", "\\n\n")
-            ) +
-            content
-              .slice(
-                position.content.end,
-                Math.min(position.content.end + 100, position.marker.start)
-              )
-              .replaceAll("\n", "\\n\n") +
-            chalk.black.bgRed(
-              content
-                .slice(position.marker.start, position.marker.end)
-                .replaceAll("\n", "\\n\n")
-            ) +
-            content
-              .slice(position.marker.end, position.marker.end + 100)
-              .replaceAll("\n", "\\n\n")
-        );
-      } else {
-        console.log(
-          content
-            .slice(position.marker.start - 100, position.marker.start)
-            .replaceAll("\n", "\\n\n") +
-            chalk.black.bgRed(
-              content
-                .slice(position.marker.start, position.marker.end)
-                .replaceAll("\n", "\\n\n")
-            ) +
-            content
-              .slice(
-                position.marker.end,
-                Math.min(position.marker.end + 100, position.content.start)
-              )
-              .replaceAll("\n", "\\n\n") +
-            chalk.black.bgGreen(
-              content
-                .slice(position.content.start, position.content.end)
-                .replaceAll("\n", "\\n\n")
-            ) +
-            content
-              .slice(position.content.end, position.content.end + 100)
-              .replaceAll("\n", "\\n\n")
-        );
-      }
-    }
-  }
-};

package/src/index.ts

@@ -1,9 +0,0 @@
-import {
-  PatchFailureReason,
-  PatchFailed,
-  PatchError,
-  TablePartsNotFound,
-  applyPatch,
-} from "./patch.js";
-
-export * from "./types.js";