@mintlify/common 1.0.1257 → 1.0.1259

package/dist/mdx/islands/extractPackageIslands.js

@@ -1,5 +1,8 @@
+import { getTableOfContentsTitle } from '../lib/remark-utils.js';
+import { createSlugDeduplicator } from '../lib/slug-deduplicator.js';
+import { HEADING_LEVELS } from '../plugins/remark/remarkComponentIds.js';
 import { bindingHead, collectBindings, collectConsts, esmStatements, lineOf, referencesIn, } from './island-bindings.js';
-import { IslandModuleBuilder, MOVE_TO_SNIPPET } from './island-module-builder.js';
+import { claimHeadingSlug, HEADING_ELEMENTS, IslandModuleBuilder, MOVE_TO_SNIPPET, } from './island-module-builder.js';
 import { blockerWithin, childrenPlacements, isIntrinsic, isListLoose, } from './island-placement.js';
 import { sha256Hex } from './sha256.js';
 const CSS_SPECIFIER = /\.css(?:[?#].*)?$/;
@@ -47,6 +50,7 @@ export const extractPackageIslands = (tree, options) => {
         if (statement.type !== 'ImportDeclaration')
             reportReferences(statement, line);
     }
+    const headingSlugs = createSlugDeduplicator();
     const tightItems = new WeakSet();
     const placements = new Map();
     const visitChildren = (parent, blocker, outside = blocker, via) => {
@@ -71,7 +75,7 @@ export const extractPackageIslands = (tree, options) => {
                         errors.push({ line: lineOf(child), message });
                         continue;
                     }
-                    const builder = new IslandModuleBuilder(child.name, options.pagePath, bindings, undeclared, consts, sideEffects, order);
+                    const builder = new IslandModuleBuilder(child.name, options.pagePath, bindings, undeclared, consts, sideEffects, order, headingSlugs);
                     const element = builder.element(child);
                     if (builder.errors.length > 0 || !element) {
                         errors.push(...builder.errors);
@@ -92,7 +96,7 @@ export const extractPackageIslands = (tree, options) => {
                             module,
                         });
                     }
-                    roots.push({ id, name: child.name, node: child, parent });
+                    roots.push({ id, name: child.name, node: child, parent, headings: builder.headings });
                     continue;
                 }
                 if (child.name && head !== undefined && undeclared.has(head)) {
@@ -102,6 +106,12 @@ export const extractPackageIslands = (tree, options) => {
                     });
                     continue;
                 }
