docusaurus-theme-openapi-docs 0.0.0-1295 → 0.0.0-1313

package/lib/theme/utils/codeBlockUtils.js

@@ -0,0 +1,223 @@
+"use strict";
+/* ============================================================================
+ * Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+ * Portions Copyright (c) Palo Alto Networks
+ *
+ * Vendored subset of @docusaurus/theme-common/src/utils/codeBlockUtils.tsx (MIT)
+ * to remove the dependency on @docusaurus/theme-common/internal.
+ * See: https://github.com/PaloAltoNetworks/docusaurus-openapi-docs/issues/1140
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCodeBlockTitle = parseCodeBlockTitle;
+exports.containsLineNumbers = containsLineNumbers;
+exports.parseLines = parseLines;
+exports.parseLanguage = parseClassNameLanguage;
+exports.getPrismCssVariables = getPrismCssVariables;
+const parse_numeric_range_1 = __importDefault(require("parse-numeric-range"));
+const codeBlockTitleRegex = /title=(?<quote>["'])(?<title>.*?)\1/;
+const metastringLinesRangeRegex = /\{(?<range>[\d,-]+)\}/;
+const popularCommentPatterns = {
+  js: { start: "\\/\\/", end: "" },
+  jsBlock: { start: "\\/\\*", end: "\\*\\/" },
+  jsx: { start: "\\{\\s*\\/\\*", end: "\\*\\/\\s*\\}" },
+  bash: { start: "#", end: "" },
+  html: { start: "<!--", end: "-->" },
+};
+const commentPatterns = {
+  ...popularCommentPatterns,
+  lua: { start: "--", end: "" },
+  wasm: { start: "\\;\\;", end: "" },
+  tex: { start: "%", end: "" },
+  vb: { start: "['‘’]", end: "" },
+  vbnet: { start: "(?:_\\s*)?['‘’]", end: "" },
+  rem: { start: "[Rr][Ee][Mm]\\b", end: "" },
+  f90: { start: "!", end: "" },
+  ml: { start: "\\(\\*", end: "\\*\\)" },
+  cobol: { start: "\\*>", end: "" },
+};
+const popularCommentTypes = Object.keys(popularCommentPatterns);
+function getCommentPattern(languages, magicCommentDirectives) {
+  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("|");
+  return new RegExp(`^\\s*(?:${commentPattern})\\s*$`);
+}
+function getAllMagicCommentDirectiveStyles(lang, magicCommentDirectives) {
+  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":
+      return getCommentPattern(["html", "jsx", "bash"], magicCommentDirectives);
+    case "tex":
+    case "latex":
+    case "matlab":
+      return getCommentPattern(["tex"], magicCommentDirectives);
+    case "lua":
+    case "haskell":
+      return getCommentPattern(["lua"], magicCommentDirectives);
+    case "sql":
+      return getCommentPattern(["lua", "jsBlock"], magicCommentDirectives);
+    case "wasm":
+      return getCommentPattern(["wasm"], magicCommentDirectives);
+    case "vb":
+    case "vba":
+    case "visual-basic":
+      return getCommentPattern(["vb", "rem"], magicCommentDirectives);
+    case "vbnet":
+      return getCommentPattern(["vbnet", "rem"], magicCommentDirectives);
+    case "batch":
+      return getCommentPattern(["rem"], magicCommentDirectives);
+    case "basic":
+      return getCommentPattern(["rem", "f90"], magicCommentDirectives);
+    case "fsharp":
+      return getCommentPattern(["js", "ml"], magicCommentDirectives);
+    case "ocaml":
+    case "sml":
+      return getCommentPattern(["ml"], magicCommentDirectives);
+    case "fortran":
+      return getCommentPattern(["f90"], magicCommentDirectives);
+    case "cobol":
+      return getCommentPattern(["cobol"], magicCommentDirectives);
+    default:
+      return getCommentPattern(popularCommentTypes, magicCommentDirectives);
+  }
+}
+function parseCodeBlockTitle(metastring) {
+  return metastring?.match(codeBlockTitleRegex)?.groups.title ?? "";
+}
+function containsLineNumbers(metastring) {
+  return Boolean(metastring?.includes("showLineNumbers"));
+}
+function parseCodeLinesFromMetastring(code, { metastring, magicComments }) {
+  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 = (0, parse_numeric_range_1.default)(linesRange)
+      .filter((n) => n > 0)
+      .map((n) => [n - 1, [metastringRangeClassName]]);
+    return { lineClassNames: Object.fromEntries(lines), code };
+  }
+  return null;
+}
+function parseCodeLinesFromContent(code, params) {
+  const { language, magicComments } = params;
+  if (language === undefined) {
+    return { lineClassNames: {}, code };
+  }
+  const directiveRegex = getAllMagicCommentDirectiveStyles(
+    language,
+    magicComments
+  );
+  const lines = code.split(/\r?\n/);
+  const blocks = Object.fromEntries(
+    magicComments.map((d) => [d.className, { start: 0, range: "" }])
+  );
+  const lineToClassName = Object.fromEntries(
+    magicComments
+      .filter((d) => d.line)
+      .map(({ className, line }) => [line, className])
+  );
+  const blockStartToClassName = Object.fromEntries(
+    magicComments
+      .filter((d) => d.block)
+      .map(({ className, block }) => [block.start, className])
+  );
+  const blockEndToClassName = 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) {
+      lineNumber += 1;
+      continue;
+    }
+    const directive = match.slice(1).find((item) => 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);
+  }
+  const lineClassNames = {};
+  Object.entries(blocks).forEach(([className, { range }]) => {
+    (0, parse_numeric_range_1.default)(range).forEach((l) => {
+      lineClassNames[l] ??= [];
+      lineClassNames[l].push(className);
+    });
+  });
+  return { code: lines.join("\n"), lineClassNames };
+}
+function parseLines(code, params) {
+  const newCode = code.replace(/\r?\n$/, "");
+  return (
+    parseCodeLinesFromMetastring(newCode, { ...params }) ??
+    parseCodeLinesFromContent(newCode, { ...params })
+  );
+}
+function parseClassNameLanguage(className) {
+  if (!className) {
+    return undefined;
+  }
+  const languageClassName = className
+    .split(" ")
+    .find((str) => str.startsWith("language-"));
+  return languageClassName?.replace(/language-/, "");
+}
+function getPrismCssVariables(prismTheme) {
+  const mapping = {
+    color: "--prism-color",
+    backgroundColor: "--prism-background-color",
+  };
+  const properties = {};
+  Object.entries(prismTheme.plain).forEach(([key, value]) => {
+    const varName = mapping[key];
+    if (varName && typeof value === "string") {
+      properties[varName] = value;
+    }
+  });
+  return properties;
+}

package/lib/theme/utils/reactUtils.d.ts

@@ -0,0 +1 @@
+export declare function useShallowMemoObject<O extends object>(obj: O): O;

package/lib/theme/utils/reactUtils.js

@@ -0,0 +1,23 @@
+"use strict";
+/* ============================================================================
+ * Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+ * Portions Copyright (c) Palo Alto Networks
+ *
+ * Vendored from @docusaurus/theme-common/src/utils/reactUtils.tsx (MIT).
+ * Only useShallowMemoObject is kept here — it is not re-exported by
+ * @docusaurus/theme-common (public or /internal). useEvent and
+ * ReactContextError are public APIs imported directly from the package.
+ * See: https://github.com/PaloAltoNetworks/docusaurus-openapi-docs/issues/1140
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useShallowMemoObject = useShallowMemoObject;
+const react_1 = require("react");
+function useShallowMemoObject(obj) {
+  const deps = Object.entries(obj);
+  deps.sort((a, b) => a[0].localeCompare(b[0]));
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return (0, react_1.useMemo)(() => obj, deps.flat());
+}

package/lib/theme/utils/scrollUtils.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+export declare function ScrollControllerProvider({ children, }: {
+    children: ReactNode;
+}): ReactNode;
+export declare function useScrollPositionBlocker(): {
+    blockElementScrollPositionUntilNextRender: (el: HTMLElement) => void;
+};

package/lib/theme/utils/scrollUtils.js

@@ -0,0 +1,175 @@
+"use strict";
+/* ============================================================================
+ * Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+ * Portions Copyright (c) Palo Alto Networks
+ *
+ * Vendored subset of @docusaurus/theme-common/src/utils/scrollUtils.tsx (MIT)
+ * to remove the dependency on @docusaurus/theme-common/internal. Only the
+ * ScrollControllerProvider + useScrollPositionBlocker surface is kept, since
+ * that's all our tab renderers need. The ScrollControllerProvider must be
+ * mounted in the React tree above any consumer of useScrollPositionBlocker
+ * (see ApiItem/index.tsx).
+ * See: https://github.com/PaloAltoNetworks/docusaurus-openapi-docs/issues/1140
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o["default"] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o)
+            if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+          if (k[i] !== "default") __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrollControllerProvider = ScrollControllerProvider;
+exports.useScrollPositionBlocker = useScrollPositionBlocker;
+const react_1 = __importStar(require("react"));
+const useIsomorphicLayoutEffect_1 = __importDefault(
+  require("@docusaurus/useIsomorphicLayoutEffect")
+);
+const theme_common_1 = require("@docusaurus/theme-common");
+function useScrollControllerContextValue() {
+  const scrollEventsEnabledRef = (0, react_1.useRef)(true);
+  return (0, react_1.useMemo)(
+    () => ({
+      scrollEventsEnabledRef,
+      enableScrollEvents: () => {
+        scrollEventsEnabledRef.current = true;
+      },
+      disableScrollEvents: () => {
+        scrollEventsEnabledRef.current = false;
+      },
+    }),
+    []
+  );
+}
+const ScrollMonitorContext = react_1.default.createContext(undefined);
+function ScrollControllerProvider({ children }) {
+  const value = useScrollControllerContextValue();
+  return react_1.default.createElement(
+    ScrollMonitorContext.Provider,
+    { value: value },
+    children
+  );
+}
+function useScrollController() {
+  const context = (0, react_1.useContext)(ScrollMonitorContext);
+  if (context == null) {
+    throw new theme_common_1.ReactContextError("ScrollControllerProvider");
+  }
+  return context;
+}
+function useScrollPositionSaver() {
+  const lastElementRef = (0, react_1.useRef)({
+    elem: null,
+    top: 0,
+  });
+  const save = (0, react_1.useCallback)((elem) => {
+    lastElementRef.current = {
+      elem,
+      top: elem.getBoundingClientRect().top,
+    };
+  }, []);
+  const restore = (0, react_1.useCallback)(() => {
+    const {
+      current: { elem, top },
+    } = lastElementRef;
+    if (!elem) {
+      return { restored: false };
+    }
+    const newTop = elem.getBoundingClientRect().top;
+    const heightDiff = newTop - top;
+    if (heightDiff) {
+      window.scrollBy({ left: 0, top: heightDiff });
+    }
+    lastElementRef.current = { elem: null, top: 0 };
+    return { restored: heightDiff !== 0 };
+  }, []);
+  return (0, react_1.useMemo)(() => ({ save, restore }), [restore, save]);
+}
+function useScrollPositionBlocker() {
+  const scrollController = useScrollController();
+  const scrollPositionSaver = useScrollPositionSaver();
+  const nextLayoutEffectCallbackRef = (0, react_1.useRef)(undefined);
+  const blockElementScrollPositionUntilNextRender = (0, react_1.useCallback)(
+    (el) => {
+      scrollPositionSaver.save(el);
+      scrollController.disableScrollEvents();
+      nextLayoutEffectCallbackRef.current = () => {
+        const { restored } = scrollPositionSaver.restore();
+        nextLayoutEffectCallbackRef.current = undefined;
+        if (restored) {
+          const handleScrollRestoreEvent = () => {
+            scrollController.enableScrollEvents();
+            window.removeEventListener("scroll", handleScrollRestoreEvent);
+          };
+          window.addEventListener("scroll", handleScrollRestoreEvent);
+        } else {
+          scrollController.enableScrollEvents();
+        }
+      };
+    },
+    [scrollController, scrollPositionSaver]
+  );
+  (0, useIsomorphicLayoutEffect_1.default)(() => {
+    queueMicrotask(() => nextLayoutEffectCallbackRef.current?.());
+  });
+  return {
+    blockElementScrollPositionUntilNextRender,
+  };
+}

package/lib/theme/utils/tabsUtils.d.ts

@@ -0,0 +1,47 @@
+import { type ReactNode } from "react";
+export interface TabValue {
+    readonly value: string;
+    readonly label?: string;
+    readonly attributes?: {
+        [key: string]: unknown;
+    };
+    readonly default?: boolean;
+}
+export interface TabsProps {
+    readonly lazy?: boolean;
+    readonly block?: boolean;
+    readonly children: ReactNode;
+    readonly defaultValue?: string | null;
+    readonly values?: readonly TabValue[];
+    readonly groupId?: string;
+    readonly className?: string;
+    readonly queryString?: string | boolean;
+}
+export interface TabProps extends TabsProps {
+    length?: number;
+}
+export interface TabItemProps {
+    readonly children: ReactNode;
+    readonly value: string;
+    readonly default?: boolean;
+    readonly label?: string;
+    readonly className?: string;
+    readonly attributes?: {
+        [key: string]: unknown;
+    };
+}
+export declare function sanitizeTabsChildren(children: ReactNode): ReactNode;
+type TabsContextValue = {
+    selectedValue: string;
+    selectValue: (value: string) => void;
+    tabValues: readonly TabValue[];
+    lazy: boolean;
+    block: boolean;
+};
+export declare function useTabsContextValue(props: TabsProps): TabsContextValue;
+export declare function useTabs(): TabsContextValue;
+export declare function TabsProvider(props: {
+    children: ReactNode;
+    value: TabsContextValue;
+}): ReactNode;
+export {};