docusaurus-theme-openapi-docs 0.0.0-1000

package/lib/theme/SchemaItem/_SchemaItem.scss

@@ -0,0 +1,89 @@
+.openapi-schema__container {
+  &:hover {
+    .openapi-schema__property {
+      color: var(--ifm-color-primary);
+    }
+  }
+}
+
+.openapi-schema__list-item {
+  list-style: none;
+  position: relative;
+  margin: 0 !important;
+  padding: 5px 0 5px 1rem;
+  border-left: thin solid var(--openapi-tree-line-color) !important;
+
+  // Horizontal line styling for schema properties
+  &::before {
+    position: absolute;
+    top: 10px;
+    left: 0;
+    width: 0.7rem;
+    /* width of horizontal line */
+    height: 0.5rem;
+    /* vertical position of line */
+    vertical-align: top;
+    border-bottom: thin solid var(--openapi-tree-line-color);
+    content: "";
+    display: inline-block;
+  }
+}
+
+.openapi-schema__name {
+  opacity: 0.6;
+  padding-left: 0.3rem;
+}
+
+.openapi-schema__required {
+  display: inline-flex;
+  align-items: center;
+  font-size: 10.5px;
+  font-weight: bold;
+  text-transform: uppercase;
+  color: var(--openapi-required);
+  margin-left: 1%;
+  background-color: transparent;
+}
+
+.openapi-schema__deprecated {
+  display: flex;
+  align-items: center;
+  font-size: 10.5px;
+  font-weight: bold;
+  text-transform: uppercase;
+  color: var(--openapi-deprecated);
+  margin-left: 1%;
+  background-color: transparent;
+}
+
+.openapi-schema__nullable {
+  display: flex;
+  align-items: center;
+  font-size: 10.5px;
+  font-weight: bold;
+  text-transform: uppercase;
+  color: var(--openapi-nullable);
+  margin-left: 1%;
+  background-color: transparent;
+}
+
+.openapi-schema__strikethrough {
+  text-decoration: line-through;
+}
+
+.openapi-schema__property {
+  margin-top: 1.25px;
+  font-family: var(--ifm-font-family-monospace);
+  transition: 300ms;
+}
+
+.openapi-schema__divider {
+  flex-grow: 1;
+  border-bottom: thin solid var(--ifm-toc-border-color);
+  margin: 10px;
+}
+
+.openapi-schema__container {
+  display: flex;
+  align-items: center;
+}

package/lib/theme/SchemaItem/index.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from "react";
+export interface Props {
+    children?: ReactNode;
+    collapsible?: boolean;
+    name?: string;
+    qualifierMessage?: string | undefined;
+    required?: boolean;
+    schemaName?: string;
+    schema?: any;
+    discriminator?: boolean;
+}
+export default function SchemaItem(props: Props): React.JSX.Element;

package/lib/theme/SchemaItem/index.js

