markdown-patch 0.1.2 → 0.2.0

package/dist/patch.js

@@ -1,11 +1,16 @@
 import { getDocumentMap } from "./map.js";
 import * as marked from "marked";
+import * as yaml from "yaml";
+import { ContentType } from "./types.js";
+import { isAppendableFrontmatterType, isDictionary, isList, isString, isStringArrayArray, } from "./typeGuards.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["ContentTypeInvalid"] = "content-type-invalid";
+    PatchFailureReason["ContentTypeInvalidForTarget"] = "content-type-invalid-for-target";
+    PatchFailureReason["ContentNotMergeable"] = "content-not-mergeable";
 })(PatchFailureReason || (PatchFailureReason = {}));
 export class PatchFailed extends Error {
     constructor(reason, instruction, targetMap) {
@@ -19,6 +24,8 @@ export class PatchFailed extends Error {
 }
 export class PatchError extends Error {
 }
+export class MergeNotPossible extends Error {
+}
 const replaceText = (document, instruction, target) => {
     return [
         document.slice(0, target.content.start),
@@ -65,11 +72,17 @@ 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);
+        if (isStringArrayArray(instruction.content)) {
+            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("| " + row.join(" | ") + " |" + table.lineEnding);
+        }
+        else {
+            throw new PatchFailed(PatchFailureReason.ContentTypeInvalid, instruction, target);
         }
         return [
             document.slice(0, target.content.start),
@@ -78,18 +91,24 @@ const replaceTable = (document, instruction, target) => {
         ].join("");
     }
     catch (TablePartsNotFound) {
-        throw new PatchFailed(PatchFailureReason.RequestedBlockTypeBehaviorUnavailable, instruction, target);
+        throw new PatchFailed(PatchFailureReason.ContentTypeInvalidForTarget, 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);
+        if (isStringArrayArray(instruction.content)) {
+            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("| " + row.join(" | ") + " |" + table.lineEnding);
+        }
+        else {
+            throw new PatchFailed(PatchFailureReason.ContentTypeInvalid, instruction, target);
         }
         tableRows.push(table.contentParts);
         return [
@@ -99,18 +118,24 @@ const prependTable = (document, instruction, target) => {
         ].join("");
     }
     catch (TablePartsNotFound) {
-        throw new PatchFailed(PatchFailureReason.RequestedBlockTypeBehaviorUnavailable, instruction, target);
+        throw new PatchFailed(PatchFailureReason.ContentTypeInvalidForTarget, 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);
+        if (isStringArrayArray(instruction.content)) {
+            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("| " + row.join(" | ") + " |" + table.lineEnding);
+        }
+        else {
+            throw new PatchFailed(PatchFailureReason.ContentTypeInvalid, instruction, target);
         }
         return [
             document.slice(0, target.content.start),
@@ -119,73 +144,198 @@ const appendTable = (document, instruction, target) => {
         ].join("");
     }
     catch (TablePartsNotFound) {
-        throw new PatchFailed(PatchFailureReason.RequestedBlockTypeBehaviorUnavailable, instruction, target);
+        throw new PatchFailed(PatchFailureReason.ContentTypeInvalidForTarget, instruction, target);
     }
 };
 const replace = (document, instruction, target) => {
-    const targetBlockTypeBehavior = "targetBlockTypeBehavior" in instruction &&
-        instruction.targetBlockTypeBehavior
-        ? instruction.targetBlockTypeBehavior
-        : "text";
-    switch (targetBlockTypeBehavior) {
-        case "text":
+    const contentType = "contentType" in instruction && instruction.contentType
+        ? instruction.contentType
+        : ContentType.text;
+    switch (contentType) {
+        case ContentType.text:
             return replaceText(document, instruction, target);
-        case "table":
+        case ContentType.json:
             return replaceTable(document, instruction, target);
     }
 };
 const prepend = (document, instruction, target) => {
-    const targetBlockTypeBehavior = "targetBlockTypeBehavior" in instruction &&
-        instruction.targetBlockTypeBehavior
-        ? instruction.targetBlockTypeBehavior
-        : "text";
-    switch (targetBlockTypeBehavior) {
-        case "text":
+    const contentType = "contentType" in instruction && instruction.contentType
+        ? instruction.contentType
+        : ContentType.text;
+    switch (contentType) {
+        case ContentType.text:
             return prependText(document, instruction, target);
-        case "table":
+        case ContentType.json:
             return prependTable(document, instruction, target);
     }
 };
 const append = (document, instruction, target) => {
-    const targetBlockTypeBehavior = "targetBlockTypeBehavior" in instruction &&
-        instruction.targetBlockTypeBehavior
-        ? instruction.targetBlockTypeBehavior
-        : "text";
-    switch (targetBlockTypeBehavior) {
-        case "text":
+    const contentType = "contentType" in instruction && instruction.contentType
+        ? instruction.contentType
+        : ContentType.text;
+    switch (contentType) {
+        case ContentType.text:
             return appendText(document, instruction, target);
-        case "table":
+        case ContentType.json:
             return appendTable(document, instruction, target);
     }
 };
+const addTargetHeading = (document, instruction, map) => {
+    const elements = [];
+    let bestTarget = map.heading[""];
+    for (const element of instruction.target ?? []) {
+        const possibleMatch = map.heading[[...elements, element].join("\u001f")];
+        if (possibleMatch) {
+            elements.push(element);
+            bestTarget = possibleMatch;
+        }
+        else {
+            break;
+        }
+    }
+    let finalContent = "";
+    let existingLevels = elements.length;
+    if (document.slice(bestTarget.content.end - map.lineEnding.length, bestTarget.content.end) !== map.lineEnding) {
+        finalContent += map.lineEnding;
+    }
+    for (const headingPart of (instruction.target ?? []).slice(existingLevels)) {
+        existingLevels += 1;
+        finalContent += `${"#".repeat(existingLevels)} ${headingPart}${map.lineEnding}`;
+    }
+    finalContent += instruction.content;
+    return [
+        document.slice(0, bestTarget.content.end),
+        finalContent,
+        document.slice(bestTarget.content.end),
+    ].join("");
+};
+const addTargetBlock = (document, instruction, map) => {
+    return (document +
+        map.lineEnding +
+        instruction.content +
+        map.lineEnding +
+        map.lineEnding +
+        "^" +
+        instruction.target);
+};
+const addTarget = (document, instruction, map) => {
+    switch (instruction.targetType) {
+        case "heading":
+            return addTargetHeading(document, instruction, map);
+        case "block":
+            return addTargetBlock(document, instruction, map);
+    }
+};
 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];
+        case "frontmatter":
+            return map.frontmatter[instruction.target];
     }
 };
+function mergeFrontmatterValue(obj1, obj2) {
+    if (isList(obj1) && isList(obj2)) {
+        return [...obj1, ...obj2];
+    }
+    else if (isDictionary(obj1) && isDictionary(obj2)) {
+        return { ...obj1, ...obj2 };
+    }
+    else if (isString(obj1) && isString(obj2)) {
+        return obj1 + obj2;
+    }
+    throw new Error(`Cannot merge objects of different types or unsupported types: ${typeof obj1} and ${typeof obj2}`);
+}
+function regenerateDocumentWithFrontmatter(frontmatter, document, map) {
+    const rawFrontmatterText = Object.values(frontmatter).some((value) => value !== undefined)
+        ? `---\n${yaml.stringify(frontmatter).trimEnd()}\n---\n`
+        : "";
+    const frontmatterText = map.lineEnding !== "\n"
+        ? rawFrontmatterText.replaceAll("\n", map.lineEnding)
+        : rawFrontmatterText;
+    const finalDocument = document.slice(map.contentOffset);
+    return frontmatterText + finalDocument;
+}
+/**
+ * Applies a patch to the specified document.
+ *
+ * @param document The document to apply the patch to.
+ * @param instruction The patch to apply.
+ * @returns The patched document
+ */
 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);
+    if (instruction.targetType === "block" ||
+        instruction.targetType === "heading") {
+        if (!target) {
+            if (instruction.createTargetIfMissing) {
+                return addTarget(document, instruction, map);
+            }
+            else {
+                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);
+        }
+    }
+    const frontmatter = { ...map.frontmatter };
+    if (frontmatter[instruction.target] === undefined) {
+        if (instruction.createTargetIfMissing) {
+            if (isList(instruction.content)) {
+                frontmatter[instruction.target] = [];
+            }
+            else if (isString(instruction.content)) {
+                frontmatter[instruction.target] = "";
+            }
+            else if (isDictionary(instruction.content)) {
+                frontmatter[instruction.target] = {};
+            }
+        }
+        else {
+            throw new PatchFailed(PatchFailureReason.InvalidTarget, instruction, null);
+        }
+    }
+    try {
+        switch (instruction.operation) {
+            case "append":
+                if (!isAppendableFrontmatterType(instruction.content)) {
+                    throw new MergeNotPossible();
+                }
+                frontmatter[instruction.target] = mergeFrontmatterValue(frontmatter[instruction.target], instruction.content);
+                break;
+            case "prepend":
+                if (!isAppendableFrontmatterType(instruction.content)) {
+                    throw new MergeNotPossible();
+                }
+                frontmatter[instruction.target] = mergeFrontmatterValue(instruction.content, frontmatter[instruction.target]);
+                break;
+            case "replace":
+                frontmatter[instruction.target] = instruction.content;
+                break;
+        }
+        return regenerateDocumentWithFrontmatter(frontmatter, document, map);
+    }
+    catch (error) {
+        if (error instanceof MergeNotPossible) {
+            throw new PatchFailed(PatchFailureReason.ContentNotMergeable, instruction, null);
+        }
+        throw error;
     }
 };

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

@@ -199,4 +199,27 @@ describe("map", () => {
         //console.log(JSON.stringify(actualBlocks, undefined, 4));
         expect(actualBlocks).toEqual(expectedBlocks);
     });
+    describe("frontmatter", () => {
+        test("exists", () => {
+            const actualFrontmatter = getDocumentMap(sample).frontmatter;
+            const expectedFrontmatter = {
+                aliases: ["Structured Markdown Patch"],
+                "project-type": "Technical",
+                repository: "https://github.com/coddingtonbear/markdown-patch",
+            };
+            expect(expectedFrontmatter).toEqual(actualFrontmatter);
+        });
+        test("does not exist", () => {
+            const sample = fs.readFileSync(path.join(__dirname, "sample.frontmatter.none.md"), "utf-8");
+            const actualFrontmatter = getDocumentMap(sample).frontmatter;
+            const expectedFrontmatter = {};
+            expect(expectedFrontmatter).toEqual(actualFrontmatter);
+        });
+        test("does not exist, but starts with hr", () => {
+            const sample = fs.readFileSync(path.join(__dirname, "sample.frontmatter.nonfrontmatter-hr.md"), "utf-8");
+            const actualFrontmatter = getDocumentMap(sample).frontmatter;
+            const expectedFrontmatter = {};
+            expect(expectedFrontmatter).toEqual(actualFrontmatter);
+        });
+    });
 });

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":""}