@mintlify/common 1.0.412 → 1.0.414

package/dist/index.d.ts

@@ -17,3 +17,4 @@ export * from './schema/common.js';
 export * from './camelToSentenceCase.js';
 export * from './asyncapi/index.js';
 export * from './isAbsoluteUrl.js';
+export * from './rss/index.js';

package/dist/index.js

@@ -17,3 +17,4 @@ export * from './schema/common.js';
 export * from './camelToSentenceCase.js';
 export * from './asyncapi/index.js';
 export * from './isAbsoluteUrl.js';
+export * from './rss/index.js';

package/dist/mdx/plugins/rehype/index.d.ts

@@ -1,4 +1,4 @@
-export * from './rehypeCodeBlocks.js';
+export * from './rehypeCodeBlocks/index.js';
 export * from './rehypeMdxExtractEndpoint/index.js';
 export * from './rehypeMdxExtractExamples.js';
 export * from './rehypeParamFieldIds.js';

package/dist/mdx/plugins/rehype/index.js

@@ -1,4 +1,4 @@
-export * from './rehypeCodeBlocks.js';
+export * from './rehypeCodeBlocks/index.js';
 export * from './rehypeMdxExtractEndpoint/index.js';
 export * from './rehypeMdxExtractExamples.js';
 export * from './rehypeParamFieldIds.js';

package/dist/mdx/plugins/rehype/rehypeCodeBlocks/buildMetaAttributes.d.ts

@@ -0,0 +1,3 @@
+import { MdxJsxAttribute, MdxJsxExpressionAttribute } from 'mdast-util-mdx-jsx';
+import { Meta } from './parseMetaString.js';
+export declare function buildMetaAttributes(meta: Meta): Array<MdxJsxAttribute | MdxJsxExpressionAttribute>;

package/dist/mdx/plugins/rehype/rehypeCodeBlocks/buildMetaAttributes.js

@@ -0,0 +1,16 @@
+export function buildMetaAttributes(meta) {
+    const attributes = [];
+    for (const [key, value] of Object.entries(meta)) {
+        if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
+            attributes.push({ type: 'mdxJsxAttribute', name: key, value: value.toString() });
+        }
+        else if (Array.isArray(value)) {
+            attributes.push({
+                type: 'mdxJsxAttribute',
+                name: key,
+                value: JSON.stringify(value),
+            });
+        }
+    }
+    return attributes;
+}

package/dist/mdx/plugins/rehype/{rehypeCodeBlocks.d.ts → rehypeCodeBlocks/index.d.ts}

@@ -1,4 +1,6 @@
 import type { Parent } from 'unist';
+export declare const FOCUS_CLASS_NAME = "line-focus";
+export declare const HIGHLIGHT_CLASS_NAME = "line-highlight";
 declare function addCodeBlocks<T extends Parent>(tree: T): void;
 export declare function rehypeCodeBlocks(): typeof addCodeBlocks;
 export {};

package/dist/mdx/plugins/rehype/rehypeCodeBlocks/index.js

