@mintlify/scraping 4.0.952 → 4.0.954

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/scraping",
-  "version": "4.0.952",
+  "version": "4.0.954",
   "description": "Scrape documentation frameworks to Mintlify docs",
   "engines": {
     "node": ">=18.0.0"
@@ -43,7 +43,7 @@
     "format:check": "oxfmt --check"
   },
   "dependencies": {
-    "@mintlify/common": "1.0.1085",
+    "@mintlify/common": "1.0.1086",
     "fast-xml-parser": "5.7.3",
     "fs-extra": "11.1.1",
     "graphql": "16.11.0",
@@ -63,9 +63,9 @@
     "zod": "3.24.0"
   },
   "devDependencies": {
-    "@mintlify/models": "0.0.347",
+    "@mintlify/models": "0.0.348",
     "@mintlify/ts-config": "2.0.2",
-    "@mintlify/validation": "0.1.825",
+    "@mintlify/validation": "0.1.826",
     "@tsconfig/recommended": "1.0.2",
     "@types/hast": "3.0.4",
     "@types/mdast": "4.0.4",
@@ -79,5 +79,5 @@
     "typescript": "5.5.3",
     "vitest": "2.1.9"
   },
-  "gitHead": "2a68e3ad7ad0237b95413bf78989cfb5031d9d85"
+  "gitHead": "779dd0a76dc2128fe36244c7761cf765d3774f27"
 }

package/src/index.ts

@@ -14,5 +14,13 @@ export { checkUrl } from './utils/url.js';
 export { FINAL_SUCCESS_MESSAGE } from './constants.js';
 export { parseGraphqlSdl } from './graphql/parseGraphqlSdl.js';
 export { generateSdkReference } from './sdk/generateSdkReference.js';
+export { findSdkPage, matchesSdkPageTarget, renderSdkTarget } from './sdk/findSdkPage.js';
 export { htmlToMdx, hastToMdx, markdownToMdx } from './sdk/convert.js';
-export type { SdkFormat, SdkPage, SdkNavGroup, SdkReference, SdkConverter } from './sdk/types.js';
+export type {
+  SdkFormat,
+  SdkPage,
+  SdkPageTarget,
+  SdkNavGroup,
+  SdkReference,
+  SdkConverter,
+} from './sdk/types.js';

package/src/sdk/converters/typedoc.ts

@@ -1,8 +1,9 @@
+import type { SdkSymbolKind } from '@mintlify/models';
 import fse from 'fs-extra';
 import path from 'node:path';
 
 import { markdownToMdx } from '../convert.js';
