mintlify 1.0.6 → 1.0.8

package/bin/mint/client/remark/utils.js

@@ -0,0 +1,369 @@
+import * as acorn from 'acorn';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { mdxJsxFromMarkdown } from 'mdast-util-mdx-jsx';
+import { mdxjsEsmFromMarkdown } from 'mdast-util-mdxjs-esm';
+import { mdxJsx } from 'micromark-extension-mdx-jsx';
+import { mdxjsEsm } from 'micromark-extension-mdxjs-esm';
+import Prism from 'prismjs';
+import loadLanguages from 'prismjs/components/index.js';
+import redent from 'redent';
+
+loadLanguages();
+
+const HTML_TAG =
+  /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/gi;
+const PSEUDO_CLASSES = [
+  'active',
+  'any-link',
+  'blank',
+  'checked',
+  'current',
+  'default',
+  'defined',
+  'dir',
+  'disabled',
+  'drop',
+  'empty',
+  'enabled',
+  'first',
+  'first-child',
+  'first-of-type',
+  'fullscreen',
+  'future',
+  'focus',
+  'focus-visible',
+  'focus-within',
+  'has',
+  'host',
+  'host',
+  'host-context',
+  'hover',
+  'indeterminate',
+  'in-range',
+  'invalid',
+  'is',
+  'lang',
+  'last-child',
+  'last-of-type',
+  'left',
+  'link',
+  'local-link',
+  'not',
+  'nth-child',
+  'nth-col',
+  'nth-last-child',
+  'nth-last-col',
+  'nth-last-of-type',
+  'nth-of-type',
+  'only-child',
+  'only-of-type',
+  'optional',
+  'out-of-range',
+  'past',
+  'picture-in-picture',
+  'placeholder-shown',
+  'read-only',
+  'read-write',
+  'required',
+  'right',
+  'root',
+  'scope',
+  'state',
+  'target',
+  'target-within',
+  'user-invalid',
+  'valid',
+  'visited',
+  'where',
+];
+
+Prism.hooks.add('wrap', (env) => {
+  if (env.type === 'atrule') {
+    const content = env.content.replace(HTML_TAG, '');
+    if (content.startsWith('@apply')) {
+      env.classes.push('atapply');
+    }
+  } else if (env.type === 'pseudo-class') {
+    if (!new RegExp(`^::?(${PSEUDO_CLASSES.join('|')})`).test(env.content)) {
+      env.classes = env.classes.filter((x) => x !== 'pseudo-class');
+    }
+  }
+});
+
+Prism.hooks.add('after-tokenize', ({ language, tokens }) => {
+  if (language === 'css') {
+    fixSelectorEscapeTokens(tokens);
+  }
+});
+
+export function fixSelectorEscapeTokens(tokens) {
+  for (let token of tokens) {
+    if (typeof token === 'string') continue;
+    if (token.type !== 'selector') continue;
+    for (let i = 0; i < token.content.length; i++) {
+      if (token.content[i] === '\\' && token.content[i - 1]?.type === 'class') {
+        token.content[i] = new Prism.Token('punctuation', token.content[i]);
+        token.content[i + 1].type = 'class';
+      }
+    }
+  }
+}
+
+export const createMdxJsxAttribute = (key, value) => {
+  return {
+    type: 'mdxJsxAttribute',
+    name: key,
+    value,
+  };
+};
+
+export const tomdxJsxFlowElement = (input) => {
+  const tree = fromMarkdown(input, {
+    extensions: [mdxJsx({ acorn: acorn, addResult: true })],
+    mdastExtensions: [mdxJsxFromMarkdown()],
+  });
+  return tree.children[0];
+};
+
+export const getEsmNode = (input) => {
+  const tree = fromMarkdown(input, {
+    extensions: [mdxjsEsm({ acorn, addResult: true })],
+    mdastExtensions: [mdxjsEsmFromMarkdown],
+  });
+  return tree.children[0];
+};
+
+export function addImportString(tree, jsx) {
+  tree.children.unshift(getEsmNode(jsx));
+}
+
+export function addImport(tree, mod, name) {
+  const jsx = `import { ${name} as _${name} } from '${mod}'`;
+  tree.children.unshift(getEsmNode(jsx));
+  return `_${name}`;
+}
+
+export function addDefaultImport(tree, mod, name) {
+  const jsx = `import _${name} from '${mod}'`;
+  tree.children.unshift(getEsmNode(jsx));
+  return `_${name}`;
+}
+
+export function addExport(tree, name, value) {
+  const jsx = `export const ${name} = ${JSON.stringify(value)}`;
+  tree.children.push(getEsmNode(jsx));
+}
+
+function hasLineHighlights(code) {
+  return code.split('\n').some((line) => line === '' || /^[> ] /.test(line));
+}
+
+export function highlightCode(code, prismLanguage) {
+  const isDiff = prismLanguage.startsWith('diff-');
+  const language = isDiff ? prismLanguage.substr(5) : prismLanguage;
+  const grammar = Prism.languages[language];
+  if (!grammar) {
+    console.warn(`Unrecognised language: ${prismLanguage}`);
+    return Prism.util.encode(code);
+  }
+
+  let addedLines = [];
+  let removedLines = [];
+  if (isDiff) {
+    code = code.replace(/(?:^[+\- ] |^[+-]$)/gm, (match, offset) => {
+      let line = code.substr(0, offset).split('\n').length - 1;
+      if (match.startsWith('+')) {
+        addedLines.push(line);
+      } else if (match.startsWith('-')) {
+        removedLines.push(line);
+      }
+      return '';
+    });
+  }
+
+  let highlightedLines = [];
+
+  if (hasLineHighlights(code)) {
+    let match;
+    let re = /^>/m;
+    while ((match = re.exec(code)) !== null) {
+      let line = code.substr(0, match.index).split('\n').length - 1;
+      highlightedLines.push(line);
+      code = code.substr(0, match.index) + ' ' + code.substr(match.index + 1);
+    }
+    code = redent(code);
+  }
+
+  function stringify(line, className) {
+    let empty = line.every((token) => token.empty);
+
+    if (!className && empty) {
+      return '\n';
+    }
+
+    let commonTypes = [];
+    for (let i = 0; i < line.length; i++) {
+      let token = line[i];
+      if (i === 0) {
+        commonTypes.push(...token.types);
+      } else {
+        commonTypes = commonTypes.filter((type) => token.types.includes(type));
+      }
+    }
+    if (commonTypes.length) {
+      for (let i = 0; i < line.length; i++) {
+        let token = line[i];
+        token.types = token.types.filter((type) => !commonTypes.includes(type));
+      }
+    }
+
+    let lineClassName = ['token', ...commonTypes, className].filter(Boolean).join(' ');
+
+    if (empty) {
+      return `<span class="${lineClassName}">\n</span>`;
+    }
+
+    return `<span class="${lineClassName}">${line
+      .map((token) =>
+        token.types.length
+          ? `<span class="token ${token.types.join(' ')}">${token.content}</span>`
+          : token.content
+      )
+      .join('')}\n</span>`;
+  }
+
+  if (highlightedLines.length && language !== 'demo') {
+    let lines = normalizeTokens(Prism.util.encode(Prism.tokenize(code, grammar)));
+
+    code = lines
+      .map((line, index) =>
+        stringify(
+          line,
+          `block${
+            highlightedLines.includes(index)
+              ? ' -mx-5 pr-5 border-l-4 border-primary-light bg-primary-light/[0.15]'
+              : ''
+          }`
+        )
+      )
+      .join('');
+  } else {
+    code = Prism.highlight(code, grammar, prismLanguage);
+  }
+
+  return language === 'html'
+    ? code.replace(
+        /\*\*(.*?)\*\*/g,
+        (_, text) => `<span class="code-highlight bg-code-highlight">${text}</span>`
+      )
+    : code;
+}
+
+// https://github.com/FormidableLabs/prism-react-renderer/blob/master/src/utils/normalizeTokens.js
+
+const newlineRe = /\r\n|\r|\n/;
+
+// Empty lines need to contain a single empty token, denoted with { empty: true }
+function normalizeEmptyLines(line) {
+  if (line.length === 0) {
+    line.push({
+      types: ['plain'],
+      content: '',
+      empty: true,
+    });
+  } else if (line.length === 1 && line[0].content === '') {
+    line[0].empty = true;
+  }
+}
+
+function appendTypes(types, add) {
+  const typesSize = types.length;
+  if (typesSize > 0 && types[typesSize - 1] === add) {
+    return types;
+  }
+
+  return types.concat(add);
+}
+
+// Takes an array of Prism's tokens and groups them by line, turning plain
+// strings into tokens as well. Tokens can become recursive in some cases,
+// which means that their types are concatenated. Plain-string tokens however
+// are always of type "plain".
+// This is not recursive to avoid exceeding the call-stack limit, since it's unclear
+// how nested Prism's tokens can become
+export function normalizeTokens(tokens) {
+  const typeArrStack = [[]];
+  const tokenArrStack = [tokens];
+  const tokenArrIndexStack = [0];
+  const tokenArrSizeStack = [tokens.length];
+
+  let i = 0;
+  let stackIndex = 0;
+  let currentLine = [];
+
+  const acc = [currentLine];
+
+  while (stackIndex > -1) {
+    while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {
+      let content;
+      let types = typeArrStack[stackIndex];
+
+      const tokenArr = tokenArrStack[stackIndex];
+      const token = tokenArr[i];
+
+      // Determine content and append type to types if necessary
+      if (typeof token === 'string') {
+        types = stackIndex > 0 ? types : ['plain'];
+        content = token;
+      } else {
+        types = appendTypes(types, token.type);
+        if (token.alias) {
+          types = appendTypes(types, token.alias);
+        }
+
+        content = token.content;
+      }
+
+      // If token.content is an array, increase the stack depth and repeat this while-loop
+      if (typeof content !== 'string') {
+        stackIndex++;
+        typeArrStack.push(types);
+        tokenArrStack.push(content);
+        tokenArrIndexStack.push(0);
+        tokenArrSizeStack.push(content.length);
+        continue;
+      }
+
+      // Split by newlines
+      const splitByNewlines = content.split(newlineRe);
+      const newlineCount = splitByNewlines.length;
+
+      currentLine.push({ types, content: splitByNewlines[0] });
+
+      // Create a new line for each string on a new line
+      for (let i = 1; i < newlineCount; i++) {
+        normalizeEmptyLines(currentLine);
+        acc.push((currentLine = []));
+        currentLine.push({ types, content: splitByNewlines[i] });
+      }
+    }
+
+    // Decreate the stack depth
+    stackIndex--;
+    typeArrStack.pop();
+    tokenArrStack.pop();
+    tokenArrIndexStack.pop();
+    tokenArrSizeStack.pop();
+  }
+
+  normalizeEmptyLines(currentLine);
+  return acc;
+}
+
+export function simplifyToken(token) {
+  if (typeof token === 'string') return token;
+  return [
+    token.type,
+    Array.isArray(token.content) ? token.content.map(simplifyToken) : token.content,
+  ];
+}