+                if (child.name && HEADING_ELEMENTS.has(child.name)) {
+                    const id = child.attributes.find((attribute) => attribute.type === 'mdxJsxAttribute' && attribute.name === 'id');
+                    if (id === undefined || typeof id.value === 'string') {
+                        claimHeadingSlug(headingSlugs, getTableOfContentsTitle(child), typeof (id === null || id === void 0 ? void 0 : id.value) === 'string' ? id.value : undefined);
+                    }
+                }
                 for (const attribute of child.attributes) {
                     let estree;
                     if (attribute.type === 'mdxJsxExpressionAttribute') {
@@ -129,6 +139,9 @@ export const extractPackageIslands = (tree, options) => {
                     reportReferences(child.data.estree, lineOf(child));
                 continue;
             }
+            if (child.type === 'heading' && HEADING_LEVELS.includes(child.depth)) {
+                claimHeadingSlug(headingSlugs, getTableOfContentsTitle(child));
+            }
             if (child.type === 'list' && !isListLoose(child)) {
                 for (const item of child.children)
                     tightItems.add(item);

package/dist/mdx/islands/island-module-builder.d.ts

@@ -1,13 +1,16 @@
 import type { JSXElement, JSXExpressionContainer, JSXFragment } from 'estree-jsx';
 import type { RootContent } from 'mdast';
+import type { SlugDeduplicator } from '../lib/slug-deduplicator.js';
 import { type Binding } from './island-bindings.js';
 import { type ConstEntry } from './static-expressions.js';
-import type { IslandError, IslandImport } from './types.js';
+import type { IslandError, IslandHeading, IslandImport } from './types.js';
 type JsxNode = Extract<RootContent, {
     type: 'mdxJsxFlowElement' | 'mdxJsxTextElement';
 }>;
 type JsxChild = JSXElement | JSXFragment | JSXExpressionContainer;
 export declare const MOVE_TO_SNIPPET = "Move this into a snippet.";
+export declare const claimHeadingSlug: (slugs: SlugDeduplicator, title: string, explicitId?: string) => string | undefined;
+export declare const HEADING_ELEMENTS: Map<string, number>;
 export declare class IslandModuleBuilder {
     private readonly rootName;
     private readonly pagePath;
@@ -16,14 +19,18 @@ export declare class IslandModuleBuilder {
     private readonly consts;
     private readonly sideEffects;
     private readonly order;
+    private readonly headingSlugs;
     readonly usedBindings: Map<string, Binding>;
     readonly usedConsts: Set<string>;
     readonly errors: IslandError[];
-    constructor(rootName: string, pagePath: string, bindings: Map<string, Binding>, undeclared: Map<string, string>, consts: Map<string, ConstEntry>, sideEffects: ReadonlyMap<string, unknown>, order: readonly string[]);
+    readonly headings: IslandHeading[];
+    constructor(rootName: string, pagePath: string, bindings: Map<string, Binding>, undeclared: Map<string, string>, consts: Map<string, ConstEntry>, sideEffects: ReadonlyMap<string, unknown>, order: readonly string[], headingSlugs: SlugDeduplicator);
     private url;
     private fail;
     private insideRoot;
     element(node: JsxNode): JSXElement | JSXFragment | undefined;
+    private addHeadingId;
+    private headingTitle;
     private attribute;
     private propFailure;
     private intrinsic;

package/dist/mdx/islands/island-module-builder.js

@@ -1,5 +1,8 @@
 import { jsx as jsxHandlers, toJs } from 'estree-util-to-js';
 import { parseInlineStyle } from '../../parse-inline-style.js';
+import { safeCleanHeadingId, slugify } from '../../slugify.js';
+import { getTableOfContentsTitle } from '../lib/remark-utils.js';
+import { HEADING_LEVELS } from '../plugins/remark/remarkComponentIds.js';
 import { resolveRelativeUrl } from '../plugins/remark/remarkResolveRelativeLinks.js';
 import { allowedComponents } from '../utils.js';
 import { bindingHead, lineOf } from './island-bindings.js';
@@ -101,9 +104,14 @@ const unravel = (nodes) => nodes.flatMap((node) => node.type === 'paragraph' &&
     node.children.every((child) => isJsxPhrasing(child) || (child.type === 'text' && /^[\t\n\v\f\r ]*$/.test(child.value)))
     ? node.children.filter((child) => child.type !== 'text' || !/^[\t\r\n ]+$/.test(child.value))
     : [node]);
+export const claimHeadingSlug = (slugs, title, explicitId) => {
+    const base = (explicitId === undefined ? undefined : safeCleanHeadingId(explicitId)) || slugify(title);
+    return base ? slugs.claim(base) : undefined;
+};
+export const HEADING_ELEMENTS = new Map(HEADING_LEVELS.map((level) => [`h${level}`, level]));
 const truncate = (value, max = 40) => value.length > max ? `${value.slice(0, max - 1)}…` : value;
 export class IslandModuleBuilder {
-    constructor(rootName, pagePath, bindings, undeclared, consts, sideEffects, order) {
+    constructor(rootName, pagePath, bindings, undeclared, consts, sideEffects, order, headingSlugs) {
         this.rootName = rootName;
         this.pagePath = pagePath;
         this.bindings = bindings;
@@ -111,9 +119,11 @@ export class IslandModuleBuilder {
         this.consts = consts;
         this.sideEffects = sideEffects;
         this.order = order;
+        this.headingSlugs = headingSlugs;
         this.usedBindings = new Map();
         this.usedConsts = new Set();
         this.errors = [];
+        this.headings = [];
     }
     url(value, isPageLink) {
         return literal(resolveRelativeUrl(this.pagePath, value, isPageLink));
@@ -168,8 +178,63 @@ export class IslandModuleBuilder {
             if (converted)
                 attributes.push(converted);
         }
+        const headingLevel = HEADING_ELEMENTS.get(name);
+        if (headingLevel !== undefined)
+            this.addHeadingId(node, headingLevel, attributes);
         return jsxElement(name, attributes, this.children(node.children));
     }
+    addHeadingId(node, depth, attributes) {
+        var _a;
+        const index = attributes.findIndex((attribute) => attribute.name.type === 'JSXIdentifier' && attribute.name.name === 'id');
+        let explicitId;
+        if (index !== -1) {
+            const value = (_a = attributes[index]) === null || _a === void 0 ? void 0 : _a.value;
+            if ((value === null || value === void 0 ? void 0 : value.type) !== 'JSXExpressionContainer' ||
+                value.expression.type !== 'Literal' ||
+                typeof value.expression.value !== 'string') {
+                return;
+            }
+            explicitId = value.expression.value;
+        }
+        const title = this.headingTitle(node);
+        const slug = claimHeadingSlug(this.headingSlugs, title, explicitId);
+        if (slug === undefined)
+            return;
+        const id = jsxAttribute('id', literal(safeCleanHeadingId(slug)));
+        if (index === -1)
+            attributes.unshift(id);
+        else
+            attributes[index] = id;
+        if (title.trim())
+            this.headings.push({ title, slug, depth });
+    }
+    headingTitle(node) {
+        if (!('children' in node))
+            return getTableOfContentsTitle(node);
+        return node.children
+            .map((child, index, children) => {
+            var _a, _b, _c;
+            if (child.type !== 'mdxTextExpression' && child.type !== 'mdxFlowExpression') {
+                return 'children' in child
+                    ? this.headingTitle(child)
+                    : getTableOfContentsTitle(child, index, children);
+            }
+            const statement = (_b = (_a = child.data) === null || _a === void 0 ? void 0 : _a.estree) === null || _b === void 0 ? void 0 : _b.body[0];
+            if ((statement === null || statement === void 0 ? void 0 : statement.type) !== 'ExpressionStatement')
+                return '';
+            const converted = toStaticExpression(statement.expression, this.consts, new Set());
+            if (!converted.ok)
+                return '';
+            const expression = converted.expression.type === 'Identifier'
+                ? (_c = this.consts.get(converted.expression.name)) === null || _c === void 0 ? void 0 : _c.expression
+                : converted.expression;
+            return (expression === null || expression === void 0 ? void 0 : expression.type) === 'Literal' &&
+                (typeof expression.value === 'string' || typeof expression.value === 'number')
+                ? String(expression.value)
+                : '';
+        })
+            .join('');
+    }
     attribute(node, elementName, attribute) {
         var _a;
         const at = attribute.position ? attribute : node;
@@ -276,8 +341,12 @@ export class IslandModuleBuilder {
                 return [
                     jsxElement('blockquote', [], wrap(unravel(node.children).map((child) => { var _a; return (_a = this.child(child)) !== null && _a !== void 0 ? _a : []; }))),
                 ];
-            case 'heading':
-                return [this.intrinsic(`h${node.depth}`, node.children)];
+            case 'heading': {
+                const attributes = [];
+                if (HEADING_LEVELS.includes(node.depth))
+                    this.addHeadingId(node, node.depth, attributes);
+                return [this.intrinsic(`h${node.depth}`, node.children, attributes)];
+            }
             case 'link': {
                 const attributes = [jsxAttribute('href', this.url(node.url, true))];
                 if (node.title)

package/dist/mdx/islands/remarkPackageIslands.js

@@ -42,6 +42,7 @@ const placeholder = (type, id) => ({
     attributes: [{ type: 'mdxJsxAttribute', name: 'id', value: id }],
     children: [],
 });
+const flowPlaceholder = (id, headings = []) => (Object.assign(Object.assign({}, placeholder('mdxJsxFlowElement', id)), (headings.length > 0 && { data: { islandHeadings: headings } })));
 const isIslandImport = (source, importer, options) => {
     if (isDeclaredPackageImport(source, options.packageNames))
         return true;
@@ -98,11 +99,13 @@ export const remarkPackageIslands = (options) => (tree) => {
     if (own.roots.length === 0)
         return;
     const ids = new Map();
+    const headings = new Map();
     const buildErrors = [];
     own.roots.forEach((root, index) => {
         var _a, _b, _c, _d, _e;
         const id = (_b = (_a = plan.roots[index]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : root.id;
         ids.set(root.node, id);
+        headings.set(root.node, root.headings);
         if (!options.islandHtml)
             return;
         const entry = options.islandHtml[id];
@@ -134,9 +137,9 @@ export const remarkPackageIslands = (options) => (tree) => {
         if (node.type === 'paragraph') {
             const only = soleParagraphChild(node);
             const id = only ? ids.get(only) : undefined;
-            if (id === undefined)
+            if (id === undefined || !only)
                 return;
-            parent.children[index] = placeholder('mdxJsxFlowElement', id);
+            parent.children[index] = flowPlaceholder(id, headings.get(only));
             return SKIP;
         }
         const id = ids.get(node);
@@ -145,7 +148,7 @@ export const remarkPackageIslands = (options) => (tree) => {
         parent.children[index] =
             node.type === 'mdxJsxTextElement'
                 ? placeholder('mdxJsxTextElement', id)
-                : placeholder('mdxJsxFlowElement', id);
+                : flowPlaceholder(id, headings.get(node));
         return SKIP;
     });
     removeIslandImports(tree, options);

package/dist/mdx/islands/types.d.ts

@@ -1,5 +1,15 @@
 import type { Parent } from 'mdast';
 import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
+declare module 'mdast-util-mdx-jsx' {
+    interface MdxJsxFlowElementData {
+        islandHeadings?: IslandHeading[];
+    }
+}
+export type IslandHeading = {
+    title: string;
+    slug: string;
+    depth: number;
+};
 export type IslandImport = {
     local: string;
     pkg: string;
@@ -28,6 +38,7 @@ export type IslandRoot = {
     name: string;
     node: MdxJsxFlowElement | MdxJsxTextElement;
     parent: Parent;
+    headings: IslandHeading[];
 };
 export type ExtractPackageIslandsResult = {
     islands: IslandSpec[];

package/dist/mdx/lib/slug-deduplicator.d.ts

@@ -0,0 +1,5 @@
+export type SlugDeduplicator = {
+    claim: (slug: string) => string;
+    reserve: (slug: string) => void;
+};
+export declare const createSlugDeduplicator: () => SlugDeduplicator;

package/dist/mdx/lib/slug-deduplicator.js

@@ -0,0 +1,24 @@
+export const createSlugDeduplicator = () => {
+    const seen = new Map();
+    return {
+        claim: (slug) => {
+            var _a;
+            const count = (_a = seen.get(slug)) !== null && _a !== void 0 ? _a : 0;
+            seen.set(slug, count + 1);
+            if (count === 0)
+                return slug;
+            let suffix = count + 1;
+            let suffixed = `${slug}-${suffix}`;
+            while (seen.has(suffixed)) {
+                suffix += 1;
+                suffixed = `${slug}-${suffix}`;
+            }
+            seen.set(suffixed, 1);
+            return suffixed;
+        },
+        reserve: (slug) => {
+            var _a;
+            seen.set(slug, ((_a = seen.get(slug)) !== null && _a !== void 0 ? _a : 0) + 1);
+        },
+    };
+};