-import type { SdkNavGroup, SdkPage, SdkReference } from '../types.js';
+import type { SdkNavGroup, SdkPage, SdkPageTarget, SdkReference } from '../types.js';
 
 const KIND = {
   project: 1,
@@ -69,13 +70,37 @@ type TypedocNode = {
   inheritedFrom?: { name: string };
 };
 
-const SECTIONS: { kind: number; group: string; dir: string; tag: string }[] = [
-  { kind: KIND.class, group: 'Classes', dir: 'classes', tag: 'CLASS' },
-  { kind: KIND.interface, group: 'Interfaces', dir: 'interfaces', tag: 'INTERFACE' },
-  { kind: KIND.enum, group: 'Enumerations', dir: 'enums', tag: 'ENUM' },
-  { kind: KIND.function, group: 'Functions', dir: 'functions', tag: 'FUNCTION' },
-  { kind: KIND.typeAlias, group: 'Type Aliases', dir: 'types', tag: 'TYPE' },
-  { kind: KIND.variable, group: 'Variables', dir: 'variables', tag: 'VARIABLE' },
+const SECTIONS: {
+  kind: number;
+  group: string;
+  dir: string;
+  tag: string;
+  symbolKind: SdkSymbolKind;
+}[] = [
+  { kind: KIND.class, group: 'Classes', dir: 'classes', tag: 'CLASS', symbolKind: 'class' },
+  {
+    kind: KIND.interface,
+    group: 'Interfaces',
+    dir: 'interfaces',
+    tag: 'INTERFACE',
+    symbolKind: 'interface',
+  },
+  { kind: KIND.enum, group: 'Enumerations', dir: 'enums', tag: 'ENUM', symbolKind: 'enum' },
+  {
+    kind: KIND.function,
+    group: 'Functions',
+    dir: 'functions',
+    tag: 'FUNCTION',
+    symbolKind: 'function',
+  },
+  { kind: KIND.typeAlias, group: 'Type Aliases', dir: 'types', tag: 'TYPE', symbolKind: 'type' },
+  {
+    kind: KIND.variable,
+    group: 'Variables',
+    dir: 'variables',
+    tag: 'VARIABLE',
+    symbolKind: 'variable',
+  },
 ];
 
 export async function convertTypedoc(sourcePath: string): Promise<SdkReference> {
@@ -115,6 +140,18 @@ export async function convertTypedoc(sourcePath: string): Promise<SdkReference>
         renderer.renderPage(entry.node, section, qualifiedName(entry))
       );
       pages.push(...sectionPages);
+      for (const entry of entries) {
+        if (entry.node.kind !== KIND.class && entry.node.kind !== KIND.interface) continue;
+        const parentSlug =
+          slugById.get(entry.node.id) ??
+          path.posix.join(
+            multiModule ? slugify(module.name) : '',
+            ...entry.namespacePath.map(slugify),
+            section.dir,
+            slugify(entry.node.name)
+          );
+        pages.push(...renderer.renderMemberPages(entry.node, parentSlug, qualifiedName(entry)));
+      }
       groups.push({ group: `${prefix}${section.group}`, pages: sectionPages.map((p) => p.slug) });
     }
   }
