@redocly/theme 0.70.0-next.9 → 0.70.1

package/lib/core/types/search.d.ts

@@ -0,0 +1,157 @@
+import type { ItemBadge, REDOCLY_ROUTE_RBAC } from '@redocly/config';
+import type { ProductConfig } from '../../config';
+import type { AiSearchConversationRole } from '../constants/search';
+export type OperationParameter = {
+    name: string | string[];
+    description: string | string[];
+    place: string;
+    mediaType: string | undefined;
+    path?: string[];
+    deepLink?: string;
+    type: string;
+    required: boolean;
+    example: string | undefined;
+    enum: string[] | undefined;
+};
+export type SearchHit = {
+    id: string;
+    url: string;
+    title: string | string[];
+    text: string | string[];
+    path?: string[];
+    httpMethod?: string;
+    httpPath?: string | string[];
+    deprecated?: boolean;
+    isAdditionalOperation?: boolean;
+    security?: string[];
+    parameters?: OperationParameter[];
+    version?: string;
+    versionFolderId?: string;
+    isDefaultVersion?: boolean;
+    product?: ProductConfig;
+    'redocly::teams-rbac'?: {
+        [x: string]: string;
+    };
+    [REDOCLY_ROUTE_RBAC]?: {
+        slug?: string;
+        fsPath?: string;
+    };
+    badges?: ItemBadge[];
+    facets?: Record<string, string>;
+    tags?: string[];
+    rbacTeams?: string[];
+};
+export type ParameterHighlight = {
+    name: string;
+    description: string;
+    place: string;
+    path: string[];
+    enum?: string;
+    example?: string;
+};
+export type SearchItemData = {
+    document: SearchHit;
+    highlight: Record<string, string> & {
+        parameters?: ParameterHighlight[];
+        path?: string[];
+    };
+};
+export type SearchFacet = {
+    name: string;
+    field: string;
+    type: SearchFacetType;
+    values: string[] | SearchFacetCount[];
+    index?: number;
+    queryable?: boolean;
+};
+export type SearchFacetCount = {
+    value: string;
+    count: number;
+    isCounterVisible?: boolean;
+};
+export type SearchFacetQuery = {
+    query: string;
+    filter: SearchFilterItem[];
+    facetQuery: string;
+};
+export type SearchFacetType = 'input' | 'multi-select' | 'select' | 'switch' | 'radio' | 'tags' | 'checkbox';
+export type SearchFilterItem = {
+    field: string;
+    values: string[];
+    isQuickFilter?: boolean;
+};
+export type AiSearchErrorConfig = {
+    headerKey: string;
+    headerDefault: string;
+    messageKey: string;
+    messageDefault: string;
+};
+export declare enum FeedbackType {
+    Like = "like",
+    Dislike = "dislike"
+}
+export type SearchAiMessageResource = {
+    url: string;
+    title: string;
+};
+export type ToolCall = {
+    id: string;
+    name: string;
+    args: unknown;
+    position: number;
+    result?: {
+        toolCallId: string;
+        documentCount?: number;
+    };
+};
+export type ContentSegment = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool';
+    toolCall: ToolCall;
+};
+export type GroupedContentSegment = {
+    type: 'text';
+    text: string;
+}
+/** `isActive`: the assistant still works on this group, with nothing written after it yet. */
+ | {
+    type: 'tools';
+    toolCalls: ToolCall[];
+    isActive: boolean;
+};
+export type SearchAiActivityKind = 'thinking' | 'search' | 'code' | 'support';
+export type SearchAiActivityStatus = {
+    label: string;
+    detail?: string;
+    kind: SearchAiActivityKind;
+    isRunning: boolean;
+};
+export type SearchAiActivityStep = {
+    id: string;
+    label: string;
+    kind: SearchAiActivityKind;
+    isRunning: boolean;
+};
+export type AiSearchConversationItem = {
+    role: AiSearchConversationRole;
+    content: string;
+    sentAt?: string;
+    resources?: SearchAiMessageResource[];
+    messageId?: string;
+    feedback?: FeedbackType;
+    toolCalls?: ToolCall[];
+    contentSegments?: ContentSegment[];
+};
+export declare enum ToolCallName {
+    SearchDocumentation = "search_documentation",
+    ListApis = "list-apis",
+    GetEndpoints = "get-endpoints",
+    GetEndpointInfo = "get-endpoint-info",
+    GetSecuritySchemes = "get-security-schemes",
+    GetFullApiDescription = "get-full-api-description",
+    Execute = "execute",
+    DescribeTools = "describe-tools",
+    ContactSupport = "contact-support"
+}

