markdown-patch 0.1.1 → 0.1.2

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