@docusaurus/theme-common 2.0.0-beta.ff31de0ff → 2.0.1

package/src/internal.ts

@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// This re-export permits to handle some level of retro-compatibility. Users
+// might swizzle unsafe components and expose these internal imports. When we
+// move an API from internal to public, former internal imports should keep
+// working, so that the change doesn't become breaking.
+//
+// Important: this line is removed from build output with the
+// "removeThemeInternalReexport" script for CI checks. This ensures that none of
+// our internal code relies on this re-export and that we don't forget to
+// migrate theme internal imports to public imports.
+//
+// eslint-disable-next-line no-restricted-syntax
+export * from './index';
+
+export {
+  DocSidebarItemsExpandedStateProvider,
+  useDocSidebarItemsExpandedState,
+} from './contexts/docSidebarItemsExpandedState';
+export {DocsVersionProvider, useDocsVersion} from './contexts/docsVersion';
+export {DocsSidebarProvider, useDocsSidebar} from './contexts/docsSidebar';
+
+export {DocProvider, useDoc, type DocContextValue} from './contexts/doc';
+export {
+  BlogPostProvider,
+  useBlogPost,
+  type BlogPostContextValue,
+} from './contexts/blogPost';
+
+export {
+  useDocsPreferredVersionByPluginId,
+  DocsPreferredVersionContextProvider,
+} from './contexts/docsPreferredVersion';
+
+export {
+  AnnouncementBarProvider,
+  useAnnouncementBar,
+} from './contexts/announcementBar';
+
+export {
+  useTabGroupChoice,
+  TabGroupChoiceProvider,
+} from './contexts/tabGroupChoice';
+
+export {useNavbarMobileSidebar} from './contexts/navbarMobileSidebar';
+export {useNavbarSecondaryMenu} from './contexts/navbarSecondaryMenu/display';
+
+export {ColorModeProvider} from './contexts/colorMode';
+
+export {useAlternatePageUtils} from './utils/useAlternatePageUtils';
+
+export {
+  parseCodeBlockTitle,
+  parseLanguage,
+  parseLines,
+  containsLineNumbers,
+} from './utils/codeBlockUtils';
+
+export {docVersionSearchTag, DEFAULT_SEARCH_TAG} from './utils/searchUtils';
+
+export {
+  isDocsPluginEnabled,
+  useDocById,
+  findSidebarCategory,
+  findFirstCategoryLink,
+  isActiveSidebarItem,
+  useSidebarBreadcrumbs,
+  useDocsVersionCandidates,
+  useLayoutDoc,
+  useLayoutDocsSidebar,
+  useDocRouteMetadata,
+} from './utils/docsUtils';
+
+export {useTitleFormatter} from './utils/generalUtils';
+
+export {useLocationChange} from './utils/useLocationChange';
+
+export {useLocalPathname} from './utils/useLocalPathname';
+
+export {useHistoryPopHandler} from './utils/historyUtils';
+
+export {
+  useFilteredAndTreeifiedTOC,
+  useTreeifiedTOC,
+  type TOCTreeNode,
+} from './utils/tocUtils';
+
+export {
+  ScrollControllerProvider,
+  useScrollController,
+  useScrollPosition,
+  useScrollPositionBlocker,
+  useSmoothScrollTo,
+} from './utils/scrollUtils';
+
+export {useHomePageRoute, isSamePath} from './utils/routesUtils';
+
+export {PluginHtmlClassNameProvider} from './utils/metadataUtils';
+
+export {splitNavbarItems, NavbarProvider} from './utils/navbarUtils';
+
+export {
+  useTOCHighlight,
+  type TOCHighlightConfig,
+} from './hooks/useTOCHighlight';
+
+export {useHideableNavbar} from './hooks/useHideableNavbar';
+export {
+  useKeyboardNavigation,
+  keyboardFocusedClassName,
+} from './hooks/useKeyboardNavigation';
+export {useLockBodyScroll} from './hooks/useLockBodyScroll';
+export {useSearchPage} from './hooks/useSearchPage';
+export {useCodeWordWrap} from './hooks/useCodeWordWrap';
+export {useSkipToContent} from './hooks/useSkipToContent';
+export {getPrismCssVariables} from './utils/codeBlockUtils';
+export {useBackToTopButton} from './hooks/useBackToTopButton';