package/lib/core/types/search.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCallName = exports.FeedbackType = void 0;
+var FeedbackType;
+(function (FeedbackType) {
+    FeedbackType["Like"] = "like";
+    FeedbackType["Dislike"] = "dislike";
+})(FeedbackType || (exports.FeedbackType = FeedbackType = {}));
+var ToolCallName;
+(function (ToolCallName) {
+    ToolCallName["SearchDocumentation"] = "search_documentation";
+    ToolCallName["ListApis"] = "list-apis";
+    ToolCallName["GetEndpoints"] = "get-endpoints";
+    ToolCallName["GetEndpointInfo"] = "get-endpoint-info";
+    ToolCallName["GetSecuritySchemes"] = "get-security-schemes";
+    ToolCallName["GetFullApiDescription"] = "get-full-api-description";
+    ToolCallName["Execute"] = "execute";
+    ToolCallName["DescribeTools"] = "describe-tools";
+    ToolCallName["ContactSupport"] = "contact-support";
+})(ToolCallName || (exports.ToolCallName = ToolCallName = {}));
+//# sourceMappingURL=search.js.map

package/lib/core/types/segmented.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+import type { SelectOption } from './select';
+export type SegmentedOption<T> = SelectOption<T> & {
+    divider?: React.ReactNode;
+};
+export type SegmentedProps<T = any> = {
+    options: SegmentedOption<T>[];
+    value: T;
+    onChange: ({ label, value }: SegmentedOption<T>) => void;
+    className?: string;
+    size?: 'regular' | 'small';
+};

package/lib/core/types/segmented.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=segmented.js.map

package/lib/core/types/select.d.ts

@@ -0,0 +1,32 @@
+import type React from 'react';
+import type { JSX } from 'react';
+export type SelectOption<T> = {
+    value: T;
+    element?: React.ReactNode | JSX.Element | string;
+    label?: string;
+};
+export type SelectProps<T = any> = {
+    value?: SelectOption<T> | SelectOption<T>[] | T | T[];
+    options: SelectOption<T>[];
+    multiple?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    dataAttributes?: Record<string, string>;
+    className?: string;
+    withArrow?: boolean;
+    triggerEvent?: 'click' | 'hover';
+    placement?: 'top' | 'bottom';
+    alignment?: 'start' | 'end';
+    onlyIcon?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    hideCheckmarkIcon?: boolean;
+    checkmarkIconPosition?: 'start' | 'end';
+    dataTestId?: string;
+    icon?: React.ReactNode;
+    footer?: React.ReactNode;
+    onChange?: (value: T | T[]) => void;
+    renderInput?: () => React.ReactElement;
+    renderDivider?: () => React.ReactElement;
+    onSearch?: (value: T | null) => void;
+};

package/lib/core/types/select.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=select.js.map

package/lib/core/types/sidebar.d.ts