@@ -0,0 +1,213 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * 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.default = SchemaItem;
+const react_1 = __importDefault(require("react"));
+const Markdown_1 = __importDefault(require("@theme/Markdown"));
+const clsx_1 = __importDefault(require("clsx"));
+const utils_1 = require("../../markdown/utils");
+const transformEnumDescriptions = (enumDescriptions) => {
+  if (enumDescriptions) {
+    return Object.entries(enumDescriptions);
+  }
+  return [];
+};
+const getEnumDescriptionMarkdown = (enumDescriptions) => {
+  if (enumDescriptions?.length) {
+    return `| Enum Value | Description |
+| ---- | ----- |
+${enumDescriptions
+  .map((desc) => {
+    return `| ${desc[0]} | ${desc[1]} | `.replaceAll("\n", "<br/>");
+  })
+  .join("\n")}
+    `;
+  }
+  return "";
+};
+function SchemaItem(props) {
+  const {
+    children: collapsibleSchemaContent,
+    collapsible,
+    name,
+    qualifierMessage,
+    required,
+    schemaName,
+    schema,
+  } = props;
+  let deprecated;
+  let schemaDescription;
+  let defaultValue;
+  let example;
+  let nullable;
+  let enumDescriptions = [];
+  if (schema) {
+    deprecated = schema.deprecated;
+    schemaDescription = schema.description;
+    enumDescriptions = transformEnumDescriptions(schema["x-enumDescriptions"]);
+    defaultValue = schema.default;
+    example = schema.example;
+    nullable =
+      schema.nullable ||
+      (Array.isArray(schema.type) && schema.type.includes("null")); // support JSON Schema nullable
+  }
+  const renderRequired = (0, utils_1.guard)(
+    Array.isArray(required) ? required.includes(name) : required,
+    () =>
+      react_1.default.createElement(
+        "span",
+        { className: "openapi-schema__required" },
+        "required"
+      )
+  );
+  const renderDeprecated = (0, utils_1.guard)(deprecated, () =>
+    react_1.default.createElement(
+      "span",
+      { className: "openapi-schema__deprecated" },
+      "deprecated"
+    )
+  );
+  const renderNullable = (0, utils_1.guard)(nullable, () =>
+    react_1.default.createElement(
+      "span",
+      { className: "openapi-schema__nullable" },
+      "nullable"
+    )
+  );
+  const renderEnumDescriptions = (0, utils_1.guard)(
+    getEnumDescriptionMarkdown(enumDescriptions),
+    (value) => {
+      return react_1.default.createElement(
+        "div",
+        { style: { marginTop: ".5rem" } },
+        react_1.default.createElement(Markdown_1.default, null, value)
+      );
+    }
+  );
+  const renderSchemaDescription = (0, utils_1.guard)(
+    schemaDescription,
+    (description) =>
+      react_1.default.createElement(
+        react_1.default.Fragment,
+        null,
+        react_1.default.createElement(Markdown_1.default, null, description)
+      )
+  );
+  const renderQualifierMessage = (0, utils_1.guard)(
+    qualifierMessage,
+    (message) =>
+      react_1.default.createElement(
+        react_1.default.Fragment,
+        null,
+        react_1.default.createElement(Markdown_1.default, null, message)
+      )
+  );
+  function renderDefaultValue() {
+    if (defaultValue !== undefined) {
+      if (typeof defaultValue === "string") {
+        return react_1.default.createElement(
+          "div",
+          null,
+          react_1.default.createElement("strong", null, "Default value: "),
+          react_1.default.createElement(
+            "span",
+            null,
+            react_1.default.createElement("code", null, defaultValue)
+          )
+        );
+      }
+      return react_1.default.createElement(
+        "div",
+        null,
+        react_1.default.createElement("strong", null, "Default value: "),
+        react_1.default.createElement(
+          "span",
+          null,
+          react_1.default.createElement(
+            "code",
+            null,
+            JSON.stringify(defaultValue)
+          )
+        )
+      );
+    }
+    return undefined;
+  }
+  function renderExample() {
+    if (example !== undefined) {
+      if (typeof example === "string") {
+        return react_1.default.createElement(
+          "div",
+          null,
+          react_1.default.createElement("strong", null, "Example: "),
+          react_1.default.createElement(
+            "span",
+            null,
+            react_1.default.createElement("code", null, example)
+          )
+        );
+      }
+      return react_1.default.createElement(
+        "div",
+        null,
+        react_1.default.createElement("strong", null, "Example: "),
+        react_1.default.createElement(
+          "span",
+          null,
+          react_1.default.createElement("code", null, JSON.stringify(example))
+        )
+      );
+    }
+    return undefined;
+  }
+  const schemaContent = react_1.default.createElement(
+    "div",
+    null,
+    react_1.default.createElement(
+      "span",
+      { className: "openapi-schema__container" },
+      react_1.default.createElement(
+        "strong",
+        {
+          className: (0, clsx_1.default)("openapi-schema__property", {
+            "openapi-schema__strikethrough": deprecated,
+          }),
+        },
+        name
+      ),
+      react_1.default.createElement(
+        "span",
+        { className: "openapi-schema__name" },
+        Array.isArray(schemaName) ? schemaName.join(" | ") : schemaName
+      ),
+      (nullable || required || deprecated) &&
+        react_1.default.createElement("span", {
+          className: "openapi-schema__divider",
+        }),
+      renderNullable,
+      renderRequired,
+      renderDeprecated
+    ),
+    renderSchemaDescription,
+    renderEnumDescriptions,
+    renderQualifierMessage,
+    renderDefaultValue(),
+    renderExample(),
+    collapsibleSchemaContent ?? collapsibleSchemaContent
+  );
+  return react_1.default.createElement(
+    "div",
+    { className: "openapi-schema__list-item" },
+    collapsible ? collapsibleSchemaContent : schemaContent
+  );
+}

