markdown-patch 0.1.1 → 0.1.3

package/src/patch.ts

@@ -1,326 +0,0 @@
-import { getDocumentMap } from "./map.js";
-import * as marked from "marked";
-import {
-  AppendTableRowsBlockPatchInstruction,
-  PrependTableRowsBlockPatchInstruction,
-  DocumentMap,
-  DocumentMapMarkerContentPair,
-  ExtendingPatchInstruction,
-  PatchInstruction,
-  ReplaceTableRowsBlockPatchInstruction,
-} from "./types.js";
-
-export enum PatchFailureReason {
-  InvalidTarget = "invalid-target",
-  ContentAlreadyPreexistsInTarget = "content-already-preexists-in-target",
-  TableContentIncorrectColumnCount = "table-content-incorrect-column-count",
-  RequestedBlockTypeBehaviorUnavailable = "requested-block-type-behavior-unavailable",
-}
-
-export class PatchFailed extends Error {
-  public reason: PatchFailureReason;
-  public instruction: PatchInstruction;
-  public targetMap: DocumentMapMarkerContentPair | null;
-
-  constructor(
-    reason: PatchFailureReason,
-    instruction: PatchInstruction,
-    targetMap: DocumentMapMarkerContentPair | null
-  ) {
-    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: string,
-  instruction: PatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  return [
-    document.slice(0, target.content.start),
-    instruction.content,
-    document.slice(target.content.end),
-  ].join("");
-};
-
-const prependText = (
-  document: string,
-  instruction: ExtendingPatchInstruction & PatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  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: string,
-  instruction: ExtendingPatchInstruction & PatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  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: string,
-  target: DocumentMapMarkerContentPair
-): {
-  token: marked.Tokens.Table;
-  lineEnding: string;
-  headerParts: string;
-  contentParts: string;
-} => {
-  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 as marked.Tokens.Table,
-    lineEnding: match[3],
-    headerParts: match[1] + lineEnding + match[2] + lineEnding,
-    contentParts: targetTable.slice(match[0].length),
-  };
-};
-
-const replaceTable = (
-  document: string,
-  instruction: ReplaceTableRowsBlockPatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  try {
-    const table = _getTableData(document, target);
-    const tableRows: string[] = [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: string,
-  instruction: PrependTableRowsBlockPatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  try {
-    const table = _getTableData(document, target);
-    const tableRows: string[] = [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: string,
-  instruction: AppendTableRowsBlockPatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  try {
-    const table = _getTableData(document, target);
-    const tableRows: string[] = [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: string,
-  instruction: PatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  const targetBlockTypeBehavior =
-    "targetBlockTypeBehavior" in instruction
-      ? instruction.targetBlockTypeBehavior
-      : "text";
-
-  switch (targetBlockTypeBehavior) {
-    case "text":
-      return replaceText(document, instruction, target);
-    case "table":
-      return replaceTable(
-        document,
-        instruction as ReplaceTableRowsBlockPatchInstruction,
-        target
-      );
-  }
-};
-
-const prepend = (
-  document: string,
-  instruction: ExtendingPatchInstruction & PatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  const targetBlockTypeBehavior =
-    "targetBlockTypeBehavior" in instruction
-      ? instruction.targetBlockTypeBehavior
-      : "text";
-
-  switch (targetBlockTypeBehavior) {
-    case "text":
-      return prependText(document, instruction, target);
-    case "table":
-      return prependTable(
-        document,
-        instruction as PrependTableRowsBlockPatchInstruction,
-        target
-      );
-  }
-};
-
-const append = (
-  document: string,
-  instruction: ExtendingPatchInstruction & PatchInstruction,
-  target: DocumentMapMarkerContentPair
-): string => {
-  const targetBlockTypeBehavior =
-    "targetBlockTypeBehavior" in instruction
-      ? instruction.targetBlockTypeBehavior
-      : "text";
-
-  switch (targetBlockTypeBehavior) {
-    case "text":
-      return appendText(document, instruction, target);
-    case "table":
-      return appendTable(
-        document,
-        instruction as AppendTableRowsBlockPatchInstruction,
-        target
-      );
-  }
-};
-
-const getTarget = (
-  map: DocumentMap,
-  instruction: PatchInstruction
-): DocumentMapMarkerContentPair | undefined => {
-  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: string,
-  instruction: PatchInstruction
-): string => {
-  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/src/tests/map.test.ts

@@ -1,212 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-import { getDocumentMap } from "../map";
-import { DocumentMapMarkerContentPair } from "../types";
-
-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: Record<string, DocumentMapMarkerContentPair> = {
-      "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);
-  });
-});