@@ -0,0 +1,63 @@
+import type { REDOCLY_TEAMS_RBAC, REDOCLY_ROUTE_RBAC, MenuStyle, RbacScopeItems, ItemBadge } from '@redocly/config';
+import type { MenuItemType } from '../constants/common';
+export type { MenuStyle } from '@redocly/config';
+export type SidebarNavItem = {
+    label?: string;
+    labelTranslationKey?: string;
+    sublabel?: string;
+    subLabelTranslationKey?: string;
+    icon?: string;
+    srcSet?: string;
+    link?: string;
+    type?: string;
+    httpVerb?: string;
+    expanded?: string;
+    selectFirstItemOnExpand?: boolean;
+    pageId?: string;
+    redocPrevLink?: string;
+    redocPrevLabel?: string;
+    redocNextLink?: string;
+    redocNextLabel?: string;
+    redocFakePage?: boolean;
+    redocInfoPageId?: string;
+    target?: string;
+    external?: boolean;
+    items?: SidebarNavItem[];
+    [REDOCLY_TEAMS_RBAC]?: RbacScopeItems;
+    [REDOCLY_ROUTE_RBAC]?: {
+        slug?: string;
+        fsPath?: string;
+    };
+    menuStyle?: MenuStyle;
+    separatorLine?: boolean;
+    linePosition?: 'top' | 'bottom';
+    version?: string;
+    variant?: 'primary' | 'secondary';
+    hideWhenEmpty?: boolean;
+    badges?: ItemBadge[];
+};
+export type ItemState = Omit<SidebarNavItem, 'items'> & {
+    items: ItemState[];
+    active: boolean;
+    hasActiveSubItem: boolean;
+    menuStyle?: MenuStyle;
+    languageInsensitive?: boolean;
+    modified?: boolean;
+    deprecated?: boolean;
+    isAdditionalOperation?: boolean;
+};
+export type DrilldownMenuItemDetails = {
+    previousLink?: string;
+    item: ItemState;
+};
+export type MenuItemProps = {
+    item: ItemState;
+    activeItem?: ItemState;
+    className?: string;
+    isMobile?: boolean;
+    depth?: number;
+    type?: MenuItemType;
+    isExpanded?: boolean;
+    onClick?: () => void;
+};
+export type MenuItemsAnimation = 'slideInLeft' | 'slideInRight';

package/lib/core/types/sidebar.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=sidebar.js.map

package/lib/core/types/toast.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+export type ToastType = 'info' | 'success' | 'warning' | 'error' | 'loading';
+export interface ToastOptions {
+    type?: ToastType;
+    title: string;
+    description?: string;
+    duration?: number;
+    onClose?: () => void;
+}
+export interface ToastItem extends ToastOptions {
+    id: string;
+    type: ToastType;
+    isExiting: boolean;
+}
+export interface ToastContextValue {
+    showToast: (options: ToastOptions) => string;
+    dismissToast: (id: string) => void;
+    updateToast: (id: string, updates: Partial<ToastOptions>) => void;
+}
+export interface ToastProviderProps {
+    children: ReactNode;
+    mountId?: string;
+}

package/lib/core/types/toast.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=toast.js.map

package/lib/core/types/tooltip.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+export type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+export type TooltipProps = {
+    children?: ReactNode;
+    tip: string | ReactNode;
+    isOpen?: boolean;
+    withArrow?: boolean;
+    placement?: TooltipPlacement;
+    fallbackPlacements?: TooltipPlacement[];
+    className?: string;
+    width?: string;
+    dataTestId?: string;
+    disabled?: boolean;
+    arrowPosition?: 'top' | 'bottom' | 'left' | 'right' | 'center';
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+};

package/lib/core/types/tooltip.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tooltip.js.map

package/lib/core/types/user-claims.d.ts

@@ -0,0 +1,6 @@
+export type UserClaims = {
+    email?: string;
+    name?: string;
+    federatedAccessToken?: string;
+    federatedIdToken?: string;
+};

package/lib/core/types/user-claims.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=user-claims.js.map

package/lib/core/types/user-menu.d.ts

@@ -0,0 +1,12 @@
+export type UserMenuData = {
+    userData: {
+        isAuthenticated: boolean;
+        name: string;
+        picture: string;
+        email?: string;
+        logoutDisabled?: boolean;
+    };
+    handleLogout: (logoutRedirect?: string) => void;
+    hasDeveloperOnboarding?: boolean;
+    loginUrl?: string;
+};

package/lib/core/types/user-menu.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=user-menu.js.map