package/lib/theme/SchemaTabs/_SchemaTabs.scss

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+
+.openapi-tabs__schema-item {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.35rem 0.7rem;
+  border: 1px solid transparent;
+  margin-top: 0 !important;
+  margin-right: 0.5rem;
+  font-weight: var(--ifm-font-weight-bold);
+  font-family: var(--ifm-font-family-monospace);
+  font-size: 10px;
+  white-space: nowrap;
+  transition: 300ms;
+
+  &:hover {
+    background-color: transparent;
+    border: 1px solid var(--ifm-toc-border-color);
+  }
+
+  &.active {
+    border: 1px solid var(--ifm-color-primary);
+    color: var(--ifm-color-primary);
+  }
+
+  &:last-child {
+    margin-right: 0 !important;
+  }
+}
+
+.openapi-tabs__schema-list-container {
+  overflow-y: hidden;
+  overflow-x: scroll;
+  scroll-behavior: smooth;
+  scrollbar-width: none;
+
+  &::-webkit-scrollbar {
+    display: none;
+  }
+
+  &.active {
+    background-color: var(--ifm-color-emphasis-100);
+  }
+}
+
+.openapi-tabs__schema-label {
+  white-space: nowrap;
+}
+
+.openapi-tabs__schema-tabs-container {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  overflow: hidden;
+}

package/lib/theme/SchemaTabs/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { TabProps } from "@docusaurus/theme-common/internal";
+export default function SchemaTabs(props: TabProps): React.JSX.Element;

package/lib/theme/SchemaTabs/index.js