package/src/types.d.ts

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-/* eslint-disable import/no-duplicates */
-/* eslint-disable spaced-comment */
 /// <reference types="@docusaurus/module-type-aliases" />
 /// <reference types="@docusaurus/plugin-content-blog" />
 /// <reference types="@docusaurus/plugin-content-docs" />

package/src/utils/ThemeClassNames.ts

@@ -5,20 +5,69 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-// These class names are used to style page layouts in Docusaurus
+// Please do not modify the classnames! This is a breaking change, and annoying
+// for users!
+
+/**
+ * These class names are used to style page layouts in Docusaurus, meant to be
+ * targeted by user-provided custom CSS selectors.
+ */
 export const ThemeClassNames = {
   page: {
     blogListPage: 'blog-list-page',
     blogPostPage: 'blog-post-page',
     blogTagsListPage: 'blog-tags-list-page',
-    blogTagsPostPage: 'blog-tags-post-page',
-    docPage: 'doc-page',
+    blogTagPostListPage: 'blog-tags-post-list-page',
+
+    docsDocPage: 'docs-doc-page',
+    docsTagsListPage: 'docs-tags-list-page',
+    docsTagDocListPage: 'docs-tags-doc-list-page',
+
     mdxPage: 'mdx-page',
   },
   wrapper: {
     main: 'main-wrapper',
     blogPages: 'blog-wrapper',
-    docPages: 'docs-wrapper',
+    docsPages: 'docs-wrapper',
     mdxPages: 'mdx-wrapper',
   },
-};
+  common: {
+    editThisPage: 'theme-edit-this-page',
+    lastUpdated: 'theme-last-updated',
+    backToTopButton: 'theme-back-to-top-button',
+    codeBlock: 'theme-code-block',
+    admonition: 'theme-admonition',
+    admonitionType: (type: 'note' | 'tip' | 'danger' | 'info' | 'caution') =>
+      `theme-admonition-${type}`,
+  },
+  layout: {
+    // TODO add other stable classNames here
+  },
+
+  /**
+   * Follows the naming convention "theme-{blog,doc,version,page}?-<suffix>"
+   */
+  docs: {
+    docVersionBanner: 'theme-doc-version-banner',
+    docVersionBadge: 'theme-doc-version-badge',
+    docBreadcrumbs: 'theme-doc-breadcrumbs',
+    docMarkdown: 'theme-doc-markdown',
+    docTocMobile: 'theme-doc-toc-mobile',
+    docTocDesktop: 'theme-doc-toc-desktop',
+    docFooter: 'theme-doc-footer',
+    docFooterTagsRow: 'theme-doc-footer-tags-row',
+    docFooterEditMetaRow: 'theme-doc-footer-edit-meta-row',
+    docSidebarContainer: 'theme-doc-sidebar-container',
+    docSidebarMenu: 'theme-doc-sidebar-menu',
+    docSidebarItemCategory: 'theme-doc-sidebar-item-category',
+    docSidebarItemLink: 'theme-doc-sidebar-item-link',
+    docSidebarItemCategoryLevel: (level: number) =>
+      `theme-doc-sidebar-item-category-level-${level}` as const,
+    docSidebarItemLinkLevel: (level: number) =>
+      `theme-doc-sidebar-item-link-level-${level}` as const,
+    // TODO add other stable classNames here
+  },
+  blog: {
+    // TODO add other stable classNames here
+  },
+} as const;

package/src/utils/codeBlockUtils.ts