package/lib/core/utils/Dynamic.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface DynamicOptions<TProps extends Record<string, unknown>> {
+    ssr?: boolean;
+    loading?: React.ComponentType<TProps>;
+}
+/**
+ * A component from `dynamic()`. After `preload()` resolves, the component renders without a
+ * loading state. On the server, `preload()` does not load a client-only component (`ssr: false`).
+ */
+export type DynamicComponent<TProps> = React.ComponentType<TProps> & {
+    preload(): Promise<void>;
+};
+export declare function dynamic<TProps extends Record<string, unknown>>(factory: () => Promise<React.ComponentType<TProps> | {
+    default: React.ComponentType<TProps>;
+} | Record<string, unknown>>, { ssr, loading }?: DynamicOptions<TProps>): DynamicComponent<TProps>;
+export {};

package/lib/core/utils/Dynamic.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamic = dynamic;
+const react_1 = __importDefault(require("react"));
+function dynamic(factory, { ssr = true, loading } = {}) {
+    let loaded;
+    let pending;
+    const load = () => (pending !== null && pending !== void 0 ? pending : (pending = factory()
+        .then((mod) => {
+        // Case 1: factory() => import('./SomeModule') - direct import
+        // Case 2: factory() => import('./SomeModule').then(mod => mod.default) - extract default
+        if (typeof mod === 'function') {
+            return { default: mod };
+        }
+        // Case 3: factory() => import('./SomeModule').then(mod => ({ default: mod.default })) - manual wrap
+        // Case 4: factory() => import('./SomeModule').then(mod => ({ default: mod.Named })) - manual wrap named
+        if (mod && typeof mod === 'object' && 'default' in mod) {
+            const defaultExport = mod.default;
+            // Handle both function components and React component objects (e.g., memo/forwardRef)
+            if (typeof defaultExport === 'function') {
+                return { default: defaultExport };
+            }
+            if (defaultExport && typeof defaultExport === 'object' && '$$typeof' in defaultExport) {
+                return { default: defaultExport };
+            }
+        }
+        // Case 5: factory() => import('./SomeModule').then(mod => mod.Named) - find named export
+        if (mod && typeof mod === 'object') {
+            const modObj = mod;
+            for (const key in modObj) {
+                const value = modObj[key];
+                if (typeof value === 'function') {
+                    return { default: value };
+                }
+                if (value && typeof value === 'object' && '$$typeof' in value) {
+                    return { default: value };
+                }
+            }
+        }
+        throw new Error('Dynamic import did not return a valid React component');
+    })
+        .then((module) => {
+        loaded = module.default;
+        return module;
+    }, (error) => {
+        // A failed load is not kept, so the next preload tries again.
+        pending = undefined;
+        throw error;
+    })));
+    const LazyComponent = react_1.default.lazy(load);
+    const LoadingComponent = loading || (() => null);
+    const DynamicComponent = (props) => {
+        const [hasMounted, setHasMounted] = react_1.default.useState(false);
+        // Fixed per instance: a change of the element type would remount the component.
+        const [Component] = react_1.default.useState(() => loaded !== null && loaded !== void 0 ? loaded : LazyComponent);
+        react_1.default.useEffect(() => {
+            setHasMounted(true);
+        }, []);
+        if (ssr) {
+            return (react_1.default.createElement(react_1.default.Suspense, { fallback: react_1.default.createElement(LoadingComponent, Object.assign({}, props)) },
+                react_1.default.createElement(Component, Object.assign({}, props))));
+        }
+        if (!hasMounted) {
+            return react_1.default.createElement(LoadingComponent, Object.assign({}, props));
+        }
+        return (react_1.default.createElement(react_1.default.Suspense, { fallback: react_1.default.createElement(LoadingComponent, Object.assign({}, props)) },
+            react_1.default.createElement(Component, Object.assign({}, props))));
+    };
+    return Object.assign(DynamicComponent, {
+        preload() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (ssr || typeof window !== 'undefined')
+                    yield load();
+            });
+        },
+    });
+}
+//# sourceMappingURL=Dynamic.js.map

package/lib/core/utils/GetFileIcon.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export declare function getFileIconByExt(ext: string): React.JSX.Element;
+export declare function getFileIconByLanguage(language: string): React.JSX.Element;

package/lib/core/utils/GetFileIcon.js