package/bin/mint/client/remark/withFrames.js

@@ -0,0 +1,55 @@
+import { addImport, tomdxJsxFlowElement } from './utils.js';
+
+const withFrames = () => {
+  return (tree) => {
+    let preTree = { children: [] };
+    let componentName;
+
+    tree.children = tree.children.map((node, index) => {
+      // Start of horizontal block: -- block
+      if (
+        node.type === 'paragraph' &&
+        node.children.length === 1 &&
+        node.children[0].value === '-- block'
+      ) {
+        node.type = 'jsx';
+        node.value = `<div className='grid md:grid-cols-2 md:gap-8'><div>`;
+      }
+
+      // Start a new column: -- column
+      if (
+        node.type === 'paragraph' &&
+        node.children.length === 1 &&
+        node.children[0].value === '-- column'
+      ) {
+        node.type = 'jsx';
+        node.value = `</div><div>`;
+      }
+
+      // End of horizontal block: -- /block
+      if (
+        node.type === 'paragraph' &&
+        node.children.length === 1 &&
+        node.children[0].value === '-- /block'
+      ) {
+        node.type = 'jsx';
+        node.value = `</div></div>`;
+      }
+
+      if (node.type === 'mdxJsxFlowElement' && (node.name === 'Example' || node.name === 'Frame')) {
+        if (!componentName) {
+          componentName = addImport(preTree, '@mintlify/components', 'Frame');
+        }
+        node.name = componentName;
+      }
+      if (node.type === 'jsx') {
+        node = tomdxJsxFlowElement(node.value);
+      }
+      return node;
+    });
+
+    tree.children = [...preTree.children, ...tree.children];
+  };
+};
+
+export default withFrames;

