├── .yarnrc.yml
├── src
    ├── lib
    │   ├── types.ts
    │   └── index.ts
    ├── plugin
    │   ├── theme.ts
    │   ├── context
    │   │   ├── index.ts
    │   │   ├── mixins
    │   │   │   ├── project.tsx
    │   │   │   ├── comment.tsx
    │   │   │   ├── container.tsx
    │   │   │   ├── navigation.tsx
    │   │   │   ├── layout.tsx
    │   │   │   └── members.tsx
    │   │   ├── base.tsx
    │   │   └── utils.tsx
    │   ├── utils.ts
    │   └── index.ts
    └── assets
    │   ├── data.ts
    │   ├── style.css
    │   └── index.ts
├── README.md
├── example
    ├── tsconfig.json
    ├── typedoc.json
    └── README.md
├── tsconfig.json
├── .gitignore
├── dprint.json
├── LICENSE
├── package.json
├── rollup.config.js
└── scripts
    └── download-assets.js


/.yarnrc.yml:
--------------------------------------------------------------------------------
1 | nodeLinker: node-modules
2 | 


--------------------------------------------------------------------------------
/src/lib/types.ts:
--------------------------------------------------------------------------------
1 | export type SearchItem = {
2 |   id: number;
3 |   name: string;
4 |   comment: string;
5 |   kind: number;
6 |   parent: string;
7 |   url: string;
8 | };
9 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # typedoc-theme-oxide
2 | 
3 | A TypeDoc theme looks just like [rustdoc](https://doc.rust-lang.org/stable/std/).
4 | 
5 | ## Example
6 | 
7 | https://balthild.github.io/typedoc-theme-oxide
8 | 


--------------------------------------------------------------------------------
/example/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"compilerOptions": {
3 | 		"module": "CommonJS",
4 | 		"skipLibCheck": true,
5 | 	},
6 | 	"include": ["../node_modules/monaco-editor/esm/vs/editor/editor.api.d.ts"],
7 | 	"exclude": ["theme"],
8 | }
9 | 


--------------------------------------------------------------------------------
/example/typedoc.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"entryPoints": ["../node_modules/monaco-editor/esm/vs/editor/editor.api.d.ts"],
 3 | 	"out": "./docs",
 4 | 	"plugin": ["../dist/plugin/index.js"],
 5 | 	"theme": "oxide",
 6 | 	"name": "Monaco Editor",
 7 | 	"readme": "./README.md",
 8 | 	"includeVersion": true,
 9 | 	"typePrintWidth": 60
10 | }
11 | 


