@helpwave/hightide/dist/components/layout-and-navigation/MarkdownInterpreter.mjs

helpwave's component and theming library

// src/components/layout-and-navigation/MarkdownInterpreter.tsx
import { Fragment, jsx } from "react/jsx-runtime";
var astNodeInserterType = ["helpwave", "newline"];
var ASTNodeInterpreter = ({
  node,
  isRoot = false,
  className = ""
}) => {
  switch (node.type) {
    case "newline":
      return /* @__PURE__ */ jsx("br", {});
    case "text":
      return isRoot ? /* @__PURE__ */ jsx("span", { className, children: node.text }) : node.text;
    case "helpwave":
      return /* @__PURE__ */ jsx("span", { className: "font-bold font-space no-underline", children: "helpwave" });
    case "none":
      return isRoot ? /* @__PURE__ */ jsx("span", { className, children: node.children.map((value, index) => /* @__PURE__ */ jsx(
        ASTNodeInterpreter,
        {
          node: value
        },
        index
      )) }) : /* @__PURE__ */ jsx(Fragment, { children: node.children.map((value, index) => /* @__PURE__ */ jsx(ASTNodeInterpreter, { node: value }, index)) });
    case "bold":
      return /* @__PURE__ */ jsx("b", { children: node.children.map((value, index) => /* @__PURE__ */ jsx(ASTNodeInterpreter, { node: value }, index)) });
    case "italic":
      return /* @__PURE__ */ jsx("i", { children: node.children.map((value, index) => /* @__PURE__ */ jsx(ASTNodeInterpreter, { node: value }, index)) });
    case "underline":
      return /* @__PURE__ */ jsx("u", { children: node.children.map((value, index) => /* @__PURE__ */ jsx(ASTNodeInterpreter, { node: value }, index)) });
    case "font-space":
      return /* @__PURE__ */ jsx("span", { className: "font-space", children: node.children.map((value, index) => /* @__PURE__ */ jsx(
        ASTNodeInterpreter,
        {
          node: value
        },
        index
      )) });
    case "primary":
      return /* @__PURE__ */ jsx("span", { className: "text-primary", children: node.children.map((value, index) => /* @__PURE__ */ jsx(
        ASTNodeInterpreter,
        {
          node: value
        },
        index
      )) });
    case "secondary":
      return /* @__PURE__ */ jsx("span", { className: "text-secondary", children: node.children.map((value, index) => /* @__PURE__ */ jsx(
        ASTNodeInterpreter,
        {
          node: value
        },
        index
      )) });
    case "warn":
      return /* @__PURE__ */ jsx("span", { className: "text-warning", children: node.children.map((value, index) => /* @__PURE__ */ jsx(
        ASTNodeInterpreter,
        {
          node: value
        },
        index
      )) });
    case "positive":
      return /* @__PURE__ */ jsx("span", { className: "text-positive", children: node.children.map((value, index) => /* @__PURE__ */ jsx(
        ASTNodeInterpreter,
        {
          node: value
        },
        index
      )) });
    case "negative":
      return /* @__PURE__ */ jsx("span", { className: "text-negative", children: node.children.map((value, index) => /* @__PURE__ */ jsx(
        ASTNodeInterpreter,
        {
          node: value
        },
        index
      )) });
    default:
      return null;
  }
};
var modifierIdentifierMapping = [
  { id: "i", name: "italic" },
  { id: "b", name: "bold" },
  { id: "u", name: "underline" },
  { id: "space", name: "font-space" },
  { id: "primary", name: "primary" },
  { id: "secondary", name: "secondary" },
  { id: "warn", name: "warn" },
  { id: "positive", name: "positive" },
  { id: "negative", name: "negative" }
];
var inserterIdentifierMapping = [
  { id: "helpwave", name: "helpwave" },
  { id: "newline", name: "newline" }
];
var parseMarkdown = (text, commandStart = "\\", open = "{", close = "}") => {
  let start = text.indexOf(commandStart);
  const children = [];
  while (text !== "") {
    if (start === -1) {
      children.push({
        type: "text",
        text
      });
      break;
    }
    children.push(parseMarkdown(text.substring(0, start)));
    text = text.substring(start);
    if (text.length <= 1) {
      children.push({
        type: "text",
        text
      });
      text = "";
      continue;
    }
    const simpleReplace = [commandStart, open, close];
    if (simpleReplace.some((value) => text[1] === value)) {
      children.push({
        type: "text",
        text: simpleReplace.find((value) => text[1] === value)
      });
      text = text.substring(2);
      start = text.indexOf(commandStart);
      continue;
    }
    const inserter = inserterIdentifierMapping.find((value) => text.substring(1).startsWith(value.id));
    if (inserter) {
      children.push({
        type: inserter.name
      });
      text = text.substring(inserter.id.length + 1);
      start = text.indexOf(commandStart);
      continue;
    }
    const modifier = modifierIdentifierMapping.find((value) => text.substring(1).startsWith(value.id));
    if (modifier) {
      if (text[modifier.id.length + 1] !== open) {
        children.push({
          type: "text",
          text: text.substring(0, modifier.id.length + 1)
        });
        text = text.substring(modifier.id.length + 2);
        start = text.indexOf(commandStart);
        continue;
      }
      let closing = -1;
      let index = modifier.id.length + 2;
      let counter = 1;
      let escaping = false;
      while (index < text.length) {
        if (text[index] === open && !escaping) {
          counter++;
        }
        if (text[index] === close && !escaping) {
          counter--;
          if (counter === 0) {
            closing = index;
            break;
          }
        }
        escaping = text[index] === commandStart;
        index++;
      }
      if (closing !== -1) {
        children.push({
          type: modifier.name,
          children: [parseMarkdown(text.substring(modifier.id.length + 2, closing))]
        });
        text = text.substring(closing + 1);
        start = text.indexOf(commandStart);
        continue;
      }
    }
    children.push({
      type: "text",
      text: text[0]
    });
    text = text.substring(1);
    start = text.indexOf(commandStart);
  }
  return {
    type: "none",
    children
  };
};
var optimizeTree = (node) => {
  if (node.type === "text") {
    return !node.text ? void 0 : node;
  }
  if (astNodeInserterType.some((value) => value === node.type)) {
    return node;
  }
  const currentNode = node;
  if (currentNode.children.length === 0) {
    return void 0;
  }
  let children = [];
  for (let i = 0; i < currentNode.children.length; i++) {
    const child = optimizeTree(currentNode.children[i]);
    if (!child) {
      continue;
    }
    if (child.type === "none") {
      children.push(...child.children);
    } else {
      children.push(child);
    }
  }
  currentNode.children = children;
  children = [];
  for (let i = 0; i < currentNode.children.length; i++) {
    const child = currentNode.children[i];
    if (child) {
      if (child.type === "text" && children[children.length - 1]?.type === "text") {
        children[children.length - 1].text += child.text;
      } else {
        children.push(child);
      }
    }
  }
  currentNode.children = children;
  return currentNode;
};
var MarkdownInterpreter = ({ text, className }) => {
  const tree = parseMarkdown(text);
  const optimizedTree = optimizeTree(tree);
  return /* @__PURE__ */ jsx(ASTNodeInterpreter, { node: optimizedTree, isRoot: true, className });
};
export {
  ASTNodeInterpreter,
  MarkdownInterpreter
};
//# sourceMappingURL=MarkdownInterpreter.mjs.map