package/bin/mint/client/remark/withImportsInjected.js

@@ -0,0 +1,36 @@
+import { addImportString } from './utils.js';
+
+const imports = `
+import { Accordion, AccordionGroup } from '@/components/Accordion'
+import { Heading } from '@/components/Heading'
+import { CodeGroup, SnippetGroup } from '@/components/CodeGroup'
+import { RequestSimple } from '@/components/Request'
+import { RequestExample, ResponseExample } from '@/components/ApiExample'
+import { Param, ParamField } from '@/components/Param'
+import { Card } from '@/components/Card'
+import { ResponseField } from '@/components/ResponseField'
+import { Expandable } from '@/components/Expandable'
+import { CardGroup, Info, Warning, Note, Tip, Check } from '@mintlify/components'
+import { Tabs, Tab } from '@mintlify/components'
+import { Tooltip } from '@mintlify/components'
+import { solid, regular, light, thin, duotone, brands } from '@fortawesome/fontawesome-svg-core/import.macro'
+`;
+
+const withImportsInjected = () => {
+  return (tree) => {
+    tree.children = tree.children.filter((node) => {
+      return (
+        (node.type === 'import' && !node.value?.includes('@/components/')) || node.type !== 'import'
+      );
+    });
+
+    imports
+      .trim()
+      .split('\n')
+      .forEach((importLine) => {
+        addImportString(tree, importLine);
+      });
+  };
+};
+
+export default withImportsInjected;