@@ -0,0 +1,127 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileIconByExt = getFileIconByExt;
+exports.getFileIconByLanguage = getFileIconByLanguage;
+const React = __importStar(require("react"));
+const CDNIcon_1 = require("../../icons/CDNIcon/CDNIcon");
+// extension to icon name
+const fileIconMap = {
+    yaml: 'yaml',
+    yml: 'yaml',
+    json: 'json',
+    js: 'javascript',
+    ts: 'typescript',
+    css: 'css',
+    html: 'html',
+    jsx: 'react',
+    tsx: 'react',
+    md: 'markdown',
+    graphql: 'graphql',
+    gql: 'graphql',
+    py: 'python',
+    sh: 'console',
+    xsh: 'console',
+    nu: 'console',
+    java: 'java',
+    ps: 'powershell',
+    php: 'php_elephant',
+    go: 'go',
+    ruby: 'ruby',
+    swift: 'swift',
+    kotlin: 'kotlin',
+    rust: 'rust',
+    scala: 'scala',
+    elixir: 'elixir',
+    dart: 'dart',
+    http: 'http',
+    rest: 'http',
+    c: 'c',
+    h: 'c',
+    hpp: 'c',
+    cc: 'c',
+    cpp: 'c',
+    cxx: 'c',
+    'c++': 'c',
+    sql: 'database',
+    hbs: 'handlebars',
+    cs: 'csharp',
+    csx: 'csharp',
+    csharp: 'csharp',
+    markdoc: 'markdoc',
+    mdoc: 'markdoc',
+    mdx: 'mdx',
+};
+// code block language to icon name, only for those when code extension is not available
+const languageIconMap = {
+    bash: 'console',
+    python: 'python',
+    java: 'java',
+    graphql: 'graphql',
+    javascript: 'javascript',
+    typescript: 'typescript',
+    react: 'react',
+    markdown: 'markdown',
+    php: 'php_elephant',
+    ruby: 'ruby',
+    swift: 'swift',
+    kotlin: 'kotlin',
+    rust: 'rust',
+    scala: 'scala',
+    elixir: 'elixir',
+    dart: 'dart',
+    csharp: 'csharp',
+    objectivec: 'c',
+    perl: 'perl',
+    sql: 'database',
+    xml: 'xml',
+    vim: 'vim',
+    lua: 'lua',
+    zsh: 'console',
+    fish: 'console',
+    powershell: 'console',
+    handlebars: 'handlebars',
+    markdoc: 'markdoc',
+    mdx: 'mdx',
+};
+function getFileIconByExt(ext) {
+    const iconName = fileIconMap[ext] || 'document';
+    return React.createElement(CDNIcon_1.CDNIcon, { name: iconName, pack: "code", mode: "background" });
+}
+function getFileIconByLanguage(language) {
+    const iconName = fileIconMap[language] || languageIconMap[language] || 'document';
+    return React.createElement(CDNIcon_1.CDNIcon, { name: iconName, pack: "code", mode: "background" });
+}
+//# sourceMappingURL=GetFileIcon.js.map

package/lib/core/utils/RenderWithLink.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from 'react';
+export declare function renderWithLink(text: string, href: string): JSX.Element;

package/lib/core/utils/RenderWithLink.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderWithLink = renderWithLink;
+const react_1 = __importDefault(require("react"));
+// Splits a translated sentence on <link>...</link> markers and renders the
+// marked phrase as an anchor, so each locale keeps its own word order.
+function renderWithLink(text, href) {
+    const [before, label, after] = text.split(/<link>|<\/link>/);
+    if (label === undefined) {
+        return react_1.default.createElement(react_1.default.Fragment, null, text);
+    }
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        before,
+        react_1.default.createElement("a", { href: href }, label),
+        after));
+}
+//# sourceMappingURL=RenderWithLink.js.map

package/lib/core/utils/add-line-numbers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param highlightedCode - A string with new line breaks; the line numbers will be added before each line.
+ * @param start - The number to start the line numbering from; default is 1
+ * @returns A string with line numbers added before each line
+ */
+export declare function addLineNumbers(highlightedCode: string, start?: number): string;