markdown-patch 0.1.1 → 0.1.3

package/dist/patch.js

@@ -0,0 +1,189 @@
+import { getDocumentMap } from "./map.js";
+import * as marked from "marked";
+import { ContentType } from "./constants.js";
+export var PatchFailureReason;
+(function (PatchFailureReason) {
+    PatchFailureReason["InvalidTarget"] = "invalid-target";
+    PatchFailureReason["ContentAlreadyPreexistsInTarget"] = "content-already-preexists-in-target";
+    PatchFailureReason["TableContentIncorrectColumnCount"] = "table-content-incorrect-column-count";
+    PatchFailureReason["RequestedBlockTypeBehaviorUnavailable"] = "requested-block-type-behavior-unavailable";
+})(PatchFailureReason || (PatchFailureReason = {}));
+export class PatchFailed extends Error {
+    constructor(reason, instruction, targetMap) {
+        super();
+        this.reason = reason;
+        this.instruction = instruction;
+        this.targetMap = targetMap;
+        this.name = "PatchFailed";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class PatchError extends Error {
+}
+const replaceText = (document, instruction, target) => {
+    return [
+        document.slice(0, target.content.start),
+        instruction.content,
+        document.slice(target.content.end),
+    ].join("");
+};
+const prependText = (document, instruction, target) => {
+    return [
+        document.slice(0, target.content.start),
+        instruction.content,
+        instruction.trimTargetWhitespace
+            ? document.slice(target.content.start).trimStart()
+            : document.slice(target.content.start),
+    ].join("");
+};
+const appendText = (document, instruction, target) => {
+    return [
+        instruction.trimTargetWhitespace
+            ? document.slice(0, target.content.end).trimEnd()
+            : document.slice(0, target.content.end),
+        instruction.content,
+        document.slice(target.content.end),
+    ].join("");
+};
+export class TablePartsNotFound extends Error {
+}
+const _getTableData = (document, target) => {
+    const targetTable = document.slice(target.content.start, target.content.end);
+    const tableToken = marked.lexer(targetTable)[0];
+    const match = /^(.*?)(?:\r?\n)(.*?)(\r?\n)/.exec(targetTable);
+    if (!(tableToken.type === "table") || !match) {
+        throw new TablePartsNotFound();
+    }
+    const lineEnding = match[3];
+    return {
+        token: tableToken,
+        lineEnding: match[3],
+        headerParts: match[1] + lineEnding + match[2] + lineEnding,
+        contentParts: targetTable.slice(match[0].length),
+    };
+};
+const replaceTable = (document, instruction, target) => {
+    try {
+        const table = _getTableData(document, target);
+        const tableRows = [table.headerParts];
+        for (const row of instruction.content) {
+            if (row.length !== table.token.header.length || typeof row === "string") {
+                throw new PatchFailed(PatchFailureReason.TableContentIncorrectColumnCount, instruction, target);
+            }
+            tableRows.push("| " + row.join(" | ") + " |" + table.lineEnding);
+        }
+        return [
+            document.slice(0, target.content.start),
+            tableRows.join(""),
+            document.slice(target.content.end),
+        ].join("");
+    }
+    catch (TablePartsNotFound) {
+        throw new PatchFailed(PatchFailureReason.RequestedBlockTypeBehaviorUnavailable, instruction, target);
+    }
+};
+const prependTable = (document, instruction, target) => {
+    try {
+        const table = _getTableData(document, target);
+        const tableRows = [table.headerParts];
+        for (const row of instruction.content) {
+            if (row.length !== table.token.header.length || typeof row === "string") {
+                throw new PatchFailed(PatchFailureReason.TableContentIncorrectColumnCount, instruction, target);
+            }
+            tableRows.push("| " + row.join(" | ") + " |" + table.lineEnding);
+        }
+        tableRows.push(table.contentParts);
+        return [
+            document.slice(0, target.content.start),
+            tableRows.join(""),
+            document.slice(target.content.end),
+        ].join("");
+    }
+    catch (TablePartsNotFound) {
+        throw new PatchFailed(PatchFailureReason.RequestedBlockTypeBehaviorUnavailable, instruction, target);
+    }
+};
+const appendTable = (document, instruction, target) => {
+    try {
+        const table = _getTableData(document, target);
+        const tableRows = [table.headerParts, table.contentParts];
+        for (const row of instruction.content) {
+            if (row.length !== table.token.header.length || typeof row === "string") {
+                throw new PatchFailed(PatchFailureReason.TableContentIncorrectColumnCount, instruction, target);
+            }
+            tableRows.push("| " + row.join(" | ") + " |" + table.lineEnding);
+        }
+        return [
+            document.slice(0, target.content.start),
+            tableRows.join(""),
+            document.slice(target.content.end),
+        ].join("");
+    }
+    catch (TablePartsNotFound) {
+        throw new PatchFailed(PatchFailureReason.RequestedBlockTypeBehaviorUnavailable, instruction, target);
+    }
+};
+const replace = (document, instruction, target) => {
+    const contentType = "contentType" in instruction && instruction.contentType
+        ? instruction.contentType
+        : ContentType.text;
+    switch (contentType) {
+        case ContentType.text:
+            return replaceText(document, instruction, target);
+        case ContentType.tableRows:
+            return replaceTable(document, instruction, target);
+    }
+};
+const prepend = (document, instruction, target) => {
+    const contentType = "contentType" in instruction && instruction.contentType
+        ? instruction.contentType
+        : ContentType.text;
+    switch (contentType) {
+        case ContentType.text:
+            return prependText(document, instruction, target);
+        case ContentType.tableRows:
+            return prependTable(document, instruction, target);
+    }
+};
+const append = (document, instruction, target) => {
+    const contentType = "contentType" in instruction && instruction.contentType
+        ? instruction.contentType
+        : ContentType.text;
+    switch (contentType) {
+        case ContentType.text:
+            return appendText(document, instruction, target);
+        case ContentType.tableRows:
+            return appendTable(document, instruction, target);
+    }
+};
+const getTarget = (map, instruction) => {
+    switch (instruction.targetType) {
+        case "heading":
+            return map.heading[instruction.target ? instruction.target.join("\u001f") : ""];
+        case "block":
+            return map.block[instruction.target];
+    }
+};
+export const applyPatch = (document, instruction) => {
+    const map = getDocumentMap(document);
+    const target = getTarget(map, instruction);
+    if (!target) {
+        throw new PatchFailed(PatchFailureReason.InvalidTarget, instruction, null);
+    }
+    if ((!("applyIfContentPreexists" in instruction) ||
+        !instruction.applyIfContentPreexists) &&
+        typeof instruction.content === "string" &&
+        document
+            .slice(target.content.start, target.content.end)
+            .includes(instruction.content.trim())) {
+        throw new PatchFailed(PatchFailureReason.ContentAlreadyPreexistsInTarget, instruction, target);
+    }
+    switch (instruction.operation) {
+        case "append":
+            return append(document, instruction, target);
+        case "prepend":
+            return prepend(document, instruction, target);
+        case "replace":
+            return replace(document, instruction, target);
+    }
+};

package/dist/tests/map.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=map.test.d.ts.map

package/dist/tests/map.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.test.d.ts","sourceRoot":"","sources":["../../src/tests/map.test.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=patch.test.d.ts.map

package/dist/tests/patch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.test.d.ts","sourceRoot":"","sources":["../../src/tests/patch.test.ts"],"names":[],"mappings":""}

package/dist/tests/patch.test.js

@@ -0,0 +1,223 @@
+import fs from "fs";
+import path from "path";
+import { applyPatch, PatchFailed } from "../patch";
+import { ContentType } from "../constants";
+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",
+                        target: "2c67a6",
+                        operation: "prepend",
+                        contentType: ContentType.tableRows,
+                        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",
+                        target: "2c67a6",
+                        operation: "append",
+                        contentType: ContentType.tableRows,
+                        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",
+                        target: "2c67a6",
+                        operation: "replace",
+                        contentType: ContentType.tableRows,
+                        content: [
+                            ["`something else`", "Some other application", "✅", "✅", "✅"],
+                        ],
+                    };
+                    const actualResult = applyPatch(sample, instruction);
+                    expect(actualResult).toEqual(expected);
+                });
+            });
+        });
+    });
+});