package/bin/mint/client/remark/withNextLinks.js

@@ -0,0 +1,37 @@
+import { addDefaultImport, tomdxJsxFlowElement } from './utils.js';
+
+const isAbsoluteUrl = (str) => /^[a-z][a-z0-9+.-]*:/.test(str);
+
+const withNextLinks = () => {
+  return (tree) => {
+    const component = addDefaultImport(tree, 'next/link', 'Link');
+    function walk(root) {
+      if (!root.children) return;
+      let i = 0;
+      while (i < root.children.length) {
+        let node = root.children[i];
+        if (node.type === 'link' && isAbsoluteUrl(node.url)) {
+          const link = `<${component} href="${node.url}" passHref><a target="_blank">${node.children[0].value}</a></${component}>`;
+          root.children[i] = {
+            ...root.children[i],
+            ...tomdxJsxFlowElement(link),
+            type: 'mdxJsxFlowElement',
+          };
+        } else if (node.type === 'link') {
+          // Is relative url path
+          const link = `<${component} href="${node.url}" passHref><a>${node.children[0].value}</a></${component}>`;
+          root.children[i] = {
+            ...root.children[i],
+            ...tomdxJsxFlowElement(link),
+            type: 'mdxJsxFlowElement',
+          };
+        }
+        walk(root.children[i]);
+        i += 1;
+      }
+    }
+    walk(tree);
+  };
+};
+
+export default withNextLinks;

package/bin/mint/client/remark/withTableOfContents.js