@@ -0,0 +1,124 @@
+import { visit } from 'unist-util-visit';
+import { buildMetaAttributes } from './buildMetaAttributes.js';
+import { parseMetaString } from './parseMetaString.js';
+export const FOCUS_CLASS_NAME = 'line-focus';
+export const HIGHLIGHT_CLASS_NAME = 'line-highlight';
+const exampleNames = ['RequestExample', 'ResponseExample'];
+const flowElementType = 'mdxJsxFlowElement';
+function isElement(node, key = 'type', element = 'element') {
+    return node != undefined && node[key] === element;
+}
+function addCodeBlocks(tree) {
+    visit(tree, (node, i, parent) => {
+        var _a, _b;
+        if (parent == null || i == null || !isElement(node) || !isElement(node, 'tagName', 'pre')) {
+            return;
+        }
+        const code = node.children[0];
+        if (!isElement(code, 'tagName', 'code'))
+            return;
+        const isFlowElement = isElement(parent, 'type', flowElementType);
+        const parentName = isFlowElement ? parent.name : undefined;
+        let properties = code.type === 'element' ? Object.entries(code.properties) : [];
+        let meta;
+        if (parentName && exampleNames.includes(parentName)) {
+            const parentType = parentName.slice(0, -7);
+            meta = parseMetaString(parentType);
+            if (!((_a = code.data) === null || _a === void 0 ? void 0 : _a.meta)) {
+                code.data = Object.assign(Object.assign({}, code.data), { meta: i === 0 ? parentType : `${parentType} ${i + 1}` });
+            }
+        }
+        if (((_b = code.data) === null || _b === void 0 ? void 0 : _b.meta) && typeof code.data.meta === 'string') {
+            meta = parseMetaString(code.data.meta);
+        }
+        const attributes = buildMetaAttributes(meta !== null && meta !== void 0 ? meta : {});
+        const lineNumber = addLineHighlightAndFocus(code, meta === null || meta === void 0 ? void 0 : meta.highlight, meta === null || meta === void 0 ? void 0 : meta.focus);
+        if (lineNumber) {
+            properties = properties.filter(([key]) => key !== 'numberOfLines');
+            attributes.push({
+                type: 'mdxJsxAttribute',
+                name: 'numberOfLines',
+                value: lineNumber.toString(),
+            });
+        }
+        const wrapElement = {
+            type: flowElementType,
+            name: 'CodeBlock',
+            attributes: [
+                ...attributes,
+                ...properties
+                    .filter(([_key, val]) => val != null)
+                    .map(([key, val]) => ({
+                    type: 'mdxJsxAttribute',
+                    name: key,
+                    value: Array.isArray(val) ? val.join(' ') : val === null || val === void 0 ? void 0 : val.toString(),
+                })),
+            ],
+            data: { _mdxExplicitJsx: true },
+            children: [],
+        };
+        wrapElement.children = [node];
+        parent.children[i] = wrapElement;
+    });
+    tree.children = [...tree.children];
+}
+function addLineHighlightAndFocus(codeElement, highlightLines, focusLines) {
+    let lineNumber = 0;
+    // remove last empty line span if it exists
+    const lastChild = codeElement.children[codeElement.children.length - 1];
+    if (lastChild &&
+        lastChild.type === 'element' &&
+        lastChild.tagName === 'span' &&
+        lastChild.properties.class &&
+        lastChild.children.length === 0) {
+        const classValue = lastChild.properties.class;
+        const hasLineClass = typeof classValue === 'string'
+            ? classValue.includes('line')
+            : Array.isArray(classValue) && classValue.includes('line');
+        if (hasLineClass) {
+            codeElement.children.pop();
+        }
+    }
+    visit(codeElement, 'element', (span, _, spanParent) => {
+        if (!spanParent ||
+            spanParent.type !== 'element' ||
+            spanParent.tagName !== 'code' ||
+            span.tagName !== 'span' ||
+            !span.properties.class) {
+            return;
+        }
+        const classValue = span.properties.class;
+        const hasLineClass = typeof classValue === 'string'
+            ? classValue.includes('line')
+            : Array.isArray(classValue) && classValue.includes('line');
+        if (!hasLineClass) {
+            return;
+        }
+        lineNumber++;
+        if (highlightLines && highlightLines.length && highlightLines.includes(lineNumber)) {
+            addClassToSpan(span, HIGHLIGHT_CLASS_NAME);
+        }
+        if (focusLines && focusLines.length && focusLines.includes(lineNumber)) {
+            addClassToSpan(span, FOCUS_CLASS_NAME);
+        }
+    });
+    if (lineNumber > 0) {
+        codeElement.properties.numberOfLines = lineNumber;
+    }
+    return lineNumber;
+}
+function addClassToSpan(span, className) {
+    const currentClass = span.properties.class;
+    if (typeof currentClass === 'string') {
+        span.properties.class = currentClass + ' ' + className;
+    }
+    else if (Array.isArray(currentClass)) {
+        span.properties.class = [...currentClass, className];
+    }
+    else {
+        span.properties.class = className;
+    }
+}
+export function rehypeCodeBlocks() {
+    return addCodeBlocks;
+}

package/dist/mdx/plugins/rehype/rehypeCodeBlocks/metaOptions.d.ts

