@unterberg/nivel 0.0.1

package/dist/chunk-45CLUNJW.js

@@ -0,0 +1,657 @@
+// src/components/code-blocks/index.ts
+import { transformerNotationHighlight } from "@brillout/shiki-transformers";
+import { transformerNotationDiff, transformerNotationWordHighlight } from "@shikijs/transformers";
+import rehypePrettyCode from "rehype-pretty-code";
+import remarkDirective from "remark-directive";
+
+// src/components/code-blocks/rehypeMetaToProps.ts
+import { visit } from "unist-util-visit";
+
+// src/components/code-blocks/meta.ts
+var kebabCase = (value) => {
+  return value.replace(/([a-z])([A-Z])/g, "$1-$2").replaceAll("_", "-").toLowerCase();
+};
+var KEY_VALUE_PAIR_RE = /(?<name>[a-zA-Z_-]+)(?:=([^"'\s]+))?/g;
+var RESERVED_CODE_BLOCK_META_NAMES = /* @__PURE__ */ new Set([
+  "choice",
+  "file-added",
+  "file-removed",
+  "hide-menu",
+  "max-width",
+  "ts-only"
+]);
+var parseMetaString = (meta, propNames) => {
+  if (typeof meta !== "string" || meta.trim() === "") {
+    return { props: {}, rest: "", tokens: [] };
+  }
+  const props = {};
+  const tokens = [];
+  const rest = meta.replaceAll(KEY_VALUE_PAIR_RE, (match, name, value) => {
+    const normalizedName = kebabCase(name);
+    tokens.push({
+      hasExplicitValue: value !== void 0,
+      name: normalizedName,
+      raw: match,
+      value
+    });
+    if (propNames && !propNames.includes(normalizedName)) {
+      return match;
+    }
+    props[normalizedName] = value || "true";
+    return "";
+  });
+  return {
+    props,
+    rest: rest.trim(),
+    tokens
+  };
+};
+var getCodeBlockPropsFromMeta = (meta) => {
+  const parsed = parseMetaString(meta);
+  const props = { ...parsed.props };
+  const implicitTitleToken = parsed.tokens.find(
+    (token) => !token.hasExplicitValue && !RESERVED_CODE_BLOCK_META_NAMES.has(token.name)
+  );
+  const explicitTitle = typeof props.title === "string" && props.title.trim() ? props.title.trim() : null;
+  delete props.title;
+  if (implicitTitleToken) {
+    delete props[implicitTitleToken.name];
+  }
+  return {
+    props,
+    title: explicitTitle ?? implicitTitleToken?.raw.trim() ?? null
+  };
+};
+
+// src/components/code-blocks/rehypeMetaToProps.ts
+var rehypeMetaToProps = () => {
+  return (tree) => {
+    visit(tree, "element", (node, _index, parent) => {
+      if (node.tagName !== "code" || parent?.type !== "element" || parent.tagName !== "pre") {
+        return;
+      }
+      const meta = getCodeBlockPropsFromMeta(node.data?.meta);
+      parent.properties ??= {};
+      parent.properties = {
+        ...parent.properties,
+        ...meta.props,
+        ...meta.title ? { "data-code-title": meta.title } : {}
+      };
+    });
+  };
+};
+
+// src/components/code-blocks/remarkChoiceGroup.ts
+import { visit as visit2 } from "unist-util-visit";
+
+// src/components/code-blocks/generateChoiceGroupCode.ts
+import { valueToEstree } from "estree-util-value-to-estree";
+var BUILT_IN_CHOICE_GROUPS = {
+  codeLang: {
+    choices: ["JavaScript", "TypeScript"],
+    default: "JavaScript"
+  },
+  pkgManager: {
+    choices: ["npm", "pnpm", "Bun", "Yarn"],
+    default: "npm"
+  }
+};
+var getChoiceGroup = (choicesRaw) => {
+  const choices = [...new Set(choicesRaw.filter(Boolean))];
+  for (const [name, group] of Object.entries(BUILT_IN_CHOICE_GROUPS)) {
+    if (!choices.every((choice) => group.choices.includes(choice))) {
+      continue;
+    }
+    return {
+      name,
+      choices: group.choices,
+      default: group.default,
+      disabled: group.choices.filter((choice) => !choices.includes(choice))
+    };
+  }
+  return {
+    name: `custom:${choices.join("|")}`,
+    choices,
+    default: choices[0] ?? "",
+    disabled: []
+  };
+};
+var generateChoiceGroupCode = (choiceNodes, parent) => {
+  const choiceGroup = getChoiceGroup(choiceNodes.map((choiceNode) => choiceNode.choiceValue));
+  const mergedChoiceNodes = choiceGroup.choices.map((choice) => {
+    const choiceNode = choiceNodes.find((node) => node.choiceValue === choice);
+    return {
+      choiceValue: choice,
+      children: choiceNode?.children ?? []
+    };
+  });
+  const attributes = [
+    {
+      type: "mdxJsxAttribute",
+      name: "choiceGroup",
+      value: {
+        type: "mdxJsxAttributeValueExpression",
+        value: "",
+        data: {
+          estree: {
+            type: "Program",
+            sourceType: "module",
+            comments: [],
+            body: [
+              {
+                type: "ExpressionStatement",
+                expression: valueToEstree(choiceGroup)
+              }
+            ]
+          }
+        }
+      }
+    }
+  ];
+  if (choiceNodes.length === 1) {
+    attributes.push({ type: "mdxJsxAttribute", name: "hide" });
+  }
+  attributes.push({
+    type: "mdxJsxAttribute",
+    name: "lvl",
+    value: `${parent?.type === "mdxJsxFlowElement" ? 1 : 0}`
+  });
+  const children = mergedChoiceNodes.map((choiceNode) => {
+    const choiceChildren = choiceNode.children.length > 0 && choiceNode.children.every((node) => node.type === "containerDirective") ? choiceNode.children.flatMap((node) => node.children ?? []) : choiceNode.children;
+    for (const child of choiceChildren) {
+      increaseLvl(child);
+    }
+    return {
+      type: "mdxJsxFlowElement",
+      name: "div",
+      attributes: [
+        {
+          type: "mdxJsxAttribute",
+          name: "data-choice-value",
+          value: choiceNode.choiceValue
+        },
+        { type: "mdxJsxAttribute", name: "className", value: "choice" }
+      ],
+      children: choiceChildren
+    };
+  });
+  return {
+    type: "mdxJsxFlowElement",
+    name: "ChoiceGroup",
+    attributes,
+    children
+  };
+};
+var increaseLvl = (node) => {
+  if (node?.type !== "mdxJsxFlowElement" || node.name !== "ChoiceGroup") {
+    return;
+  }
+  const attribute = node.attributes.find(
+    (candidate) => candidate.type === "mdxJsxAttribute" && candidate.name === "lvl"
+  );
+  if (typeof attribute?.value === "string") {
+    attribute.value = `${Number(attribute.value) + 1}`;
+  }
+};
+
+// src/components/code-blocks/remarkChoiceGroup.ts
+var remarkChoiceGroup = () => {
+  return (tree) => {
+    visit2(tree, (node) => {
+      if (node.type === "code" && node.meta) {
+        const meta = parseMetaString(node.meta, ["choice"]);
+        const choice = meta.props.choice;
+        node.meta = meta.rest;
+        if (choice) {
+          node.data ??= {};
+          node.data.customDataChoice = choice;
+          node.data.customDataFilter = "explicitChoice";
+        }
+      }
+      if (node.type === "containerDirective" && node.name === "Choice") {
+        const choice = typeof node.attributes?.id === "string" ? node.attributes.id : null;
+        if (!choice) {
+          return;
+        }
+        node.data ??= {};
+        node.data.customDataChoice = choice;
+        node.data.customDataFilter = node.type;
+        node.attributes = {};
+      }
+    });
+    visit2(tree, (node) => {
+      if (!Array.isArray(node.children)) {
+        return;
+      }
+      let start = -1;
+      let end = 0;
+      const processRange = () => {
+        if (start === -1 || start === end) {
+          return;
+        }
+        const nodes = node.children.slice(start, end);
+        const replacements = filterChoices(nodes).map((choiceNodes) => generateChoiceGroupCode(choiceNodes, node));
+        node.children.splice(start, end - start, ...replacements);
+        end = start + replacements.length;
+        start = -1;
+      };
+      for (; end < node.children.length; end += 1) {
+        const child = node.children[end];
+        if (!["code", "mdxJsxFlowElement", "containerDirective"].includes(child?.type)) {
+          processRange();
+          continue;
+        }
+        if (!child.data?.customDataChoice) {
+          processRange();
+          continue;
+        }
+        if (start === -1) {
+          start = end;
+        }
+      }
+      processRange();
+    });
+  };
+};
+var filterChoices = (nodes) => {
+  const filteredChoices = [];
+  const filters = [...new Set(nodes.map((node) => node.data?.customDataFilter).filter(Boolean))];
+  for (const filter of filters) {
+    const nodesByChoice = /* @__PURE__ */ new Map();
+    for (const node of nodes.filter((candidate) => candidate.data?.customDataFilter === filter)) {
+      const choice = node.data?.customDataChoice;
+      if (!choice) {
+        continue;
+      }
+      node.data.customDataChoice = void 0;
+      const choiceNodes = nodesByChoice.get(choice) ?? [];
+      choiceNodes.push(node);
+      nodesByChoice.set(choice, choiceNodes);
+    }
+    filteredChoices.push(
+      [...nodesByChoice].map(([choiceValue, children]) => ({
+        choiceValue,
+        children
+      }))
+    );
+  }
+  return filteredChoices;
+};
+
+// src/components/code-blocks/remarkDetype.ts
+import { transform as detype } from "detype";
+import { visit as visit3 } from "unist-util-visit";
+var prettierOptions = {
+  semi: false,
+  singleQuote: true,
+  trailingComma: "none"
+};
+var remarkDetype = () => {
+  return async (tree, file) => {
+    const codeNodes = [];
+    visit3(tree, "code", (node, index, parent) => {
+      if (!parent || typeof index !== "number") {
+        return;
+      }
+      if (!["ts", "tsx", "vue", "yaml"].includes(node.lang ?? "")) {
+        return;
+      }
+      if (typeof node.meta === "string" && node.meta.includes("ts-only")) {
+        return;
+      }
+      codeNodes.push({ codeBlock: node, index, parent });
+    });
+    for (const node of [...codeNodes].reverse()) {
+      if (node.codeBlock.lang === "yaml") {
+        transformYaml(node);
+      } else {
+        await transformTsToJs(node, file);
+      }
+    }
+  };
+};
+var transformYaml = (node) => {
+  const { codeBlock, index, parent } = node;
+  const codeBlockContentJs = replaceFileNameSuffixes(codeBlock.value);
+  if (codeBlockContentJs === codeBlock.value) {
+    return;
+  }
+  const meta = parseMetaString(codeBlock.meta, ["choice"]);
+  const choice = meta.props.choice;
+  codeBlock.meta = meta.rest;
+  const yamlJsCode = {
+    ...codeBlock,
+    value: codeBlockContentJs
+  };
+  const replacement = generateChoiceGroupCode([
+    { choiceValue: "JavaScript", children: [yamlJsCode] },
+    { choiceValue: "TypeScript", children: [codeBlock] }
+  ]);
+  replacement.attributes.push({ type: "mdxJsxAttribute", name: "hide" });
+  replacement.data ??= {};
+  replacement.data.customDataChoice = choice;
+  replacement.data.customDataFilter = "codeLang";
+  parent.children.splice(index, 1, replacement);
+};
+var transformTsToJs = async (node, file) => {
+  const { codeBlock, index, parent } = node;
+  const meta = parseMetaString(codeBlock.meta, ["max-width", "choice"]);
+  const maxWidth = Number(meta.props["max-width"]);
+  const choice = meta.props.choice;
+  codeBlock.meta = meta.rest;
+  codeBlock.data ??= {};
+  codeBlock.data.customDataChoice = choice;
+  codeBlock.data.customDataFilter = "codeLang";
+  if (choice === "TypeScript") {
+    return;
+  }
+  const codeBlockReplacedJs = replaceFileNameSuffixes(codeBlock.value);
+  let codeBlockContentJs = "";
+  try {
+    codeBlockContentJs = await detype(codeBlockReplacedJs, `snippet.${codeBlock.lang}`, {
+      customizeBabelConfig(config) {
+        if (!config.presets || config.presets.length !== 1) {
+          return;
+        }
+        config.presets = [[config.presets[0], { onlyRemoveTypeImports: true }]];
+      },
+      removeTsComments: true,
+      prettierOptions: {
+        ...prettierOptions,
+        printWidth: Number.isFinite(maxWidth) && maxWidth > 0 ? maxWidth : 99
+      }
+    });
+  } catch (error) {
+    console.error(
+      [
+        `Failed to detype code block in ${file?.path ?? "an MDX file"}.`,
+        error instanceof Error ? error.message : String(error)
+      ].join("\n")
+    );
+    return;
+  }
+  codeBlockContentJs = cleanUpCode(codeBlockContentJs.trimEnd(), true);
+  codeBlock.value = cleanUpCode(codeBlock.value);
+  codeBlockContentJs = preserveSourceLineBreaks(codeBlock.value, codeBlockContentJs);
+  codeBlockContentJs = preserveSourceBlankLines(codeBlock.value, codeBlockContentJs);
+  if (codeBlockContentJs === codeBlock.value) {
+    return;
+  }
+  const tsCode = { ...codeBlock, lang: codeBlock.lang };
+  const jsCode = {
+    ...codeBlock,
+    lang: String(codeBlock.lang).replace("t", "j"),
+    value: codeBlockContentJs
+  };
+  const replacement = generateChoiceGroupCode([
+    { choiceValue: "JavaScript", children: [jsCode] },
+    { choiceValue: "TypeScript", children: [tsCode] }
+  ]);
+  if (codeBlockReplacedJs === codeBlockContentJs) {
+    replacement.attributes.push({ type: "mdxJsxAttribute", name: "hide" });
+  }
+  replacement.data ??= {};
+  replacement.data.customDataChoice = codeBlock.data.customDataChoice;
+  replacement.data.customDataFilter = codeBlock.data.customDataFilter;
+  parent.children.splice(index, 1, replacement);
+};
+var replaceFileNameSuffixes = (value) => value.replaceAll(".ts", ".js");
+var cleanUpCode = (code, isJsCode = false) => {
+  if (isJsCode) {
+    code = correctCodeDiffComments(code);
+  }
+  return processMagicComments(code);
+};
+var processMagicComments = (code) => {
+  const renameCommentRe = /^\s*\/\/\s@docpress-replace\s([^ ]+) ([^ ]+)\n/gm;
+  const matches = Array.from(code.matchAll(renameCommentRe));
+  for (let index = matches.length - 1; index >= 0; index -= 1) {
+    const match = matches[index];
+    if (!match) {
+      continue;
+    }
+    const [fullMatch, renameFrom, renameTo] = match;
+    code = code.split(fullMatch).join("").replaceAll(renameFrom, renameTo);
+  }
+  return code.replaceAll("// @docpress-uncomment ", "");
+};
+var correctCodeDiffComments = (code) => {
+  return code.replaceAll(/\n\s*\/\/\s\[!code.+\]/g, (codeDiff) => codeDiff.trimStart());
+};
+var preserveSourceLineBreaks = (sourceCode, outputCode) => {
+  const multilineSegments = collectMultilineSourceSegments(sourceCode);
+  if (multilineSegments.length === 0) {
+    return outputCode;
+  }
+  const outputLines = outputCode.split("\n");
+  for (const segmentLines of multilineSegments) {
+    const segmentNormalized = normalizeCodeSegment(segmentLines.join("\n"));
+    if (!segmentNormalized) {
+      continue;
+    }
+    for (let start = 0; start < outputLines.length; start += 1) {
+      let replaced = false;
+      for (let size = 1; size <= segmentLines.length; size += 1) {
+        if (start + size > outputLines.length) {
+          break;
+        }
+        const outputSegment = outputLines.slice(start, start + size);
+        if (normalizeCodeSegment(outputSegment.join("\n")) !== segmentNormalized) {
+          continue;
+        }
+        if (outputSegment.join("\n") !== segmentLines.join("\n")) {
+          outputLines.splice(start, size, ...segmentLines);
+        }
+        start += segmentLines.length - 1;
+        replaced = true;
+        break;
+      }
+      if (replaced) {
+        break;
+      }
+    }
+  }
+  return outputLines.join("\n");
+};
+var collectMultilineSourceSegments = (code) => {
+  const lines = code.split("\n");
+  const segments = [];
+  let paragraphStart = -1;
+  for (let index = 0; index <= lines.length; index += 1) {
+    if (index < lines.length && lines[index]?.trim() !== "") {
+      if (paragraphStart === -1) {
+        paragraphStart = index;
+      }
+      continue;
+    }
+    if (paragraphStart !== -1) {
+      const paragraphEnd = index - 1;
+      for (let size = paragraphEnd - paragraphStart + 1; size >= 2; size -= 1) {
+        for (let start = paragraphStart; start + size - 1 <= paragraphEnd; start += 1) {
+          segments.push(lines.slice(start, start + size).map(replaceFileNameSuffixes));
+        }
+      }
+    }
+    paragraphStart = -1;
+  }
+  return segments;
+};
+var preserveSourceBlankLines = (sourceCode, outputCode) => {
+  const blankLineAnchors = collectBlankLineAnchors(sourceCode);
+  if (blankLineAnchors.length === 0) {
+    return outputCode;
+  }
+  const outputLines = outputCode.split("\n");
+  let searchFrom = 0;
+  for (const anchor of blankLineAnchors) {
+    const lineIndex = outputLines.findIndex((line, index) => index >= searchFrom && normalizeCodeLine(line) === anchor);
+    if (lineIndex <= 0) {
+      continue;
+    }
+    if (outputLines[lineIndex - 1]?.trim() !== "") {
+      outputLines.splice(lineIndex, 0, "");
+      searchFrom = lineIndex + 2;
+    } else {
+      searchFrom = lineIndex + 1;
+    }
+  }
+  return outputLines.join("\n");
+};
+var collectBlankLineAnchors = (code) => {
+  const lines = code.split("\n");
+  const anchors = [];
+  for (let index = 1; index < lines.length; index += 1) {
+    if (lines[index]?.trim() !== "" || lines[index - 1]?.trim() === "") {
+      continue;
+    }
+    let nextLineIndex = index + 1;
+    while (nextLineIndex < lines.length && lines[nextLineIndex]?.trim() === "") {
+      nextLineIndex += 1;
+    }
+    const anchor = lines[nextLineIndex];
+    if (anchor) {
+      anchors.push(normalizeCodeLine(anchor));
+    }
+  }
+  return anchors;
+};
+var normalizeCodeLine = (line) => {
+  return stripTypeSyntax(replaceFileNameSuffixes(line)).trim().replace(/\s+/g, " ");
+};
+var normalizeCodeSegment = (code) => {
+  return replaceFileNameSuffixes(code).replace(/\s+/g, "");
+};
+var stripTypeSyntax = (line) => {
+  return line.replace(/\??:\s*[A-Za-z_$][\w$.<>, |&[\]]*/g, "").replace(/\s+as\s+const\b/g, "").replace(/\s+as\s+[A-Za-z_$][\w$.<>, |&[\]]*/g, "");
+};
+
+// src/components/code-blocks/remarkPkgManager.ts
+import convert_ from "npm-to-yarn";
+import { visit as visit4 } from "unist-util-visit";
+var convert = convert_;
+var PACKAGE_MANAGERS = ["pnpm", "Bun", "Yarn"];
+var remarkPkgManager = () => {
+  return (tree) => {
+    visit4(tree, "code", (node, index, parent) => {
+      if (!parent || typeof index !== "number") {
+        return;
+      }
+      if (!["bash", "sh", "shell"].includes(node.lang ?? "")) {
+        return;
+      }
+      if (node.value.includes("pnpm")) {
+        return;
+      }
+      if (!node.value.includes("npm ") && !node.value.includes("npx ")) {
+        return;
+      }
+      let choice;
+      if (node.meta) {
+        const meta = parseMetaString(node.meta, ["choice"]);
+        choice = meta.props.choice;
+        node.meta = meta.rest;
+      }
+      node.value = node.value.replaceAll("npm i ", "npm install ");
+      const nodes = /* @__PURE__ */ new Map();
+      nodes.set("npm", node);
+      for (const packageManager of PACKAGE_MANAGERS) {
+        nodes.set(packageManager, {
+          ...node,
+          value: convert(node.value, packageManager.toLowerCase())
+        });
+      }
+      const replacement = generateChoiceGroupCode(
+        [...nodes].map(([choiceValue, childNode]) => ({
+          choiceValue,
+          children: [childNode]
+        }))
+      );
+      replacement.data ??= {};
+      replacement.data.customDataChoice = choice;
+      replacement.data.customDataFilter = replacement.type;
+      parent.children.splice(index, 1, replacement);
+    });
+  };
+};
+
+// src/components/code-blocks/shikiTransformerAutoLinks.ts
+var LINK_RE = /https:\/\/[^\s]*[^.,\s"'`]/g;
+var shikiTransformerAutoLinks = () => {
+  return {
+    name: "solid-docpress-shiki-autolinks",
+    span(span) {
+      if (span.children.length !== 1) {
+        return;
+      }
+      let child = span.children[0];
+      if (child.type !== "text") {
+        return;
+      }
+      const matches = Array.from(child.value.matchAll(LINK_RE)).filter(([href]) => !href.includes("${"));
+      if (matches.length === 0) {
+        return;
+      }
+      const links = matches.map((match) => ({ href: match[0], index: match.index ?? 0 })).sort((left, right) => right.index - left.index);
+      const nextChildren = [];
+      for (const { href, index } of links) {
+        const endIndex = index + href.length;
+        const trailingText = child.value.slice(endIndex);
+        if (trailingText) {
+          nextChildren.unshift({ type: "text", value: trailingText });
+        }
+        nextChildren.unshift({
+          type: "element",
+          tagName: "a",
+          properties: { href },
+          children: [{ type: "text", value: href }]
+        });
+        child = {
+          type: "text",
+          value: child.value.slice(0, index)
+        };
+      }
+      if (child.value) {
+        nextChildren.unshift(child);
+      }
+      span.children = nextChildren;
+    }
+  };
+};
+
+// src/components/code-blocks/index.ts
+var getCodeBlockMdxPlugins = () => {
+  return {
+    remarkPlugins: [remarkDirective, remarkDetype, remarkPkgManager, remarkChoiceGroup],
+    rehypePlugins: [
+      [
+        rehypePrettyCode,
+        {
+          keepBackground: false,
+          theme: {
+            light: "github-light",
+            dark: "one-dark-pro"
+          },
+          transformers: [
+            transformerNotationDiff(),
+            transformerNotationHighlight(),
+            transformerNotationWordHighlight(),
+            shikiTransformerAutoLinks()
+          ]
+        }
+      ],
+      rehypeMetaToProps
+    ]
+  };
+};
+
+export {
+  parseMetaString,
+  getCodeBlockPropsFromMeta,
+  rehypeMetaToProps,
+  remarkChoiceGroup,
+  remarkDetype,
+  remarkPkgManager,
+  shikiTransformerAutoLinks,
+  getCodeBlockMdxPlugins
+};
+//# sourceMappingURL=chunk-45CLUNJW.js.map