@@ -0,0 +1,71 @@
+import slugify from '@sindresorhus/slugify';
+
+import { addImport, addExport, createMdxJsxAttribute } from './utils.js';
+
+const withTableOfContents = () => {
+  return (tree) => {
+    const component = addImport(tree, '@/components/Heading', 'Heading');
+    const contents = [];
+    let hasTopLayer = false;
+    for (let nodeIndex = 0; nodeIndex < tree.children.length; nodeIndex++) {
+      let node = tree.children[nodeIndex];
+
+      if (node.type === 'heading' && [1, 2, 3, 4].includes(node.depth)) {
+        let level = node.depth;
+        let title = node.children
+          .filter(
+            (node, i, a) =>
+              (node.type === 'text' &&
+                (a[i - 1]?.type !== 'mdxJsxFlowElement' ||
+                  !a[i - 1]?.value.startsWith('<small'))) ||
+              node.type === 'inlineCode'
+          )
+          .map((node) => node.value)
+          .join('');
+        let slug = slugify(title);
+
+        // if a header with the exact same title shows up - make the slug unique
+        let allOtherSlugs = contents.flatMap((entry) => [
+          entry.slug,
+          ...entry.children?.map(({ slug }) => slug),
+        ]);
+        let slugIndex = 1;
+        while (allOtherSlugs.indexOf(slug) > -1) {
+          slug = `${slugify(title)}-${slugIndex}`;
+          slugIndex++;
+        }
+
+        let mdxJsxAttributes = [
+          createMdxJsxAttribute('level', level),
+          createMdxJsxAttribute('id', slug),
+        ];
+
+        if (tree.children[nodeIndex + 1]) {
+          let { children, position, value, ...element } = tree.children[nodeIndex + 1];
+          if (typeof element?.depth !== 'undefined') {
+            mdxJsxAttributes.push(createMdxJsxAttribute('nextElementDepth', element.depth));
+          }
+        }
+
+        node.attributes = mdxJsxAttributes;
+        node.type = 'mdxJsxFlowElement';
+        node.name = component;
+        const depth = node.depth;
+        if (level <= 2) {
+          hasTopLayer = true;
+          contents.push({ title, slug, depth, children: [] });
+        } else {
+          // Account if there is no first layer
+          let arrToPushInto = contents;
+          if (hasTopLayer) {
+            arrToPushInto = contents[contents.length - 1].children;
+          }
+          arrToPushInto.push({ title, slug, depth, children: [] });
+        }
+      }
+    }
+    addExport(tree, 'tableOfContents', contents);
+  };
+};
+
+export default withTableOfContents;

package/bin/mint/client/scripts/local-to-docs.js

@@ -0,0 +1,72 @@
+import { existsSync } from 'fs';
+import { promises } from 'fs';
+import { resolve } from 'path';
+
+const { readdir, copyFile } = promises;
+
+const pathToMoveTo = process.argv[2] ?? '../docs';
+
+const getFileList = async (dirName, og = dirName) => {
+  let files = [];
+  const items = await readdir(resolve(dirName), { withFileTypes: true });
+
+  for (const item of items) {
+    if (item.isDirectory()) {
+      files = [...files, ...(await getFileList(`${dirName}/${item.name}`, og))];
+    } else {
+      files.push(`${dirName}/${item.name}`);
+    }
+  }
+
+  return files;
+};
+
+const moveConfig = async () => {
+  try {
+    const configPath = resolve('./src/mint.json');
+    if (existsSync(configPath)) {
+      console.log('⚙️ Config file detected');
+      await copyFile(configPath, resolve(`${pathToMoveTo}/mint.json`));
+      console.log('🌿 Config file moved to mint.json');
+    }
+  } catch (err) {
+    console.log(err);
+  }
+};
+
+const moveFiles = async () => {
+  moveConfig();
+  let publicFileList = await getFileList('./public');
+  let mdxFileList = await getFileList('./src/pages');
+  publicFileList = publicFileList.filter((filename) => {
+    const startsWith = filename.startsWith('./public/favicons/');
+    const endsWith = filename.endsWith('.DS_Store');
+    return !startsWith && !endsWith;
+  });
+  mdxFileList = mdxFileList.filter((filename) => {
+    const extension =
+      filename.substring(filename.lastIndexOf('.') + 1, filename.length) || filename;
+    return extension && (extension === 'mdx' || extension === 'md');
+  });
+  publicFileList.forEach(async (filename) => {
+    const path = filename.substring(8);
+    await copyFile(resolve(filename), resolve(`${pathToMoveTo}${path}`));
+  });
+  console.log(`📄  ${publicFileList.length} static files moved to ${pathToMoveTo}`);
+
+  mdxFileList.forEach(async (filename) => {
+    const path = filename.substring(11);
+    await copyFile(resolve(filename), resolve(`${pathToMoveTo}${path}`));
+  });
+  console.log(`📄  ${mdxFileList.length} pages moved to ${pathToMoveTo}`);
+};
+
+(async function () {
+  try {
+    console.log('🗂  Moving files');
+    await moveFiles();
+  } catch (error) {
+    console.log(error);
+    console.error('⚠️   Error while prebuilding documents');
+  }
+})();