@@ -0,0 +1,123 @@
+export type MetaOptionBase = {
+    index: number;
+    raw: string;
+    key: string | undefined;
+    valueStartDelimiter: string;
+    valueEndDelimiter: string;
+};
+export type MetaOptionString = MetaOptionBase & {
+    kind: 'string';
+    value: string;
+};
+export type MetaOptionRange = MetaOptionBase & {
+    kind: 'range';
+    value: string;
+};
+export type MetaOptionRegExp = MetaOptionBase & {
+    kind: 'regexp';
+    value: RegExp;
+};
+export type MetaOptionBoolean = MetaOptionBase & {
+    kind: 'boolean';
+    value: boolean;
+};
+export type MetaOption = MetaOptionString | MetaOptionRange | MetaOptionRegExp | MetaOptionBoolean;
+export type MetaOptionKind = MetaOption['kind'];
+export declare class MetaOptions {
+    constructor(input: string, reservedKeys?: string[]);
+    parsedOptions: MetaOption[];
+    errors: string[] | undefined;
+    remainingText: string;
+    /**
+     * A list of error messages that occurred when parsing the meta string,
+     * or `undefined` if no errors occurred.
+     */
+    get getErrors(): string[] | undefined;
+    /**
+     * Returns the remaining text after all parsed options are removed.
+     * This is useful for extracting filename from meta strings.
+     */
+    getRemainingText(): string;
+    /**
+     * Returns a list of meta options, optionally filtered by their key and/or {@link MetaOptionKind}.
+     *
+     * @param keyOrKeys
+     * Allows to filter the options by key. An empty string will return options without a key.
+     * A non-empty string will return options with a matching key (case-insensitive).
+     * An array of strings will return options with any of the matching keys.
+     * If omitted, no key-based filtering will be applied.
+     *
+     * @param kind
+     * Allows to filter the options by {@link MetaOptionKind}.
+     * If omitted, no kind-based filtering will be applied.
+     */
+    list<K extends MetaOptionKind | undefined = undefined>(keyOrKeys?: string | string[], kind?: K): K extends "string" | "boolean" | "range" | "regexp" ? (Extract<MetaOptionString, {
+        kind: K;
+    }> | Extract<MetaOptionRange, {
+        kind: K;
+    }> | Extract<MetaOptionRegExp, {
+        kind: K;
+    }> | Extract<MetaOptionBoolean, {
+        kind: K;
+    }>)[] : MetaOption[];
+    value<K extends MetaOptionKind | undefined = undefined>(key: string, kind?: K): (K extends "string" | "boolean" | "range" | "regexp" ? Extract<MetaOptionString, {
+        kind: K;
+    }> | Extract<MetaOptionRange, {
+        kind: K;
+    }> | Extract<MetaOptionRegExp, {
+        kind: K;
+    }> | Extract<MetaOptionBoolean, {
+        kind: K;
+    }> : MetaOption)["value"] | undefined;
+    /**
+     * Returns the last string value with the given key (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getString(key: string): string | undefined;
+    /**
+     * Returns an array of all string values with the given keys (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getStrings(keyOrKeys?: string | string[]): string[];
+    /**
+     * Returns the last range value (`{value}`) with the given key (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getRange(key: string): string | undefined;
+    /**
+     * Returns an array of all range values (`{value}`) with the given keys (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getRanges(keyOrKeys?: string | string[]): string[];
+    /**
+     * Returns the last integer value with the given key (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getInteger(key: string): number | undefined;
+    /**
+     * Returns an array of all integer values with the given keys (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getIntegers(keyOrKeys?: string | string[]): number[];
+    getStringsWithInteger(keyOrKeys?: string | string[]): number[];
+    /**
+     * Returns an array of all integers from range values with the given keys (case-insensitive),
+     * parsing ranges like "1,3-5" to return [1,3,4,5].
+     * Works with range values (`{value}`) that contain comma-separated integers and ranges.
+     */
+    getRangesWithInteger(keyOrKeys?: string | string[]): number[];
+    /**
+     * Returns the last RegExp value (`/value/`) with the given key (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getRegExp(key: string): RegExp | undefined;
+    /**
+     * Returns an array of all RegExp values (`/value/`) with the given keys (case-insensitive),
+     * or without a key by passing an empty string.
+     */
+    getRegExps(keyOrKeys?: string | string[]): RegExp[];
+    /**
+     * Returns the last boolean value with the given key (case-insensitive).
+     */
+    getBoolean(key: string): boolean | undefined;
+}