--------------------------------------------------------------------------------
/src/plugin/theme.ts:
--------------------------------------------------------------------------------
 1 | import { DefaultTheme, PageEvent, Reflection } from 'typedoc';
 2 | 
 3 | import { OxideContext } from './context';
 4 | 
 5 | export class OxideTheme extends DefaultTheme {
 6 |   getRenderContext(page: PageEvent<Reflection>) {
 7 |     return new OxideContext(this.router, this, page, this.application.options);
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/example/README.md:
--------------------------------------------------------------------------------
1 | # TypeDoc Example
2 | 
3 | This is an example of [typedoc-theme-oxide](https://github.com/balthild/typedoc-theme-oxide).
4 | 
5 | The content of the example documentation is generated from the `d.ts` file of [monaco-editor](https://github.com/microsoft/monaco-editor). However, it is not intended to serve as a documentation. Please refer to https://microsoft.github.io/monaco-editor/ if you want to read the API documentation of monaco-editor.
6 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "include": ["src"],
 3 |   "compilerOptions": {
 4 |     "target": "es2022",
 5 |     "module": "preserve",
 6 |     "moduleResolution": "bundler",
 7 |     "esModuleInterop": true,
 8 |     "skipLibCheck": true,
 9 |     "forceConsistentCasingInFileNames": true,
10 |     "strict": true,
11 |     "sourceMap": true,
12 |     "preserveWatchOutput": true,
13 | 
14 |     "jsx": "react",
15 |     "jsxFactory": "JSX.createElement",
16 |     "jsxFragmentFactory": "JSX.Fragment",
17 |   },
18 | }
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | yarn-debug.log*
 6 | yarn-error.log*
 7 | lerna-debug.log*
 8 | 
 9 | # Diagnostic reports (https://nodejs.org/api/report.html)
10 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
11 | 
12 | # Compiled output
13 | dist
14 | docs
15 | assets/dist
16 | assets/rustdoc
17 | 
18 | # Dependency directories
19 | node_modules/
20 | .pnp.*
21 | .yarn/*
22 | !.yarn/patches
23 | !.yarn/plugins
24 | !.yarn/releases
25 | !.yarn/sdks
26 | !.yarn/versions
27 | 
28 | # Output of 'npm pack'
29 | *.tgz
30 | 


--------------------------------------------------------------------------------
/src/plugin/context/index.ts:
--------------------------------------------------------------------------------
 1 | import { OxideContextBase } from './base';
 2 | import { CommentMixin } from './mixins/comment';
 3 | import { ContainerMixin } from './mixins/container';
 4 | import { LayoutMixin } from './mixins/layout';
 5 | import { MembersMixin } from './mixins/members';
 6 | import { NavigationMixin } from './mixins/navigation';
 7 | import { ProjectMixin } from './mixins/project';
 8 | 
 9 | const mixins = [
10 |   LayoutMixin,
11 | 
12 |   // Pages
13 |   ProjectMixin,
14 |   ContainerMixin,
15 | 
16 |   // Partials
17 |   NavigationMixin,
18 |   CommentMixin,
19 |   MembersMixin,
20 | ];
21 | 
22 | let OxideContext = OxideContextBase;
23 | for (const mixin of mixins) {
24 |   OxideContext = mixin(OxideContext) as any;
25 | }
26 | 
27 | export { OxideContext };
28 | 


--------------------------------------------------------------------------------
/src/assets/data.ts:
--------------------------------------------------------------------------------
 1 | import { ReflectionKind } from 'typedoc/models';
 2 | import { createSearchDocument } from '../lib';
 3 | 
 4 | export async function loadDeflateData<T = any>(url: string) {
 5 |   const response = await fetch(url);
 6 |   const blob = await response.blob();
 7 |   const stream = blob.stream().pipeThrough(new DecompressionStream('deflate'));
 8 |   return await new Response(stream).json() as T;
 9 | }
10 | 
11 | export async function loadSearchIndex() {
12 |   const index = createSearchDocument();
13 | 
14 |   const base = `${document.documentElement.dataset.base}assets/oxide`;
15 |   const parts = await loadDeflateData(`${base}/search-index.deflate`);
16 |   for (const [key, data] of Object.entries(parts)) {
17 |     index.import(key, data as any);
18 |   }
19 | 
20 |   return index;
21 | }
22 | 
23 | export function getReflectionKindName(kind: ReflectionKind) {
24 |   return ReflectionKind.classString(kind)
25 |     .replace('tsd-kind-', '')
26 |     .replace('-', ' ');
27 | }
28 | 


--------------------------------------------------------------------------------
/dprint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "includes": [
 3 |     "scripts/*.js",
 4 |     "src/**/*.{ts,tsx,css}",
 5 |     "rollup.config.js",
 6 |   ],
 7 |   "excludes": [
 8 |     "**/node_modules",
 9 |     "**/*-lock.json",
10 |     "./example"
11 |   ],
12 |   "imporg": {},
13 |   "typescript": {
14 |     "indentWidth": 2,
15 |     "lineWidth": 120,
16 |     "semiColons": "always",
17 |     "quoteStyle": "preferSingle",
18 |     "jsx.quoteStyle": "preferDouble",
19 |     "quoteProps": "consistent",
20 |     "arrowFunction.useParentheses": "force",
21 |     "functionExpression.spaceBeforeParentheses": true,
22 |     "jsxOpeningElement.bracketPosition": "sameLine",
23 |     "jsxSelfClosingElement.bracketPosition": "nextLine"
24 |   },
25 |   "malva": {
26 |     "indentWidth": 2,
27 |     "printWidth": 120,
28 |     "quotes": "preferSingle",
29 |   },
30 |   "plugins": [
31 |     "https://plugins.dprint.dev/balthild/imporg-0.1.8.wasm",
32 |     "https://plugins.dprint.dev/typescript-0.93.0.wasm",
33 |     "https://plugins.dprint.dev/g-plane/malva-v0.10.1.wasm",
34 |   ],
35 | }
36 | 


--------------------------------------------------------------------------------
/src/plugin/utils.ts:
--------------------------------------------------------------------------------
 1 | import { Comment } from 'typedoc';
 2 | import { ReflectionWithLink } from './context/utils';
 3 | 
 4 | export function renderTextComment(item: ReflectionWithLink) {
 5 |   const comments: Comment[] = [];
 6 | 
 7 |   if (item.comment) {
 8 |     comments.push(item.comment);
 9 |   }
10 | 
11 |   if (item.isDocument()) {
12 |     comments.push(new Comment(item.content));
13 |   }
14 | 
15 |   if (item.isDeclaration()) {
16 |     const signatures = [
17 |       ...item.signatures ?? [],
18 |       item.getSignature,
19 |       item.setSignature,
20 |     ];
21 | 
22 |     for (const signature of signatures) {
23 |       if (signature?.comment) {
24 |         comments.push(signature.comment);
25 |       }
26 |     }
27 |   }
28 | 
29 |   if (!comments.length) {
30 |     return '';
31 |   }
32 | 
33 |   return comments
34 |     .flatMap((comment) => {
35 |       return [
36 |         ...comment.summary,
37 |         ...comment.blockTags.flatMap((tag) => tag.content),
38 |       ];
39 |     })
40 |     .map((part) => part.text)
41 |     .join('\n');
42 | }
43 | 


--------------------------------------------------------------------------------
/src/lib/index.ts:
--------------------------------------------------------------------------------
 1 | import { Charset, Document, Encoder } from 'flexsearch';
 2 | 
 3 | import { SearchItem } from './types';
 4 | 
 5 | export function createSearchDocument() {
 6 |   return new Document<SearchItem>({
 7 |     document: {
 8 |       id: 'id',
 9 |       store: true,
10 |       index: [
11 |         {
12 |           field: 'name',
13 |           tokenize: 'bidirectional',
14 |           priority: 9,
15 |           encoder: new Encoder(Charset.LatinBalance).assign({
16 |             normalize(text) {
17 |               // split the names in camel case
18 |               let words = text.replace(/\d+/g, ' ').split(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/);
19 |               if (words.length > 1) {
20 |                 words.push(text);
21 |               }
22 |               return words.join(' ').toLowerCase();
23 |             },
24 |           }),
25 |         },
26 |         {
27 |           field: 'comment',
28 |           tokenize: 'default',
29 |           encoder: Charset.LatinSoundex,
30 |         },
31 |       ],
32 |       tag: [],
33 |     },
34 |   });
35 | }
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Balthild
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/plugin/context/mixins/project.tsx:
--------------------------------------------------------------------------------
 1 | import { JSX, PageEvent, ProjectReflection, ReflectionKind } from 'typedoc';
 2 | 
 3 | import { OxideContextBase } from '../base';
 4 | 
 5 | export const ProjectMixin = (base: typeof OxideContextBase) =>
 6 |   class extends base {
 7 |     indexTemplate = (page: PageEvent<ProjectReflection>) => {
 8 |       const { model, project } = page;
 9 | 
10 |       return (
11 |         <>
12 |           <div class="main-heading">
13 |             <h1>
14 |               {ReflectionKind.singularString(model.kind)} <span>{project.name}</span>
15 |               <button id="copy-path" title="Copy item path to clipboard">Copy item path</button>
16 |             </h1>
17 |             <rustdoc-toolbar />
18 |           </div>
19 | 
20 |           <details class="toggle top-doc" open>
21 |             <summary class="hideme">
22 |               <span>Expand description</span>
23 |             </summary>
24 |             <div class="docblock">
25 |               <JSX.Raw html={this.markdown(page.model.readme)} />
26 |             </div>
27 |           </details>
28 | 
29 |           {this.members(model)}
30 |         </>
31 |       );
32 |     };
33 |   };
34 | 


--------------------------------------------------------------------------------
/src/plugin/context/base.tsx:
--------------------------------------------------------------------------------
 1 | import { DefaultTheme, DefaultThemeRenderContext, Options, PageEvent, Reflection, Router } from 'typedoc';
 2 | 
 3 | import { itemLink, itemSlug, ReflectionSection, ReflectionWithLink, sectionSlug, transformTypography } from './utils';
 4 | 
 5 | export class OxideContextBase extends DefaultThemeRenderContext {
 6 |   constructor(router: Router, theme: DefaultTheme, page: PageEvent<Reflection>, options: Options) {
 7 |     super(router, theme, page, options);
 8 | 
 9 |     const markdown = this.markdown;
10 |     this.markdown = (text) => transformTypography(markdown(text) ?? '');
11 |   }
12 | 
13 |   protected sectionSlug(section: ReflectionSection) {
14 |     return sectionSlug(section);
15 |   }
16 | 
17 |   protected itemSlug(item: ReflectionWithLink) {
18 |     return itemSlug(item);
19 |   }
20 | 
21 |   protected itemLink(item: ReflectionWithLink, forceNested: boolean) {
22 |     return itemLink(this, item, forceNested);
23 |   }
24 | 
25 |   protected itemSourceLink(item: Reflection) {
26 |     if (!item.isDeclaration() && !item.isSignature()) {
27 |       return;
28 |     }
29 | 
30 |     return item.sources?.map((src) => src.url).find((url) => url);
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/plugin/context/mixins/comment.tsx:
--------------------------------------------------------------------------------
 1 | import { JSX, Reflection, ReflectionKind } from 'typedoc';
 2 | 
 3 | import { OxideContextBase } from '../base';
 4 | 
 5 | export const CommentMixin = (base: typeof OxideContextBase) =>
 6 |   class extends base {
 7 |     commentTags = (model: Reflection) => {
 8 |       if (!model.comment) {
 9 |         return;
10 |       }
11 | 
12 |       const skipped = this.options.getValue('notRenderedTags');
13 |       if (model.kindOf(ReflectionKind.SomeSignature)) {
14 |         skipped.push('@returns');
15 |       }
16 | 
17 |       const tags = model.comment.blockTags
18 |         .filter((tag) => !tag.skipRendering)
19 |         .filter((tag) => !skipped.includes(tag.tag));
20 | 
21 |       return (
22 |         <>
23 |           {this.hook('comment.beforeTags', this, model.comment, model)}
24 | 
25 |           <div class="item-table comment-tags">
26 |             {tags.map((tag) => (
27 |               <>
28 |                 <dt>
29 |                   <span class="stab" title={tag.name}>{tag.name ?? tag.tag.replace('@', '')}</span>
30 |                 </dt>
31 |                 <dd>
32 |                   <JSX.Raw html={this.markdown(tag.content)} />
33 |                 </dd>
34 |               </>
35 |             ))}
36 |           </div>
37 | 
38 |           {this.hook('comment.afterTags', this, model.comment, model)}
39 |         </>
40 |       );
41 |     };
42 |   };
43 | 


--------------------------------------------------------------------------------
/src/assets/style.css:
--------------------------------------------------------------------------------
 1 | body.rustdoc {
 2 |   --code-background: var(--code-block-background-color);
 3 | }
 4 | 
 5 | .sidebar-elems .block li.parent-module a {
 6 |   letter-spacing: 0.1em;
 7 | }
 8 | 
 9 | :target {
10 |   display: block;
11 | }
12 | 
13 | a.token, span.token {
14 |   color: var(--main-color);
15 | }
16 | 
17 | .tsd-anchor-icon {
18 |   display: none;
19 | }
20 | 
21 | .impl-items > .toggle > summary + .docblock:empty {
22 |   margin-bottom: -0.75em;
23 | }
24 | 
25 | .structfield {
26 |   --code-background: none;
27 | }
28 | 
29 | .docblock {
30 |   :last-child {
31 |     margin-bottom: 0;
32 |   }
33 | 
34 |   pre > button {
35 |     display: none;
36 |   }
37 | }
38 | 
39 | .item-table.comment-tags {
40 |   grid-template-columns: auto 1fr;
41 | 
42 |   .stab {
43 |     padding: 1px 5px;
44 |   }
45 | }
46 | 
47 | rustdoc-toolbar #help-button {
48 |   .shortcuts {
49 |     width: 100%;
50 |   }
51 | 
52 |   .infos, .top, .bottom {
53 |     display: none;
54 |   }
55 | }
56 | 
57 | oxide-search-results .search-results.active {
58 |   display: grid;
59 |   grid-template-columns: min-content 1fr;
60 | 
61 |   > .result-item {
62 |     display: grid;
63 |     grid-template-areas: none;
64 |     grid-template-columns: subgrid;
65 |     grid-column: 1 / 3;
66 | 
67 |     .result-name {
68 |       display: grid;
69 |       grid-template-columns: subgrid;
70 |       grid-column: 1 / 3;
71 |       /* align-items: initial; */
72 | 
73 |       .typename {
74 |         grid-column: 1 / 2;
75 |         width: auto;
76 |         white-space: nowrap;
77 |         /* line-height: 1.5rem; */
78 |       }
79 | 
80 |       .path {
81 |         grid-column: 2 / 3;
82 | 
83 |         span {
84 |           display: inline-block;
85 |         }
86 |       }
87 |     }
88 |   }
89 | }
90 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "typedoc-theme-oxide",
 3 |   "version": "0.2.0",
 4 |   "description": "A TypeDoc theme looks just like rustdoc.",
 5 |   "repository": "github:balthild/typedoc-theme-oxide",
 6 |   "author": "Balthild <ibalthild@gmail.com>",
 7 |   "license": "MIT",
 8 |   "keywords": [
 9 |     "rustdoc",
10 |     "typedoc",
11 |     "typedoc-theme",
12 |     "typescript"
13 |   ],
14 |   "scripts": {
15 |     "dev": "rollup -c -w",
16 |     "build": "rollup -c",
17 |     "clean": "rm -rf dist example/docs",
18 |     "download": "node scripts/download-assets.js",
19 |     "example:build": "cd example && typedoc --options ./typedoc.json",
20 |     "example:deploy": "yarn build && yarn example:build && gh-pages -d ./example/docs",
21 |     "release": "release-it"
22 |   },
23 |   "packageManager": "yarn@4.9.1",
24 |   "type": "module",
25 |   "main": "dist/plugin/index.js",
26 |   "files": [
27 |     "dist"
28 |   ],
29 |   "dependencies": {
30 |     "cheerio": "^1.0.0",
31 |     "flexsearch": "^0.8.164",
32 |     "slug": "^10.0.0"
33 |   },
34 |   "devDependencies": {
35 |     "@rollup/plugin-node-resolve": "^16.0.1",
36 |     "@rollup/plugin-terser": "^0.4.4",
37 |     "@rollup/plugin-typescript": "^12.1.2",
38 |     "@types/lodash-es": "^4.17.12",
39 |     "@types/node": "^22.15.17",
40 |     "@types/slug": "^5.0.9",
41 |     "clean-css": "^5.3.3",
42 |     "gh-pages": "^6.3.0",
43 |     "http-server": "^14.1.1",
44 |     "lit": "^3.3.0",
45 |     "lodash-es": "^4.17.21",
46 |     "monaco-editor": "^0.52.2",
47 |     "postcss": "^8.5.3",
48 |     "postcss-nested": "^7.0.2",
49 |     "release-it": "^19.0.2",
50 |     "rollup": "^4.40.2",
51 |     "rollup-plugin-postcss": "^4.0.2",
52 |     "terser": "^5.39.0",
53 |     "tslib": "^2.8.1",
54 |     "typedoc": "^0.28.4",
55 |     "typescript": "^5.8.3",
56 |     "undici": "^7.9.0"
57 |   },
58 |   "peerDependencies": {
59 |     "typedoc": "^0.28.4"
60 |   }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/plugin/context/mixins/container.tsx:
--------------------------------------------------------------------------------
 1 | import { ContainerReflection, JSX, PageEvent, Reflection, ReflectionKind } from 'typedoc';
 2 | 
 3 | import { OxideContextBase } from '../base';
 4 | import { join } from '../utils';
 5 | 
 6 | export const ContainerMixin = (base: typeof OxideContextBase) =>
 7 |   class extends base {
 8 |     reflectionTemplate = (page: PageEvent<ContainerReflection>) => {
 9 |       const { model } = page;
10 | 
11 |       return (
12 |         <>
13 |           <div class="main-heading">
14 |             <div class="rustdoc-breadcrumbs">
15 |               {this.#breadcrumbs(page.model.parent)}
16 |             </div>
17 | 
18 |             <h1>
19 |               {ReflectionKind.singularString(model.kind) + ' '}
20 |               <span>{model.name}</span>
21 |               {this.#generics(model)}
22 | 
23 |               <button id="copy-path" title="Copy item path to clipboard">Copy item path</button>
24 |             </h1>
25 | 
26 |             <rustdoc-toolbar />
27 | 
28 |             {this.#source(model)}
29 |           </div>
30 | 
31 |           {model.hasComment() && (
32 |             <details class="toggle top-doc" open>
33 |               <summary class="hideme">
34 |                 <span>Expand description</span>
35 |               </summary>
36 |               <div class="docblock">
37 |                 {this.commentSummary(model)}
38 |                 {this.commentTags(model)}
39 |               </div>
40 |             </details>
41 |           )}
42 | 
43 |           {this.members(model)}
44 |         </>
45 |       );
46 |     };
47 | 
48 |     #breadcrumbs(model?: Reflection): JSX.Children[] {
49 |       if (!model || model.isProject()) {
50 |         return [];
51 |       }
52 | 
53 |       if (model.kindOf(ReflectionKind.SomeSignature)) {
54 |         return this.#breadcrumbs(model.parent);
55 |       }
56 | 
57 |       const trail = [
58 |         ...this.#breadcrumbs(model.parent),
59 |         <a href={this.urlTo(model)}>{model.name}</a>,
60 |       ];
61 | 
62 |       return join(['.', <wbr />], trail);
63 |     }
64 | 
65 |     #generics(model: Reflection) {
66 |       if (!model.isDeclaration() && !model.isSignature()) {
67 |         return;
68 |       }
69 | 
70 |       if (!model.typeParameters) {
71 |         return;
72 |       }
73 | 
74 |       return ['<', join(', ', model.typeParameters.map((x) => x.name)), '>'];
75 |     }
76 | 
77 |     #source(model: Reflection) {
78 |       const url = this.itemSourceLink(model);
79 |       if (!url) {
80 |         return;
81 |       }
82 | 
83 |       return (
84 |         <span class="sub-heading">
85 |           <a class="src" href={url}>Source</a>
86 |         </span>
87 |       );
88 |     }
89 |   };
90 | 


--------------------------------------------------------------------------------
/src/plugin/index.ts:
--------------------------------------------------------------------------------
 1 | import * as fs from 'fs/promises';
 2 | import * as path from 'path';
 3 | import { promisify } from 'util';
 4 | import { deflate } from 'zlib';
 5 | 
 6 | import { Application, Reflection, RendererEvent } from 'typedoc';
 7 | 
 8 | import { createSearchDocument } from '../lib';
 9 | import { itemLink } from './context/utils';
10 | import { OxideTheme } from './theme';
11 | import { renderTextComment } from './utils';
12 | 
13 | declare module 'typedoc' {
14 |   namespace JSX.JSX {
15 |     interface IntrinsicElements {
16 |       'rustdoc-search': IntrinsicAttributes;
17 |       'rustdoc-toolbar': IntrinsicAttributes;
18 |       'oxide-search-results': IntrinsicAttributes;
19 |     }
20 | 
21 |     interface IntrinsicAttributes {
22 |       onclick?: string;
23 |     }
24 |   }
25 | }
26 | 
27 | /**
28 |  * Called by TypeDoc when loading this theme as a plugin. Should be used to define themes which
29 |  * can be selected by the user.
30 |  */
31 | export function load(app: Application) {
32 |   app.renderer.defineTheme('oxide', OxideTheme);
33 | 
34 |   app.renderer.preRenderAsyncJobs.push(async (event: RendererEvent) => {
35 |     const document = createSearchDocument();
36 | 
37 |     app.renderer.router!.getLinkTargets()
38 |       .filter((x) => x instanceof Reflection)
39 |       .filter((x) => x.isDeclaration() || x.isDocument())
40 |       .filter((x) => x.name && !x.flags.isExternal)
41 |       .forEach((item) => {
42 |         try {
43 |           document.add({
44 |             id: item.id,
45 |             name: item.name,
46 |             comment: renderTextComment(item),
47 |             kind: item.kind,
48 |             parent: item.parent?.isProject() ? '' : item.parent?.getFriendlyFullName() ?? '',
49 |             url: itemLink(app.renderer.router!, item, false),
50 |           });
51 |         } catch {}
52 |       });
53 | 
54 |     const parts: Record<string, any> = {};
55 |     await document.export(async (key, data) => {
56 |       app.logger.info(`Search index part: ${key}`);
57 |       parts[key] = JSON.parse(data);
58 |     });
59 | 
60 |     const buffer = await promisify(deflate)(Buffer.from(JSON.stringify(parts)));
61 | 
62 |     const dest = path.join(event.outputDirectory, 'assets', 'oxide');
63 |     await fs.mkdir(dest, { recursive: true });
64 |     await fs.writeFile(path.join(dest, 'search-index.deflate'), buffer);
65 |   });
66 | 
67 |   app.renderer.postRenderAsyncJobs.push(async (event: RendererEvent) => {
68 |     const src = path.join(import.meta.dirname, '..', 'assets');
69 |     const dest = path.join(event.outputDirectory, 'assets', 'oxide');
70 | 
71 |     try {
72 |       await fs.access(src, fs.constants.F_OK);
73 |       await fs.access(path.join(src, 'rustdoc'), fs.constants.F_OK);
74 |       await fs.mkdir(dest, { recursive: true });
75 |       await fs.cp(src, dest, { recursive: true });
76 |     } catch (e) {
77 |       console.log(e);
78 |       app.logger.error('Some front-end assets are missing.');
79 |       app.logger.error('User of the oxide theme should not see this, or I must did something silly.');
80 |     }
81 |   });
82 | }
83 | 


--------------------------------------------------------------------------------
/rollup.config.js:
--------------------------------------------------------------------------------
  1 | import { spawn } from 'child_process';
  2 | import * as fs from 'fs/promises';
  3 | 
  4 | import resolve from '@rollup/plugin-node-resolve';
  5 | import terser from '@rollup/plugin-terser';
  6 | import typescript from '@rollup/plugin-typescript';
  7 | import { createServer } from 'http-server';
  8 | import nested from 'postcss-nested';
  9 | import { defineConfig } from 'rollup';
 10 | import postcss from 'rollup-plugin-postcss';
 11 | 
 12 | export default defineConfig((args) => [
 13 |   // TypeDoc plugin
 14 |   {
 15 |     plugins: [
 16 |       typescript(),
 17 |       resolve({ extensions: ['.ts', '.tsx', '.json', '.node'] }),
 18 |       args.watch && typedocExampleBuild(),
 19 |     ],
 20 |     input: 'src/plugin/index.ts',
 21 |     external: /(node_modules)/,
 22 |     watch: {
 23 |       clearScreen: false,
 24 |     },
 25 |     output: {
 26 |       dir: 'dist/plugin',
 27 |       format: 'esm',
 28 |       sourcemap: true,
 29 |       interop: 'auto',
 30 |       preserveModules: true,
 31 |       preserveModulesRoot: 'src/plugin',
 32 |     },
 33 |   },
 34 | 
 35 |   // Frontend assets
 36 |   {
 37 |     plugins: [
 38 |       typescript(),
 39 |       resolve({ extensions: ['.ts', '.tsx', '.json', '.node'] }),
 40 |       postcss({ extract: true, minimize: !args.watch, sourceMap: true, plugins: [nested()] }),
 41 |       !args.watch && terser(),
 42 |       args.watch && typedocExampleCopyAssets(),
 43 |     ],
 44 |     input: 'src/assets/index.ts',
 45 |     context: 'globalThis',
 46 |     watch: {
 47 |       clearScreen: false,
 48 |     },
 49 |     output: {
 50 |       dir: 'dist/assets',
 51 |       format: 'iife',
 52 |       interop: 'auto',
 53 |       sourcemap: true,
 54 |     },
 55 |   },
 56 | ]);
 57 | 
 58 | /** @returns {import('rollup').Plugin} */
 59 | function typedocExampleBuild() {
 60 |   return {
 61 |     name: 'typedoc-example-build',
 62 |     async writeBundle() {
 63 |       const child = spawn('yarn', ['run', 'example:build'], {
 64 |         cwd: import.meta.dirname,
 65 |         stdio: 'inherit',
 66 |       });
 67 |       await new Promise((resolve, reject) => {
 68 |         child.once('exit', resolve);
 69 |         child.once('error', reject);
 70 |       });
 71 | 
 72 |       startServer();
 73 |     },
 74 |   };
 75 | }
 76 | 
 77 | /** @returns {import('rollup').Plugin} */
 78 | function typedocExampleCopyAssets() {
 79 |   return {
 80 |     name: 'typedoc-example-copy-assets',
 81 |     async writeBundle() {
 82 |       const src = './dist/assets';
 83 |       const dest = './example/docs/assets/oxide';
 84 | 
 85 |       try {
 86 |         await fs.access(`${src}/rustdoc`, fs.constants.F_OK);
 87 |         await fs.cp(src, dest, { recursive: true });
 88 |       } catch {
 89 |         this.warn('Rustdoc front-end assets are missing.');
 90 |         this.warn('Please run `yarn download`.');
 91 |       }
 92 | 
 93 |       startServer();
 94 |     },
 95 |   };
 96 | }
 97 | 
 98 | function startServer() {
 99 |   if (!globalThis.httpServer) {
100 |     globalThis.httpServer = createServer({ root: './example/docs' });
101 |     globalThis.httpServer.listen(3000);
102 |   }
103 | 
104 |   console.log('┌──────────────────────────────────────────┐');
105 |   console.log('│ Serving example on http://localhost:3000 │');
106 |   console.log('└──────────────────────────────────────────┘');
107 | }
108 | 


--------------------------------------------------------------------------------
/scripts/download-assets.js:
--------------------------------------------------------------------------------
  1 | import * as fs from 'fs/promises';
  2 | import { join } from 'path';
  3 | 
  4 | import CleanCSS from 'clean-css';
  5 | import { minify } from 'terser';
  6 | import { fetch } from 'undici';
  7 | 
  8 | const urlPrefix = 'https://cdn.jsdelivr.net/gh/rust-lang/rust@1.86.0/src/librustdoc/html/static';
  9 | const destPrefix = join(import.meta.dirname, '..', 'dist', 'assets', 'rustdoc');
 10 | 
 11 | await main();
 12 | 
 13 | async function main() {
 14 |   await fs.rm(destPrefix, { recursive: true, force: true });
 15 |   await fs.mkdir(destPrefix, { recursive: true });
 16 | 
 17 |   await downloadStyle();
 18 |   await downloadMainJs();
 19 |   await downloadSettingsJs();
 20 | }
 21 | 
 22 | async function downloadStyle() {
 23 |   console.log('Downloading and processing rustdoc.css');
 24 | 
 25 |   const src = `${urlPrefix}/css/rustdoc.css`;
 26 |   const dest = join(destPrefix, 'rustdoc.css');
 27 | 
 28 |   const response = await fetch(src);
 29 |   let source = await response.text();
 30 | 
 31 |   // The hash has a fixed length of 8
 32 |   // https://github.com/rust-lang/rust/blob/1.86.0/src/librustdoc/build.rs#L49
 33 |   source = source.replace(
 34 |     /url\("([\w\d\.-]+)(-[0-9a-f]{8})(\.woff2|\.ttf\.woff2)"\)/g,
 35 |     (match, name, hash, ext) => `url("${urlPrefix}/fonts/${name}${ext}")`,
 36 |   );
 37 | 
 38 |   source = [
 39 |     `/**`,
 40 |     ` * Patched by typedoc-theme-oxide. Minified with clean-css.`,
 41 |     ` * Original file: ${src}`,
 42 |     ` */`,
 43 |     new CleanCSS().minify(source).styles,
 44 |   ].join('\n');
 45 | 
 46 |   await fs.writeFile(dest, source);
 47 | }
 48 | 
 49 | async function downloadMainJs() {
 50 |   console.log('Downloading and processing main.js');
 51 | 
 52 |   const src = `${urlPrefix}/js/main.js`;
 53 |   const dest = join(destPrefix, 'main.js');
 54 | 
 55 |   const response = await fetch(src);
 56 |   let source = await response.text();
 57 | 
 58 |   source = source.replace(
 59 |     'function sendSearchForm() {',
 60 |     'function sendSearchForm() { return;',
 61 |   );
 62 | 
 63 |   // source = source.replace(
 64 |   //   'titleElement.textContent.replace(" - Rust", "")',
 65 |   //   'titleElement.textContent.replace(/ - .+$/, "")',
 66 |   // );
 67 | 
 68 |   source = source.replace(
 69 |     'const [item, module] = document.title.split(" in ");',
 70 |     'const [item, module] = document.title.split(" - ")[0].split(" in ");',
 71 |   );
 72 | 
 73 |   source = source.replace(
 74 |     'copyContentToClipboard(path.join("::"));',
 75 |     'copyContentToClipboard(path.join("."));',
 76 |   );
 77 | 
 78 |   source = [
 79 |     `/**`,
 80 |     ` * Patched by typedoc-theme-oxide. Minified with terser.`,
 81 |     ` * Original file: ${src}`,
 82 |     ` */`,
 83 |     (await minify(source)).code,
 84 |   ].join('\n');
 85 | 
 86 |   await fs.writeFile(dest, source);
 87 | }
 88 | 
 89 | async function downloadSettingsJs() {
 90 |   console.log('Downloading and processing settings.js');
 91 | 
 92 |   const src = `${urlPrefix}/js/settings.js`;
 93 |   const dest = join(destPrefix, 'settings.js');
 94 | 
 95 |   const response = await fetch(src);
 96 |   let source = await response.text();
 97 | 
 98 |   source = [
 99 |     `/**`,
100 |     ` * Patched by typedoc-theme-oxide. Minified with terser.`,
101 |     ` * Original file: ${src}`,
102 |     ` */`,
103 |     (await minify(source)).code,
104 |   ].join('\n');
105 | 
106 |   await fs.writeFile(dest, source);
107 | }
108 | 


--------------------------------------------------------------------------------
/src/plugin/context/mixins/navigation.tsx:
--------------------------------------------------------------------------------
  1 | import {
  2 |   ContainerReflection,
  3 |   JSX,
  4 |   PageEvent,
  5 |   Reflection,
  6 |   ReflectionCategory,
  7 |   ReflectionGroup,
  8 |   ReflectionKind,
  9 | } from 'typedoc';
 10 | 
 11 | import { OxideContextBase } from '../base';
 12 | import { isNestedTable, partition, ReflectionSection, ReflectionWithLink } from '../utils';
 13 | 
 14 | export const NavigationMixin = (base: typeof OxideContextBase) =>
 15 |   class extends base {
 16 |     navigation = (page: PageEvent<Reflection>) => {
 17 |       const { model } = page;
 18 | 
 19 |       return (
 20 |         <>
 21 |           <div class="sidebar-elems">
 22 |             <ul class="block">
 23 |               <li>
 24 |                 <a href={this.urlTo(model.project)}>Exports</a>
 25 |               </li>
 26 |             </ul>
 27 | 
 28 |             {this.#modules(model)}
 29 |             {this.#sections(model)}
 30 |           </div>
 31 |         </>
 32 |       );
 33 |     };
 34 | 
 35 |     #modules(model: Reflection) {
 36 |       const parent = model.parent;
 37 |       if (parent instanceof ContainerReflection === false) {
 38 |         return;
 39 |       }
 40 | 
 41 |       const siblings = parent.getChildrenByKind(ReflectionKind.SomeModule);
 42 | 
 43 |       return (
 44 |         <section>
 45 |           <ul class="block">
 46 |             <li class="parent-module">
 47 |               <a href={this.urlTo(parent)}>..</a>
 48 |             </li>
 49 | 
 50 |             {siblings.map((sibling) => (
 51 |               <li>
 52 |                 <a
 53 |                   href={this.urlTo(sibling)}
 54 |                   class={sibling.id === model.id ? 'current' : ''}>
 55 |                   {sibling.name}
 56 |                 </a>
 57 |               </li>
 58 |             ))}
 59 |           </ul>
 60 |         </section>
 61 |       );
 62 |     }
 63 | 
 64 |     #sections(model: Reflection) {
 65 |       if (model instanceof ContainerReflection === false) {
 66 |         return;
 67 |       }
 68 | 
 69 |       const [tables1, categories] = partition(model.categories ?? [], isNestedTable);
 70 |       const [tables2, groups] = partition(model.groups ?? [], isNestedTable);
 71 | 
 72 |       const [modules, tables] = partition(
 73 |         [...tables1, ...tables2],
 74 |         (x) => x.children.every((x) => x.kindOf(ReflectionKind.ExportContainer)),
 75 |       );
 76 | 
 77 |       return [
 78 |         modules.map((x) => this.#table(x, true)),
 79 |         categories.map((x) => this.#category(x)),
 80 |         groups.map((x) => this.#group(x)),
 81 |         tables.map((x) => this.#table(x, true)),
 82 |       ];
 83 |     }
 84 | 
 85 |     #category(category: ReflectionCategory) {
 86 |       return this.#table(category, false);
 87 |     }
 88 | 
 89 |     #group(group: ReflectionGroup) {
 90 |       if (group.categories) {
 91 |         return group.categories.map((x) => this.#category(x));
 92 |       }
 93 | 
 94 |       return this.#table(group, false);
 95 |     }
 96 | 
 97 |     #table(section: ReflectionSection, forceNested: boolean) {
 98 |       const anchor = this.sectionSlug(section);
 99 | 
100 |       return (
101 |         <>
102 |           <h3>
103 |             <a href={`#${anchor}`}>{section.title}</a>
104 |           </h3>
105 |           <ul class="block">
106 |             {section.children.map((x) => this.#item(x, forceNested))}
107 |           </ul>
108 |         </>
109 |       );
110 |     }
111 | 
112 |     #item(item: ReflectionWithLink, forceNested: boolean) {
113 |       return (
114 |         <li class={this.getReflectionClasses(item)}>
115 |           <a href={this.itemLink(item, forceNested)}>{item.name}</a>
116 |         </li>
117 |       );
118 |     }
119 |   };
120 | 


--------------------------------------------------------------------------------
/src/plugin/context/utils.tsx:
--------------------------------------------------------------------------------
  1 | import * as cheerio from 'cheerio';
  2 | import slug from 'slug';
  3 | import {
  4 |   BaseRouter,
  5 |   DeclarationReflection,
  6 |   DefaultThemeRenderContext,
  7 |   DocumentReflection,
  8 |   JSX,
  9 |   Reflection,
 10 |   ReflectionCategory,
 11 |   ReflectionGroup,
 12 |   ReflectionKind,
 13 |   Router,
 14 | } from 'typedoc';
 15 | 
 16 | export type ReflectionSection = ReflectionGroup | ReflectionCategory;
 17 | export type ReflectionWithLink = DeclarationReflection | DocumentReflection;
 18 | export type URLFactory = Router | DefaultThemeRenderContext;
 19 | 
 20 | export function isNestedTable(section: ReflectionSection) {
 21 |   return section.children.every(isNestedItem);
 22 | }
 23 | 
 24 | export function isNestedItem(item: ReflectionWithLink) {
 25 |   return item.kindOf([
 26 |     ReflectionKind.ExportContainer,
 27 |     ReflectionKind.Interface,
 28 |     ReflectionKind.Class,
 29 |     ReflectionKind.Enum,
 30 |   ]);
 31 | }
 32 | 
 33 | export function transformElement(
 34 |   children: JSX.Children,
 35 |   transformer: (_: JSX.Element) => JSX.Element,
 36 | ): JSX.Children {
 37 |   if (Array.isArray(children)) {
 38 |     return children.map((x) => transformElement(x, transformer));
 39 |   }
 40 | 
 41 |   if (typeof children !== 'object' || children === null) {
 42 |     return children;
 43 |   }
 44 | 
 45 |   return {
 46 |     ...transformer(children),
 47 |     children: children.children.map((x) => transformElement(x, transformer)),
 48 |   };
 49 | }
 50 | 
 51 | export function transformTypography(html: string): string {
 52 |   const $ = cheerio.load(html, null, false);
 53 | 
 54 |   $('h1').each((_, el) => {
 55 |     $(el).wrapInner('<h2></h2>').children(':first-child').unwrap();
 56 |   });
 57 | 
 58 |   $('a').find('>h1, >h2, >h3, >h4, >h5, >h6').each((_, el) => {
 59 |     const $heading = $(el);
 60 |     const $outerAnchor = $heading.parent();
 61 |     const $innerAnchor = $('<a></a>');
 62 | 
 63 |     $outerAnchor.after($heading);
 64 |     $outerAnchor.remove();
 65 | 
 66 |     $innerAnchor.attr('href', $outerAnchor.attr('href'));
 67 |     $innerAnchor.append($heading.contents());
 68 | 
 69 |     $heading.attr('id', $outerAnchor.attr('id'));
 70 |     $heading.append($innerAnchor);
 71 |   });
 72 | 
 73 |   return $.html();
 74 | }
 75 | 
 76 | export function join(joiner: JSX.Children, list: readonly JSX.Children[]) {
 77 |   const result = [];
 78 | 
 79 |   for (const item of list) {
 80 |     if (result.length > 0) {
 81 |       result.push(joiner);
 82 |     }
 83 |     result.push(item);
 84 |   }
 85 | 
 86 |   return result;
 87 | }
 88 | 
 89 | export function breakable(str: string) {
 90 |   const sep = /([^0-9A-Za-z]+|[0-9]+|(?<=[a-z])(?=[A-Z]))/;
 91 |   const pieces = str.split(sep).filter((x) => x.length);
 92 |   return join(<wbr />, pieces);
 93 | }
 94 | 
 95 | export function partition<T>(items: T[], predicate: (_: T) => boolean): [T[], T[]] {
 96 |   const satisfied = [];
 97 |   const unsatisfied = [];
 98 | 
 99 |   for (const item of items) {
100 |     if (predicate(item)) {
101 |       satisfied.push(item);
102 |     } else {
103 |       unsatisfied.push(item);
104 |     }
105 |   }
106 | 
107 |   return [satisfied, unsatisfied];
108 | }
109 | 
110 | export const getUrl = (factory: URLFactory, item: Reflection) => {
111 |   if (factory instanceof DefaultThemeRenderContext) {
112 |     return factory.urlTo(item)!;
113 |   }
114 | 
115 |   if (factory instanceof BaseRouter) {
116 |     return factory.getFullUrl(item);
117 |   }
118 | 
119 |   throw new Error('Unknown URL factory type');
120 | };
121 | 
122 | export function sectionSlug(section: ReflectionSection) {
123 |   const title = slug(section.title);
124 |   return `section.${title}`;
125 | }
126 | 
127 | export function itemSlug(item: ReflectionWithLink) {
128 |   const kind = ReflectionKind.classString(item.kind).replace('tsd-kind-', '');
129 |   const name = slug(item.name);
130 |   return `${kind}.${name}`;
131 | }
132 | 
133 | export function itemLink(factory: URLFactory, item: ReflectionWithLink, forceNested: boolean) {
134 |   if (forceNested || !item.parent || isNestedItem(item)) {
135 |     return getUrl(factory, item);
136 |   }
137 | 
138 |   const url = getUrl(factory, item.parent);
139 |   const anchor = itemSlug(item);
140 |   if (typeof url !== 'undefined') {
141 |     return `${url}#${anchor}`;
142 |   }
143 | 
144 |   return getUrl(factory, item);
145 | }
146 | 


--------------------------------------------------------------------------------
/src/assets/index.ts:
--------------------------------------------------------------------------------
  1 | import './style.css';
  2 | 
  3 | import { Document } from 'flexsearch';
  4 | import { html, LitElement } from 'lit';
  5 | import { customElement, property } from 'lit/decorators.js';
  6 | import { map } from 'lit/directives/map.js';
  7 | import { throttle } from 'lodash-es';
  8 | import { ReflectionKind } from 'typedoc/models';
  9 | 
 10 | import { SearchItem } from '../lib/types';
 11 | import { getReflectionKindName, loadSearchIndex } from './data';
 12 | 
 13 | document.addEventListener('DOMContentLoaded', async () => {
 14 |   const form = document.querySelector('rustdoc-search .search-form') as HTMLFormElement;
 15 |   const input = document.querySelector('rustdoc-search .search-input') as HTMLInputElement;
 16 | 
 17 |   const main = document.getElementById('main-content')!;
 18 |   const alt = document.getElementById('alternative-display')!;
 19 | 
 20 |   form.addEventListener('submit', (event) => {
 21 |     event.preventDefault();
 22 |     event.stopPropagation();
 23 |   });
 24 | 
 25 |   let index: Promise<Document<SearchItem>>;
 26 |   let controller: AbortController;
 27 | 
 28 |   input.addEventListener(
 29 |     'input',
 30 |     throttle(async (event) => {
 31 |       if (!index) {
 32 |         index = loadSearchIndex();
 33 |       }
 34 | 
 35 |       const query = event.target.value?.trim();
 36 | 
 37 |       const [hide, show] = query ? [main, alt] : [alt, main];
 38 |       hide.classList.add('hidden');
 39 |       show.classList.remove('hidden');
 40 | 
 41 |       controller?.abort();
 42 |       controller = new AbortController();
 43 |       const signal = controller.signal;
 44 | 
 45 |       await performSearch(query, signal, await index);
 46 |     }, 300),
 47 |   );
 48 | });
 49 | 
 50 | async function performSearch(query: string, signal: AbortSignal, index: Document<SearchItem>) {
 51 |   if (signal.aborted || !query.length) {
 52 |     return;
 53 |   }
 54 | 
 55 |   const items = await index.search({ query, enrich: true, merge: true });
 56 |   if (signal.aborted) {
 57 |     return;
 58 |   }
 59 | 
 60 |   const vars = document.querySelector('meta[name="rustdoc-vars"]') as HTMLMetaElement;
 61 |   const results = document.querySelector('oxide-search-results#search') as OxideSearchResults;
 62 | 
 63 |   results.loading = false;
 64 |   results.project = vars.dataset.currentCrate!;
 65 |   results.query = query;
 66 |   results.items = items.map((x) => x.doc).filter((x) => x !== null && x !== undefined);
 67 | }
 68 | 
 69 | @customElement('oxide-search-results')
 70 | class OxideSearchResults extends LitElement {
 71 |   static base = document.documentElement.dataset.base!;
 72 | 
 73 |   static classes = {
 74 |     [ReflectionKind.ClassMember]: 'fn',
 75 |     [ReflectionKind.Function]: 'fn',
 76 |     [ReflectionKind.Property]: 'fn',
 77 |     [ReflectionKind.Method]: 'fn',
 78 |     [ReflectionKind.CallSignature]: 'fn',
 79 |     [ReflectionKind.IndexSignature]: 'fn',
 80 |     [ReflectionKind.GetSignature]: 'fn',
 81 |     [ReflectionKind.SetSignature]: 'fn',
 82 |     [ReflectionKind.Accessor]: 'fn',
 83 |     [ReflectionKind.ConstructorSignature]: 'primitive',
 84 |     [ReflectionKind.Constructor]: 'primitive',
 85 |     [ReflectionKind.EnumMember]: 'macro',
 86 |     [ReflectionKind.Variable]: 'macro',
 87 |   } as Record<number, string>;
 88 | 
 89 |   @property({ attribute: false })
 90 |   accessor loading: boolean = true;
 91 | 
 92 |   @property({ attribute: false })
 93 |   accessor project: string = '';
 94 | 
 95 |   @property({ attribute: false })
 96 |   accessor query: string = '';
 97 | 
 98 |   @property({ attribute: false })
 99 |   accessor items: SearchItem[] = [];
100 | 
101 |   createRenderRoot() {
102 |     // Disable Shadow DOM.
103 |     return this;
104 |   }
105 | 
106 |   render() {
107 |     if (this.loading) {
108 |       return html`
109 |         <h3 class="search-loading">Loading search results...</h3>
110 |       `;
111 |     }
112 | 
113 |     const items = this.items.map((item) => {
114 |       const classname = OxideSearchResults.classes[item.kind] ?? 'mod';
115 |       const trace = map(
116 |         item.parent?.split('.').filter((x) => x) ?? [],
117 |         (name) => html`<span class="parent">${name}.</span>`,
118 |       );
119 | 
120 |       return html`
121 |         <a class="result-item" href="${OxideSearchResults.base}${item.url}">
122 |           <span class="result-name">
123 |             <span class="typename">
124 |               ${getReflectionKindName(item.kind)}
125 |             </span>
126 | 
127 |             <div class="path">
128 |               ${trace}<span class="${classname}">${item.name}</span>
129 |             </div>
130 |           </span>
131 |         </a>
132 |       `;
133 |     });
134 | 
135 |     const ddgQuery = encodeURIComponent(`${this.project} ${this.query}`);
136 | 
137 |     return html`
138 |       <div class="main-heading">
139 |         <h1 class="search-results-title">Results</h1>
140 |       </div>
141 | 
142 |       <div id="results">
143 |         <div class="search-results ${this.items.length ? 'active' : ''}">
144 |           ${items}
145 |         </div>
146 | 
147 |         <div class="search-failed ${this.items.length ? '' : 'active'}">
148 |           No results :(
149 |           <br />
150 |           Try on <a href="https://duckduckgo.com/?q=${ddgQuery}" target="_blank">DuckDuckGo</a>?
151 |         </div>
152 |       </div>
153 |     `;
154 |   }
155 | }
156 | 


--------------------------------------------------------------------------------
/src/plugin/context/mixins/layout.tsx:
--------------------------------------------------------------------------------
  1 | import { JSX, PageEvent, Reflection, RenderTemplate } from 'typedoc';
  2 | 
  3 | import { OxideContextBase } from '../base';
  4 | 
  5 | type Template = RenderTemplate<PageEvent<Reflection>>;
  6 | 
  7 | export const LayoutMixin = (base: typeof OxideContextBase) =>
  8 |   class extends base {
  9 |     defaultLayout = (template: Template, page: PageEvent<Reflection>) => {
 10 |       return (
 11 |         <html lang={this.options.getValue('lang')} data-base={this.relativeURL('./')}>
 12 |           {this.#head(page)}
 13 | 
 14 |           <body class="rustdoc">
 15 |             <JSX.Raw html="<!--[if lte IE 11]>" />
 16 |             <div class="warning">
 17 |               This old browser is unsupported and will most likely display funky things.
 18 |             </div>
 19 |             <JSX.Raw html="<![endif]-->" />
 20 | 
 21 |             {this.hook('body.begin', this)}
 22 | 
 23 |             {this.#topbar(page)}
 24 |             {this.#sidebar(page)}
 25 |             {this.#main(template, page)}
 26 | 
 27 |             {this.hook('body.end', this)}
 28 |           </body>
 29 |         </html>
 30 |       );
 31 |     };
 32 | 
 33 |     #head(page: PageEvent<Reflection>) {
 34 |       const { model, project } = page;
 35 | 
 36 |       let title = model.name;
 37 |       if (model.parent && !model.parent.isProject()) {
 38 |         title = `${title} in ${model.parent.getFriendlyFullName()}`;
 39 |       }
 40 |       if (!model.isProject()) {
 41 |         title = `${title} - ${project.name}`;
 42 |       }
 43 | 
 44 |       const fonts = [
 45 |         'fonts/SourceSerif4-Regular.ttf.woff2',
 46 |         'fonts/FiraSans-Regular.woff2',
 47 |         'fonts/FiraSans-Medium.woff2',
 48 |         'fonts/SourceCodePro-Regular.ttf.woff2',
 49 |         'fonts/SourceSerif4-Bold.ttf.woff2',
 50 |         'fonts/SourceCodePro-Semibold.ttf.woff2',
 51 |       ];
 52 | 
 53 |       return (
 54 |         <head>
 55 |           <meta charset="utf-8" />
 56 |           {this.hook('head.begin', this)}
 57 |           <meta http-equiv="x-ua-compatible" content="IE=edge" />
 58 |           <title>{title}</title>
 59 |           <meta name="description" content={'Documentation for ' + project.name} />
 60 |           <meta name="viewport" content="width=device-width, initial-scale=1" />
 61 | 
 62 |           {fonts.map((font) => (
 63 |             <link
 64 |               rel="preload"
 65 |               as="font"
 66 |               type="font/woff2"
 67 |               crossOrigin="anonymous"
 68 |               href={rustdocAsset(font)}
 69 |             />
 70 |           ))}
 71 | 
 72 |           <link rel="stylesheet" type="text/css" href={rustdocAsset('css/normalize.min.css')} />
 73 |           <link
 74 |             rel="stylesheet"
 75 |             type="text/css"
 76 |             href={this.relativeURL('assets/oxide/rustdoc/rustdoc.css')}
 77 |           />
 78 | 
 79 |           <meta
 80 |             name="rustdoc-vars"
 81 |             data-root-path={this.relativeURL('')}
 82 |             data-static-root-path={this.relativeURL('assets/oxide/rustdoc/')}
 83 |             data-current-crate={page.project.name}
 84 |             data-themes=""
 85 |             data-resource-suffix=""
 86 |             data-rustdoc-version="1.86.0"
 87 |             data-channel="1.86.0"
 88 |             data-search-js="search.js"
 89 |             data-settings-js="settings.js"
 90 |           />
 91 | 
 92 |           <script src={rustdocAsset('js/storage.min.js')}></script>
 93 |           <script defer src={this.relativeURL('assets/oxide/rustdoc/main.js')}></script>
 94 |           <noscript>
 95 |             <link rel="stylesheet" href={rustdocAsset('css/noscript.min.css')} />
 96 |           </noscript>
 97 | 
 98 |           <link rel="stylesheet" href={this.relativeURL('assets/highlight.css')} />
 99 |           <link rel="stylesheet" href={this.relativeURL('assets/oxide/index.css')} />
100 |           <script src={this.relativeURL('assets/oxide/index.js')}></script>
101 | 
102 |           {this.options.getValue('customCss') && <link rel="stylesheet" href={this.relativeURL('assets/custom.css')} />}
103 |           {this.hook('head.end', this)}
104 |         </head>
105 |       );
106 |     }
107 | 
108 |     #topbar(page: PageEvent<Reflection>) {
109 |       const { project } = page;
110 | 
111 |       return (
112 |         <nav class="mobile-topbar">
113 |           <button class="sidebar-menu-toggle" title="show sidebar"></button>
114 |           <h2 class="location">
115 |             <a href="#">{project.name}</a>
116 |           </h2>
117 |         </nav>
118 |       );
119 |     }
120 | 
121 |     #sidebar(page: PageEvent<Reflection>) {
122 |       const { project } = page;
123 | 
124 |       return (
125 |         <>
126 |           <nav class="sidebar">
127 |             <div class="sidebar-crate">
128 |               <h2>
129 |                 <a href={this.relativeURL('index.html')}>{project.name}</a>
130 |                 <span class="version">{project.packageVersion}</span>
131 |               </h2>
132 |             </div>
133 | 
134 |             {this.hook('sidebar.begin', this)}
135 |             {this.navigation(page)}
136 |             {this.hook('sidebar.end', this)}
137 |           </nav>
138 |           <div class="sidebar-resizer" />
139 |         </>
140 |       );
141 |     }
142 | 
143 |     #main(template: Template, page: PageEvent<Reflection>) {
144 |       return (
145 |         <main>
146 |           <div class="width-limiter">
147 |             <rustdoc-search />
148 | 
149 |             <section id="main-content" class="content">
150 |               {this.hook('content.begin', this)}
151 |               {template(page)}
152 |               {this.hook('content.end', this)}
153 |             </section>
154 | 
155 |             <section id="alternative-display" class="content hidden">
156 |               <oxide-search-results id="search" />
157 |             </section>
158 |           </div>
159 |         </main>
160 |       );
161 |     }
162 |   };
163 | 
164 | function rustdocAsset(path: string) {
165 |   return `https://cdn.jsdelivr.net/gh/rust-lang/rust@1.86.0/src/librustdoc/html/static/${path}`;
166 | }
167 | 


--------------------------------------------------------------------------------
/src/plugin/context/mixins/members.tsx:
--------------------------------------------------------------------------------
  1 | import {
  2 |   ContainerReflection,
  3 |   DeclarationReflection,
  4 |   DocumentReflection,
  5 |   JSX,
  6 |   ReflectionKind,
  7 |   ReflectionType,
  8 |   SignatureReflection,
  9 |   TypeParameterReflection,
 10 | } from 'typedoc';
 11 | 
 12 | import { OxideContextBase } from '../base';
 13 | import {
 14 |   breakable,
 15 |   isNestedItem,
 16 |   isNestedTable,
 17 |   join,
 18 |   partition,
 19 |   ReflectionSection,
 20 |   ReflectionWithLink,
 21 |   transformElement,
 22 | } from '../utils';
 23 | 
 24 | export const MembersMixin = (base: typeof OxideContextBase) =>
 25 |   class extends base {
 26 |     members = (model: ContainerReflection) => {
 27 |       const [nested1, categories] = partition(model.categories ?? [], isNestedTable);
 28 |       const [nested2, groups] = partition(model.groups ?? [], isNestedTable);
 29 | 
 30 |       const [modules, tables] = partition(
 31 |         [...nested1, ...nested2],
 32 |         (x) => x.children.every((x) => x.kindOf(ReflectionKind.ExportContainer)),
 33 |       );
 34 | 
 35 |       const sections = [
 36 |         ...categories,
 37 |         ...groups.flatMap((x) => x.categories ?? [x] as ReflectionSection[]),
 38 |       ];
 39 | 
 40 |       return (
 41 |         <>
 42 |           {this.#preview(model)}
 43 |           {modules.map((x) => this.#table(x, true))}
 44 |           {sections.map((x) => this.#section(x))}
 45 |           {tables.map((x) => this.#table(x, true))}
 46 |         </>
 47 |       );
 48 |     };
 49 | 
 50 |     #preview(decl: ContainerReflection) {
 51 |       if (!decl.isDeclaration()) {
 52 |         return;
 53 |       }
 54 | 
 55 |       // Workaround for `this.reflectionPreview`
 56 |       if (decl.indexSignatures) {
 57 |         decl.children ??= [];
 58 |       }
 59 | 
 60 |       const preview = this.reflectionPreview(decl);
 61 |       if (preview) {
 62 |         return (
 63 |           <pre class="item-decl">
 64 |             <code>{removeLinks(transformHighlights(preview))}</code>
 65 |           </pre>
 66 |         );
 67 |       }
 68 | 
 69 |       if (!isNestedItem(decl)) {
 70 |         return (
 71 |           <pre class="item-decl">
 72 |             <code>{this.#definition(decl, true)}</code>
 73 |           </pre>
 74 |         );
 75 |       }
 76 |     }
 77 | 
 78 |     #table = (section: ReflectionSection, forceNested: boolean) => {
 79 |       const anchor = this.sectionSlug(section);
 80 | 
 81 |       return (
 82 |         <>
 83 |           <h2 id={anchor} class="section-header">
 84 |             {section.title}
 85 |             <a href={`#${anchor}`} class="anchor">§</a>
 86 |           </h2>
 87 | 
 88 |           <dl class="item-table">
 89 |             {section.children.map((item) => (
 90 |               <>
 91 |                 <dt>
 92 |                   <a
 93 |                     class={itemLinkClass(item)}
 94 |                     href={this.itemLink(item, forceNested)}
 95 |                     title={item.name}>
 96 |                     {item.name}
 97 |                   </a>
 98 |                 </dt>
 99 | 
100 |                 <dd>
101 |                   <JSX.Raw html={this.markdown(item.comment?.getShortSummary(true))} />
102 |                 </dd>
103 |               </>
104 |             ))}
105 |           </dl>
106 |         </>
107 |       );
108 |     };
109 | 
110 |     #section(section: ReflectionSection) {
111 |       const anchor = this.sectionSlug(section);
112 | 
113 |       let classname = 'impl-items';
114 |       if (section.children.every((x) => x.kindOf(ReflectionKind.EnumMember))) {
115 |         classname = 'variants';
116 |       }
117 |       if (section.children.every((x) => x.kindOf(ReflectionKind.Property))) {
118 |         classname = '';
119 |       }
120 | 
121 |       return (
122 |         <>
123 |           <h2 id={anchor} class="section-header">
124 |             {section.title}
125 |             <a href={`#${anchor}`} class="anchor">§</a>
126 |           </h2>
127 | 
128 |           <div class={classname}>
129 |             {section.children.map((item) => this.#item(item))}
130 |           </div>
131 |         </>
132 |       );
133 |     }
134 | 
135 |     #item(item: ReflectionWithLink) {
136 |       if (item instanceof DocumentReflection) {
137 |         return this.#doc(item);
138 |       }
139 | 
140 |       if (item.kindOf(ReflectionKind.EnumMember)) {
141 |         return this.#variant(item);
142 |       }
143 | 
144 |       return this.#decl(item);
145 |     }
146 | 
147 |     #doc(doc: DocumentReflection) {
148 |       console.log('DocumentReflection', doc.getFullName());
149 |       debugger;
150 |     }
151 | 
152 |     #variant(decl: DeclarationReflection) {
153 |       const anchor = this.itemSlug(decl);
154 | 
155 |       return (
156 |         <>
157 |           <section id={anchor} class="variant">
158 |             <a href={`#${anchor}`} class="anchor">§</a>
159 |             <h3 class="code-header">{decl.name} = {transformHighlights(this.type(decl.type))}</h3>
160 |           </section>
161 | 
162 |           <div class="docblock">
163 |             {this.commentSummary(decl)}
164 |             {this.commentTags(decl)}
165 |           </div>
166 |         </>
167 |       );
168 |     }
169 | 
170 |     #decl(decl: DeclarationReflection) {
171 |       const anchor = this.itemSlug(decl);
172 | 
173 |       if (decl.signatures?.length) {
174 |         // methods
175 |         return decl.signatures?.map((x, i) =>
176 |           i === 0
177 |             ? this.#signature(x, anchor)
178 |             : this.#signature(x, `${anchor}-${i}`)
179 |         );
180 |       }
181 | 
182 |       if (decl.hasGetterOrSetter()) {
183 |         // accessors
184 |         const signatures = [decl.getSignature, decl.setSignature].filter((x) => x != undefined);
185 |         return signatures.map((x, i) =>
186 |           i === 0
187 |             ? this.#signature(x, anchor)
188 |             : this.#signature(x, `${anchor}-${i}`)
189 |         );
190 |       }
191 | 
192 |       // type aliases, variables, fields
193 |       return this.#detail(decl, anchor);
194 |     }
195 | 
196 |     #signature(signature: SignatureReflection, anchor: string) {
197 |       return (
198 |         <details class="toggle method-toggle" open>
199 |           <summary>
200 |             <section id={anchor} class="method trait-impl">
201 |               {this.#source(signature)}
202 |               <a href={anchor && `#${anchor}`} class="anchor">§</a>
203 | 
204 |               <h4 class="code-header">
205 |                 {transformHighlights(this.memberSignatureTitle(signature))}
206 |               </h4>
207 |             </section>
208 |           </summary>
209 | 
210 |           <div class="docblock">
211 |             {this.commentSummary(signature)}
212 |             {this.commentTags(signature)}
213 |           </div>
214 |         </details>
215 |       );
216 |     }
217 | 
218 |     #detail(decl: DeclarationReflection, anchor: string) {
219 |       if (decl.kindOf(ReflectionKind.Property)) {
220 |         return (
221 |           <>
222 |             <span id={anchor} class="structfield section-header">
223 |               <a href={`#${anchor}`} class="anchor field">§</a>
224 |               <code>{this.#definition(decl)}</code>
225 |             </span>
226 | 
227 |             <div class="docblock">
228 |               {this.commentSummary(decl)}
229 |               {this.commentTags(decl)}
230 |             </div>
231 |           </>
232 |         );
233 |       }
234 | 
235 |       return (
236 |         <details class="toggle method-toggle" open>
237 |           <summary>
238 |             <section id={anchor} class="method trait-impl">
239 |               {this.#source(decl)}
240 |               <a href={`#${anchor}`} class="anchor">§</a>
241 | 
242 |               <h4 class="code-header">{this.#definition(decl)}</h4>
243 |             </section>
244 |           </summary>
245 | 
246 |           <div class="docblock">
247 |             {this.commentSummary(decl)}
248 |             {this.commentTags(decl)}
249 |           </div>
250 |         </details>
251 |       );
252 |     }
253 | 
254 |     #definition(decl: DeclarationReflection, full = false) {
255 |       let value: JSX.Children = decl.defaultValue;
256 |       if (isStringNumberLiteral(value)) {
257 |         value = <span class="macro">{decl.defaultValue}</span>;
258 |       } else if (isPrimitiveType(value)) {
259 |         value = <span class="primitive">{decl.defaultValue}</span>;
260 |       }
261 | 
262 |       let delimeter;
263 |       if (decl.kindOf(ReflectionKind.SomeType)) {
264 |         delimeter = ' = ';
265 |       } else {
266 |         delimeter = decl.flags.isOptional ? '?: ' : ': ';
267 |       }
268 | 
269 |       let type;
270 |       if (!full && decl.type instanceof ReflectionType) {
271 |         type = '{ ... }';
272 |       } else {
273 |         type = this.type(decl.type);
274 |       }
275 | 
276 |       return (
277 |         <>
278 |           {transformHighlights(this.#modifier(decl))}
279 | 
280 |           {decl.kindOf(ReflectionKind.SomeMember)
281 |             ? <span>{breakable(decl.name)}</span>
282 |             : <a class={itemLinkClass(decl)} href={this.urlTo(decl)}>{breakable(decl.name)}</a>}
283 | 
284 |           {transformHighlights(this.#generics(decl.typeParameters))}
285 | 
286 |           {type
287 |             ? [delimeter, transformHighlights(type)]
288 |             : (decl.groups || decl.categories) && `${delimeter}{ ... }`}
289 | 
290 |           {value}
291 |         </>
292 |       );
293 |     }
294 | 
295 |     #modifier(decl: DeclarationReflection) {
296 |       let modifier = [];
297 | 
298 |       if (decl.kindOf(ReflectionKind.SomeType)) {
299 |         modifier.push('type');
300 |       } else if (decl.kindOf(ReflectionKind.SomeValue)) {
301 |         modifier.push(decl.flags.isConst ? 'const' : 'let');
302 |       } else if (decl.kindOf(ReflectionKind.ClassMember)) {
303 |         if (decl.flags.isPrivate) {
304 |           modifier.push('private');
305 |         }
306 |         if (decl.flags.isProtected) {
307 |           modifier.push('protected');
308 |         }
309 |         if (decl.flags.isPublic) {
310 |           modifier.push('public');
311 |         }
312 |         if (decl.flags.isAbstract) {
313 |           modifier.push('abstract');
314 |         }
315 |         if (decl.flags.isStatic) {
316 |           modifier.push('static');
317 |         }
318 |         if (decl.flags.isReadonly) {
319 |           modifier.push('readonly');
320 |         }
321 |       }
322 | 
323 |       if (!modifier.length) {
324 |         return;
325 |       }
326 | 
327 |       return <span class="tsd-signature-keyword">{modifier.join(' ')}{' '}</span>;
328 |     }
329 | 
330 |     #source(decl: DeclarationReflection | SignatureReflection) {
331 |       const url = this.itemSourceLink(decl);
332 |       if (!url) {
333 |         return;
334 |       }
335 | 
336 |       return (
337 |         <span class="rightside">
338 |           <a class="src" href={url}>Source</a>
339 |         </span>
340 |       );
341 |     }
342 | 
343 |     #generics(params?: TypeParameterReflection[]) {
344 |       if (!params?.length) {
345 |         return;
346 |       }
347 | 
348 |       return (
349 |         <>
350 |           <span class="tsd-signature-symbol">{'<'}</span>
351 |           {join(
352 |             <span class="tsd-signature-symbol">{', '}</span>,
353 |             params.map((item) => (
354 |               <>
355 |                 {item.varianceModifier ? `${item.varianceModifier} ` : ''}
356 |                 <span
357 |                   class="tsd-signature-type"
358 |                   data-tsd-kind={ReflectionKind.singularString(item.kind)}>
359 |                   {item.name}
360 |                 </span>
361 |               </>
362 |             )),
363 |           )}
364 |           <span class="tsd-signature-symbol">{'>'}</span>
365 |         </>
366 |       );
367 |     }
368 |   };
369 | 
370 | export function itemLinkClass(item: ReflectionWithLink): string {
371 |   switch (item.kind) {
372 |     case ReflectionKind.Module:
373 |     case ReflectionKind.Namespace:
374 |       return 'mod';
375 |     case ReflectionKind.Function:
376 |       return 'fn';
377 |     case ReflectionKind.TypeAlias:
378 |       return 'type';
379 |     case ReflectionKind.Enum:
380 |       return 'enum';
381 |     case ReflectionKind.Class:
382 |       return 'struct';
383 |     case ReflectionKind.Interface:
384 |       return 'trait';
385 |     case ReflectionKind.Variable:
386 |       return 'constant';
387 |     default:
388 |       return 'foreigntype';
389 |   }
390 | }
391 | 
392 | function removeLinks(children: JSX.Children) {
393 |   return transformElement(children, (element) => {
394 |     if (element.tag === 'a') {
395 |       element.tag = 'span';
396 |       if (element.props) {
397 |         // @ts-ignore
398 |         delete element.props.href;
399 |       }
400 |     }
401 | 
402 |     return element;
403 |   });
404 | }
405 | 
406 | function transformHighlights(children: JSX.Children) {
407 |   return transformElement(children, (element) => {
408 |     const props = {
409 |       'class': '',
410 |       'href': undefined as string | undefined,
411 |       'data-tsd-kind': undefined as string | undefined,
412 |       ...element.props,
413 |     };
414 | 
415 |     const classes = props.class.trim().split(/\s+/);
416 |     if (classes.includes('tsd-signature-type')) {
417 |       if (isStringNumberLiteral(element.children[0])) {
418 |         classes.push('macro');
419 |       } else if (isPrimitiveType(element.children[0])) {
420 |         classes.push('keyword');
421 |       } else if (props['data-tsd-kind'] === ReflectionKind.singularString(ReflectionKind.TypeParameter)) {
422 |         classes.push('trait');
423 |       } else if (classes.includes('tsd-kind-type-parameter')) {
424 |         classes.push('trait');
425 |       } else if (classes.includes('tsd-kind-enum-member')) {
426 |         classes.push('constant');
427 |       } else {
428 |         classes.push('type');
429 |       }
430 |     }
431 |     if (classes.includes('tsd-signature-keyword')) {
432 |       // keywords in signature have no color in rustdoc
433 |       classes.push('token');
434 |     }
435 |     if (
436 |       classes.includes('tsd-kind-interface')
437 |       || classes.includes('tsd-kind-type-alias')
438 |       || classes.includes('tsd-kind-constructor-signature')
439 |     ) {
440 |       classes.push('type');
441 |     }
442 |     if (classes.includes('tsd-kind-type-parameter')) {
443 |       classes.push('trait');
444 |       element.tag = 'span';
445 |       delete props.href;
446 |     }
447 |     if (classes.includes('tsd-kind-enum-member')) {
448 |       if (props.href) {
449 |         const [url, hash] = props.href.split('#');
450 |         props.href = `${url}#enum-member.${hash}`;
451 |       }
452 |     }
453 |     if (classes.includes('tsd-kind-call-signature')) {
454 |       classes.push('method');
455 |     }
456 |     props.class = classes.join(' ');
457 | 
458 |     return {
459 |       ...element,
460 |       props,
461 |     };
462 |   });
463 | }
464 | 
465 | function isStringNumberLiteral(expr: JSX.Children) {
466 |   return typeof expr === 'string' && /^(\d|".+"$)/.test(expr);
467 | }
468 | 
469 | function isPrimitiveType(expr: JSX.Children) {
470 |   const primitives = [
471 |     'boolean',
472 |     'number',
473 |     'string',
474 |     'symbol',
475 |     'unknown',
476 |     'any',
477 |     'void',
478 |     'null',
479 |     'undefined',
480 |     'never',
481 |     'object',
482 |     'unique symbol',
483 |   ];
484 | 
485 |   return typeof expr === 'string' && primitives.includes(expr);
486 | }
487 | 


--------------------------------------------------------------------------------