markdown-patch 0.1.0 → 0.1.2

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/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,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/map.ts

@@ -1,200 +0,0 @@
-import * as marked from "marked";
-
-import {
-  DocumentMap,
-  DocumentMapMarkerContentPair,
-  HeadingMarkerContentPair,
-} from "./types.js";
-
-import {
-  CAN_INCLUDE_BLOCK_REFERENCE,
-  TARGETABLE_BY_ISOLATED_BLOCK_REFERENCE,
-} from "./constants.js";
-
-function getHeadingPositions(
-  document: string,
-  tokens: marked.TokensList
-): Record<string, HeadingMarkerContentPair> {
-  // If the document starts with frontmatter, figure out where
-  // the frontmatter ends so we can know where the text of the
-  // document begins
-  let documentStart = 0;
-  if (tokens[0].type === "hr") {
-    documentStart = tokens[0].raw.length + 1;
-    for (const token of tokens.slice(1)) {
-      documentStart += token.raw.length;
-      if (token.type === "hr") {
-        break;
-      }
-    }
-  }
-
-  const positions: Record<string, HeadingMarkerContentPair> = {
-    "": {
-      content: {
-        start: documentStart,
-        end: document.length,
-      },
-      marker: {
-        start: 0,
-        end: 0,
-      },
-      level: 0,
-    },
-  };
-  const stack: Array<{ heading: string; position: HeadingMarkerContentPair }> =
-    [];
-
-  let currentPosition = 0;
-
-  tokens.forEach((token, index) => {
-    if (token.type === "heading") {
-      const headingToken = token as marked.Tokens.Heading;
-
-      const startHeading = document.indexOf(
-        headingToken.raw.trim(),
-        currentPosition
-      );
-      const endHeading = startHeading + headingToken.raw.trim().length + 1;
-      const headingLevel = headingToken.depth;
-
-      // Determine the start of the content after this heading
-      const startContent = endHeading;
-
-      // Determine the end of the content before the next heading of the same or higher level, or end of document
-      let endContent: number | undefined = undefined;
-      for (let i = index + 1; i < tokens.length; i++) {
-        if (
-          tokens[i].type === "heading" &&
-          (tokens[i] as marked.Tokens.Heading).depth <= headingLevel
-        ) {
-          endContent = document.indexOf(tokens[i].raw.trim(), startContent);
-          break;
-        }
-      }
-      if (endContent === undefined) {
-        endContent = document.length;
-      }
-
-      const currentHeading: HeadingMarkerContentPair = {
-        content: {
-          start: startContent,
-          end: endContent,
-        },
-        marker: {
-          start: startHeading,
-          end: endHeading,
-        },
-        level: headingLevel,
-      };
-
-      // Build the full heading path with parent headings separated by '\t'
-      let fullHeadingPath = headingToken.text.trim();
-      while (
-        stack.length &&
-        stack[stack.length - 1].position.level >= headingLevel
-      ) {
-        stack.pop();
-      }
-
-      if (stack.length) {
-        const parent = stack[stack.length - 1];
-        parent.position.content.end = endContent;
-        fullHeadingPath = `${parent.heading}\u001f${fullHeadingPath}`;
-      }
-
-      positions[fullHeadingPath] = currentHeading;
-      stack.push({ heading: fullHeadingPath, position: currentHeading });
-
-      currentPosition = endHeading;
-    }
-  });
-
-  return positions;
-}
-
-function getBlockPositions(
-  document: string,
-  tokens: marked.TokensList
-): Record<string, DocumentMapMarkerContentPair> {
-  const positions: Record<string, DocumentMapMarkerContentPair> = {};
-
-  let lastBlockDetails:
-    | {
-        token: marked.Token;
-        start: number;
-        end: number;
-      }
-    | undefined = undefined;
-  let startContent = 0;
-  let endContent = 0;
-  let endMarker = 0;
-  marked.walkTokens(tokens, (token) => {
-    const blockReferenceRegex = /(?:\s+|^)\^([a-zA-Z0-9_-]+)\s*$/;
-    startContent = document.indexOf(token.raw, startContent);
-    const match = blockReferenceRegex.exec(token.raw);
-    endContent = startContent + (match ? match.index : token.raw.length);
-    const startMarker = match ? startContent + match.index : -1;
-    endMarker = startContent + token.raw.length;
-    // The end of a list item token sometimes doesn't include the trailing
-    // newline -- i'm honestly not sure why, but treating it as
-    // included here would simplify my implementation
-    if (
-      document.slice(endMarker - 1, endMarker) !== "\n" &&
-      document.slice(endMarker, endMarker + 1) === "\n"
-    ) {
-      endMarker += 1;
-    } else if (
-      document.slice(endMarker - 2, endMarker) !== "\r\n" &&
-      document.slice(endMarker, endMarker + 2) === "\r\n"
-    ) {
-      endMarker += 2;
-    }
-    if (CAN_INCLUDE_BLOCK_REFERENCE.includes(token.type) && match) {
-      const name = match[1];
-      if (!name || match.index === undefined) {
-        return;
-      }
-
-      const finalStartContent = {
-        start: startContent,
-        end: endContent,
-      };
-      if (
-        finalStartContent.start === finalStartContent.end &&
-        lastBlockDetails
-      ) {
-        finalStartContent.start = lastBlockDetails.start;
-        finalStartContent.end = lastBlockDetails.end;
-      }
-
-      positions[name] = {
-        content: finalStartContent,
-        marker: {
-          start: startMarker,
-          end: endMarker,
-        },
-      };
-    }
-
-    if (TARGETABLE_BY_ISOLATED_BLOCK_REFERENCE.includes(token.type)) {
-      lastBlockDetails = {
-        token: token,
-        start: startContent,
-        end: endContent - 1,
-      };
-    }
-  });
-
-  return positions;
-}
-
-export const getDocumentMap = (document: string): DocumentMap => {
-  const lexer = new marked.Lexer();
-  const tokens = lexer.lex(document);
-
-  return {
-    heading: getHeadingPositions(document, tokens),
-    block: getBlockPositions(document, tokens),
-  };
-};

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";
-
-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);
-  }
-};