@@ -5,8 +5,247 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-const codeBlockTitleRegex = /title=(["'])(.*?)\1/;
+import type {CSSProperties} from 'react';
+import rangeParser from 'parse-numeric-range';
+import type {PrismTheme} from 'prism-react-renderer';
+
+const codeBlockTitleRegex = /title=(?<quote>["'])(?<title>.*?)\1/;
+const metastringLinesRangeRegex = /\{(?<range>[\d,-]+)\}/;
+
+// Supported types of highlight comments
+const commentPatterns = {
+  js: {start: '\\/\\/', end: ''},
+  jsBlock: {start: '\\/\\*', end: '\\*\\/'},
+  jsx: {start: '\\{\\s*\\/\\*', end: '\\*\\/\\s*\\}'},
+  bash: {start: '#', end: ''},
+  html: {start: '<!--', end: '-->'},
+};
+
+type CommentType = keyof typeof commentPatterns;
+
+export type MagicCommentConfig = {
+  className: string;
+  line?: string;
+  block?: {start: string; end: string};
+};
+
+function getCommentPattern(
+  languages: CommentType[],
+  magicCommentDirectives: MagicCommentConfig[],
+) {
+  // To be more reliable, the opening and closing comment must match
+  const commentPattern = languages
+    .map((lang) => {
+      const {start, end} = commentPatterns[lang];
+      return `(?:${start}\\s*(${magicCommentDirectives
+        .flatMap((d) => [d.line, d.block?.start, d.block?.end].filter(Boolean))
+        .join('|')})\\s*${end})`;
+    })
+    .join('|');
+  // White space is allowed, but otherwise it should be on it's own line
+  return new RegExp(`^\\s*(?:${commentPattern})\\s*$`);
+}
+
+/**
+ * Select comment styles based on language
+ */
+function getAllMagicCommentDirectiveStyles(
+  lang: string,
+  magicCommentDirectives: MagicCommentConfig[],
+) {
+  switch (lang) {
+    case 'js':
+    case 'javascript':
+    case 'ts':
+    case 'typescript':
+      return getCommentPattern(['js', 'jsBlock'], magicCommentDirectives);
+
+    case 'jsx':
+    case 'tsx':
+      return getCommentPattern(
+        ['js', 'jsBlock', 'jsx'],
+        magicCommentDirectives,
+      );
+
+    case 'html':
+      return getCommentPattern(
+        ['js', 'jsBlock', 'html'],
+        magicCommentDirectives,
+      );
+
+    case 'python':
+    case 'py':
+    case 'bash':
+      return getCommentPattern(['bash'], magicCommentDirectives);
+
+    case 'markdown':
+    case 'md':
+      // Text uses HTML, front matter uses bash
+      return getCommentPattern(['html', 'jsx', 'bash'], magicCommentDirectives);
+
+    default:
+      // All comment types
+      return getCommentPattern(
+        Object.keys(commentPatterns) as CommentType[],
+        magicCommentDirectives,
+      );
+  }
+}
 
 export function parseCodeBlockTitle(metastring?: string): string {
-  return metastring?.match(codeBlockTitleRegex)?.[2] ?? '';
+  return metastring?.match(codeBlockTitleRegex)?.groups!.title ?? '';
+}
+
+export function containsLineNumbers(metastring?: string): boolean {
+  return Boolean(metastring?.includes('showLineNumbers'));
+}
+
+/**
+ * Gets the language name from the class name (set by MDX).
+ * e.g. `"language-javascript"` => `"javascript"`.
+ * Returns undefined if there is no language class name.
+ */
+export function parseLanguage(className: string): string | undefined {
+  const languageClassName = className
+    .split(' ')
+    .find((str) => str.startsWith('language-'));
+  return languageClassName?.replace(/language-/, '');
+}
+
+/**
+ * Parses the code content, strips away any magic comments, and returns the
+ * clean content and the highlighted lines marked by the comments or metastring.
+ *
+ * If the metastring contains a range, the `content` will be returned as-is
+ * without any parsing. The returned `lineClassNames` will be a map from that
+ * number range to the first magic comment config entry (which _should_ be for
+ * line highlight directives.)
+ *
+ * @param content The raw code with magic comments. Trailing newline will be
+ * trimmed upfront.
+ * @param options Options for parsing behavior.
+ */
+export function parseLines(
+  content: string,
+  options: {
+    /**
+     * The full metastring, as received from MDX. Line ranges declared here
+     * start at 1.
+     */
+    metastring: string | undefined;
+    /**
+     * Language of the code block, used to determine which kinds of magic
+     * comment styles to enable.
+     */
+    language: string | undefined;
+    /**
+     * Magic comment types that we should try to parse. Each entry would
+     * correspond to one class name to apply to each line.
+     */
+    magicComments: MagicCommentConfig[];
+  },
+): {
+  /**
+   * The highlighted lines, 0-indexed. e.g. `{ 0: ["highlight", "sample"] }`
+   * means the 1st line should have `highlight` and `sample` as class names.
+   */
+  lineClassNames: {[lineIndex: number]: string[]};
+  /**
+   * If there's number range declared in the metastring, the code block is
+   * returned as-is (no parsing); otherwise, this is the clean code with all
+   * magic comments stripped away.
+   */
+  code: string;
+} {
+  let code = content.replace(/\n$/, '');
+  const {language, magicComments, metastring} = options;
+  // Highlighted lines specified in props: don't parse the content
+  if (metastring && metastringLinesRangeRegex.test(metastring)) {
+    const linesRange = metastring.match(metastringLinesRangeRegex)!.groups!
+      .range!;
+    if (magicComments.length === 0) {
+      throw new Error(
+        `A highlight range has been given in code block's metastring (\`\`\` ${metastring}), but no magic comment config is available. Docusaurus applies the first magic comment entry's className for metastring ranges.`,
+      );
+    }
+    const metastringRangeClassName = magicComments[0]!.className;
+    const lines = rangeParser(linesRange)
+      .filter((n) => n > 0)
+      .map((n) => [n - 1, [metastringRangeClassName]] as [number, string[]]);
+    return {lineClassNames: Object.fromEntries(lines), code};
+  }
+  if (language === undefined) {
+    return {lineClassNames: {}, code};
+  }
+  const directiveRegex = getAllMagicCommentDirectiveStyles(
+    language,
+    magicComments,
+  );
+  // Go through line by line
+  const lines = code.split('\n');
+  const blocks = Object.fromEntries(
+    magicComments.map((d) => [d.className, {start: 0, range: ''}]),
+  );
+  const lineToClassName: {[comment: string]: string} = Object.fromEntries(
+    magicComments
+      .filter((d) => d.line)
+      .map(({className, line}) => [line!, className] as [string, string]),
+  );
+  const blockStartToClassName: {[comment: string]: string} = Object.fromEntries(
+    magicComments
+      .filter((d) => d.block)
+      .map(({className, block}) => [block!.start, className]),
+  );
+  const blockEndToClassName: {[comment: string]: string} = Object.fromEntries(
+    magicComments
+      .filter((d) => d.block)
+      .map(({className, block}) => [block!.end, className]),
+  );
+  for (let lineNumber = 0; lineNumber < lines.length; ) {
+    const line = lines[lineNumber]!;
+    const match = line.match(directiveRegex);
+    if (!match) {
+      // Lines without directives are unchanged
+      lineNumber += 1;
+      continue;
+    }
+    const directive = match
+      .slice(1)
+      .find((item: string | undefined) => item !== undefined)!;
+    if (lineToClassName[directive]) {
+      blocks[lineToClassName[directive]!]!.range += `${lineNumber},`;
+    } else if (blockStartToClassName[directive]) {
+      blocks[blockStartToClassName[directive]!]!.start = lineNumber;
+    } else if (blockEndToClassName[directive]) {
+      blocks[blockEndToClassName[directive]!]!.range += `${
+        blocks[blockEndToClassName[directive]!]!.start
+      }-${lineNumber - 1},`;
+    }
+    lines.splice(lineNumber, 1);
+  }
+  code = lines.join('\n');
+  const lineClassNames: {[lineIndex: number]: string[]} = {};
+  Object.entries(blocks).forEach(([className, {range}]) => {
+    rangeParser(range).forEach((l) => {
+      lineClassNames[l] ??= [];
+      lineClassNames[l]!.push(className);
+    });
+  });
+  return {lineClassNames, code};
+}
+
+export function getPrismCssVariables(prismTheme: PrismTheme): CSSProperties {
+  const mapping: {[name: keyof PrismTheme['plain']]: string} = {
+    color: '--prism-color',
+    backgroundColor: '--prism-background-color',
+  };
+
+  const properties: {[key: string]: string} = {};
+  Object.entries(prismTheme.plain).forEach(([key, value]) => {
+    const varName = mapping[key];
+    if (varName && typeof value === 'string') {
+      properties[varName] = value;
+    }
+  });
+  return properties;
 }