@@ -0,0 +1,255 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * 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.default = SchemaTabs;
+const react_1 = __importStar(require("react"));
+const internal_1 = require("@docusaurus/theme-common/internal");
+const useIsBrowser_1 = __importDefault(require("@docusaurus/useIsBrowser"));
+const clsx_1 = __importDefault(require("clsx"));
+const flatten_1 = __importDefault(require("lodash/flatten"));
+function TabList({ className, block, selectedValue, selectValue, tabValues }) {
+  const tabRefs = [];
+  const { blockElementScrollPositionUntilNextRender } = (0,
+  internal_1.useScrollPositionBlocker)();
+  const handleTabChange = (event) => {
+    const newTab = event.currentTarget;
+    const newTabIndex = tabRefs.indexOf(newTab);
+    const newTabValue = tabValues[newTabIndex].value;
+    if (newTabValue !== selectedValue) {
+      blockElementScrollPositionUntilNextRender(newTab);
+      selectValue(newTabValue);
+    }
+  };
+  const handleKeydown = (event) => {
+    let focusElement = null;
+    switch (event.key) {
+      case "Enter": {
+        handleTabChange(event);
+        break;
+      }
+      case "ArrowRight": {
+        const nextTab = tabRefs.indexOf(event.currentTarget) + 1;
+        focusElement = tabRefs[nextTab] ?? tabRefs[0];
+        break;
+      }
+      case "ArrowLeft": {
+        const prevTab = tabRefs.indexOf(event.currentTarget) - 1;
+        focusElement = tabRefs[prevTab] ?? tabRefs[tabRefs.length - 1];
+        break;
+      }
+      default:
+        break;
+    }
+    focusElement?.focus();
+  };
+  const tabItemListContainerRef = (0, react_1.useRef)(null);
+  const [showTabArrows, setShowTabArrows] = (0, react_1.useState)(false);
+  (0, react_1.useEffect)(() => {
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (let entry of entries) {
+        requestAnimationFrame(() => {
+          if (entry.target.clientWidth < entry.target.scrollWidth) {
+            setShowTabArrows(true);
+          } else {
+            setShowTabArrows(false);
+          }
+        });
+      }
+    });
+    resizeObserver.observe(tabItemListContainerRef.current);
+    return () => {
+      resizeObserver.disconnect();
+    };
+  }, []);
+  const handleRightClick = (e) => {
+    e.preventDefault();
+    if (tabItemListContainerRef.current) {
+      tabItemListContainerRef.current.scrollLeft += 90;
+    }
+  };
+  const handleLeftClick = (e) => {
+    e.preventDefault();
+    if (tabItemListContainerRef.current) {
+      tabItemListContainerRef.current.scrollLeft -= 90;
+    }
+  };
+  return react_1.default.createElement(
+    "div",
+    { className: "openapi-tabs__schema-tabs-container" },
+    showTabArrows &&
+      react_1.default.createElement("button", {
+        className: "openapi-tabs__arrow left",
+        onClick: handleLeftClick,
+      }),
+    react_1.default.createElement(
+      "ul",
+      {
+        ref: tabItemListContainerRef,
+        role: "tablist",
+        "aria-orientation": "horizontal",
+        className: (0, clsx_1.default)(
+          "openapi-tabs__schema-list-container",
+          "tabs",
+          {
+            "tabs--block": block,
+          },
+          className
+        ),
+      },
+      tabValues.map(({ value, label, attributes }) =>
+        react_1.default.createElement(
+          "li",
+          {
+            // TODO extract TabListItem
+            role: "tab",
+            tabIndex: selectedValue === value ? 0 : -1,
+            "aria-selected": selectedValue === value,
+            key: value,
+            ref: (tabControl) => {
+              tabRefs.push(tabControl);
+            },
+            onKeyDown: handleKeydown,
+            onClick: handleTabChange,
+            ...attributes,
+            className: (0, clsx_1.default)(
+              "tabs__item",
+              "openapi-tabs__schema-item",
+              attributes?.className,
+              {
+                active: selectedValue === value,
+              }
+            ),
+          },
+          react_1.default.createElement(
+            "span",
+            { className: "openapi-tabs__schema-label" },
+            label ?? value
+          )
+        )
+      )
+    ),
+    showTabArrows &&
+      react_1.default.createElement("button", {
+        className: "openapi-tabs__arrow right",
+        onClick: handleRightClick,
+      })
+  );
+}
+function TabContent({ lazy, children, selectedValue }) {
+  const childTabs = (Array.isArray(children) ? children : [children]).filter(
+    Boolean
+  );
+  const flattenedChildTabs = (0, flatten_1.default)(childTabs);
+  if (lazy) {
+    const selectedTabItem = flattenedChildTabs.find(
+      (tabItem) => tabItem.props.value === selectedValue
+    );
+    if (!selectedTabItem) {
+      // fail-safe or fail-fast? not sure what's best here
+      return null;
+    }
+    return (0, react_1.cloneElement)(selectedTabItem, {
+      className: "margin-top--md",
+    });
+  }
+  return react_1.default.createElement(
+    "div",
+    { className: "margin-top--md" },
+    childTabs.map((tabItem, i) =>
+      (0, react_1.cloneElement)(tabItem, {
+        key: i,
+        hidden: tabItem.props.value !== selectedValue,
+      })
+    )
+  );
+}
+function TabsComponent(props) {
+  const tabs = (0, internal_1.useTabs)(props);
+  return react_1.default.createElement(
+    "div",
+    { className: "openapi-tabs__schema-container" },
+    react_1.default.createElement(TabList, { ...props, ...tabs }),
+    react_1.default.createElement(TabContent, { ...props, ...tabs })
+  );
+}
+function SchemaTabs(props) {
+  const isBrowser = (0, useIsBrowser_1.default)();
+  return react_1.default.createElement(
+    TabsComponent,
+    // Remount tabs after hydration
+    // Temporary fix for https://github.com/facebook/docusaurus/issues/5653
+    {
+      // Remount tabs after hydration
+      // Temporary fix for https://github.com/facebook/docusaurus/issues/5653
+      key: String(isBrowser),
+      ...props,
+    },
+    (0, internal_1.sanitizeTabsChildren)(props.children)
+  );
+}

package/lib/theme/SkeletonLoader/index.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface Props {
+    size?: "sm" | "md" | "lg";
+}
+declare const SkeletonLoader: React.FC<Props>;
+export default SkeletonLoader;

package/lib/theme/SkeletonLoader/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * 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 });
+const react_1 = __importDefault(require("react"));
+const SkeletonLoader = (props) => {
+  return react_1.default.createElement("div", {
+    className: `openapi-skeleton ${props.size ?? "md"}`,
+  });
+};
+exports.default = SkeletonLoader;

package/lib/theme/StatusCodes/index.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { ApiItem } from "docusaurus-plugin-openapi-docs/lib/types";
+interface Props {
+    id?: string;
+    label?: string;
+    responses: ApiItem["responses"];
+}
+declare const StatusCodes: React.FC<Props>;
+export default StatusCodes;