@@ -147,7 +184,11 @@ function slugify(name: string): string {
 class TypedocRenderer {
   constructor(private slugById: Map<number, string>) {}
 
-  renderPage(node: TypedocNode, section: { dir: string; tag: string }, title?: string): SdkPage {
+  renderPage(
+    node: TypedocNode,
+    section: { dir: string; tag: string; symbolKind: SdkSymbolKind },
+    title?: string
+  ): SdkPage {
     const slug = this.slugById.get(node.id) ?? path.posix.join(section.dir, slugify(node.name));
     const lines: string[] = [];
     const summary = this.comment(node.comment);
@@ -174,15 +215,55 @@ class TypedocRenderer {
         break;
     }
 
+    const target: SdkPageTarget = {
+      kind: section.symbolKind,
+      name: node.name,
+    };
+
     return {
       slug,
       title: title ?? node.name,
       description: this.firstSentence(node.comment),
       tag: section.tag,
       content: lines.filter(Boolean).join('\n\n'),
+      target,
     };
   }
 
+  renderMemberPages(parent: TypedocNode, parentSlug: string, parentTitle: string): SdkPage[] {
+    const members = (parent.children ?? []).filter((child) => !child.flags?.isPrivate);
+    const pages: SdkPage[] = [];
+
+    for (const property of members.filter(
+      (child) => child.kind === KIND.property || child.kind === KIND.accessor
+    )) {
+      const type = property.kind === KIND.accessor ? property.getSignature?.type : property.type;
+      const optional = property.flags?.isOptional === true;
+      const summary = this.comment(property.comment ?? property.getSignature?.comment);
+      pages.push({
+        slug: path.posix.join(parentSlug, slugify(property.name)),
+        title: `${parentTitle}.${property.name}`,
+        description: this.firstSentence(property.comment ?? property.getSignature?.comment),
+        tag: 'PROPERTY',
+        content: this.responseField(property.name, this.type(type), optional, summary),
+        target: { kind: 'property', name: property.name, parent: parent.name },
+      });
+    }
+
+    for (const method of members.filter((child) => child.kind === KIND.method)) {
+      pages.push({
+        slug: path.posix.join(parentSlug, slugify(method.name)),
+        title: `${parentTitle}.${method.name}`,
+        description: this.firstSentence(method.comment ?? method.signatures?.[0]?.comment),
+        tag: 'METHOD',
+        content: this.renderSignatures(method, 2).filter(Boolean).join('\n\n'),
+        target: { kind: 'method', name: method.name, parent: parent.name },
+      });
+    }
+
+    return pages;
+  }
+
   private renderClassLike(node: TypedocNode): string[] {
     const lines: string[] = [];
     const heritage = [

package/src/sdk/findSdkPage.ts

@@ -0,0 +1,69 @@
+import type { ResolvedSdkTarget, SdkSymbolKind } from '@mintlify/models';
+
+import type { SdkPage, SdkPageTarget, SdkReference } from './types.js';
+
+const KIND_DIRS: Record<SdkSymbolKind, string> = {
+  class: 'classes',
+  interface: 'interfaces',
+  enum: 'enums',
+  function: 'functions',
+  type: 'types',
+  variable: 'variables',
+  method: 'methods',
+  property: 'properties',
+};
+
+export function matchesSdkPageTarget(
+  pageTarget: SdkPageTarget | undefined,
+  target: Pick<ResolvedSdkTarget, 'kind' | 'name' | 'parent'>
+): boolean {
+  if (!pageTarget) return false;
+  if (pageTarget.kind !== target.kind || pageTarget.name !== target.name) return false;
+  if (target.parent) return pageTarget.parent === target.parent;
+  return pageTarget.parent === undefined;
+}
+
+function matchesSdkPageHeuristic(
+  page: SdkPage,
+  target: Pick<ResolvedSdkTarget, 'kind' | 'name' | 'parent'>
+): boolean {
+  if (target.parent) {
+    return (
+      page.title === `${target.parent}.${target.name}` ||
+      page.slug.endsWith(`/${slugify(target.parent)}/${slugify(target.name)}`)
+    );
+  }
+  // Only slug matches encode the symbol kind; a bare title match could return
+  // a same-named symbol of a different kind.
+  const dir = KIND_DIRS[target.kind];
+  return (
+    page.slug === `${dir}/${slugify(target.name)}` ||
+    page.slug.endsWith(`/${dir}/${slugify(target.name)}`)
+  );
+}
+
+function slugify(name: string): string {
+  return name.replace(/[^a-zA-Z0-9-_.]+/g, '-').replace(/^-+|-+$/g, '') || 'item';
+}
+
+export function findSdkPage(
+  reference: SdkReference,
+  target: Pick<ResolvedSdkTarget, 'kind' | 'name' | 'parent'>
+): SdkPage | undefined {
+  return (
+    reference.pages.find((page) => matchesSdkPageTarget(page.target, target)) ??
+    reference.pages.find((page) => matchesSdkPageHeuristic(page, target))
+  );
+}
+
+export function renderSdkTarget(
+  reference: SdkReference,
+  target: Pick<ResolvedSdkTarget, 'kind' | 'name' | 'parent'>
+): SdkPage {
+  const page = findSdkPage(reference, target);
+  if (!page) {
+    const qualified = target.parent ? `${target.parent}.${target.name}` : target.name;
+    throw new Error(`SDK symbol not found: ${target.kind} ${qualified}`);
+  }
+  return page;
+}

package/src/sdk/types.ts

@@ -1,7 +1,14 @@
+import type { SdkSymbolKind } from '@mintlify/models';
 import type { SdkFormat } from '@mintlify/validation';
 
 export type { SdkFormat };
 
+export type SdkPageTarget = {
+  kind: SdkSymbolKind;
+  name: string;
+  parent?: string;
+};
+
 export type SdkPage = {
   slug: string;
   title: string;
@@ -9,6 +16,7 @@ export type SdkPage = {
   tag?: string;
   icon?: string;
   content: string;
+  target?: SdkPageTarget;
 };
 
 export type SdkNavGroup = {