fumadocs-typescript 1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,3 @@
+# Fumadocs Typescript
+
+Typescript Integration for Fumadocs.

package/dist/base-tTG4_ClF.d.ts

@@ -0,0 +1,46 @@
+import ts from 'typescript';
+
+interface TypescriptConfig {
+    files?: string[];
+    tsconfigPath?: string;
+    /** A root directory to resolve relative path entries in the config file to. e.g. outDir */
+    basePath?: string;
+}
+
+interface GeneratedDoc {
+    name: string;
+    description: string;
+    entries: DocEntry[];
+}
+interface DocEntry {
+    name: string;
+    description: string;
+    type: string;
+    tags: Record<string, string>;
+}
+interface EntryContext {
+    program: ts.Program;
+    checker: ts.TypeChecker;
+    options: GenerateOptions;
+    type: ts.Type;
+    symbol: ts.Symbol;
+}
+interface GenerateOptions {
+    /**
+     * Modify output property entry
+     */
+    transform?: (this: EntryContext, entry: DocEntry, propertyType: ts.Type, propertySymbol: ts.Symbol) => void;
+}
+interface GenerateDocumentationOptions extends GenerateOptions {
+    /**
+     * Typescript configurations
+     */
+    config?: TypescriptConfig;
+}
+/**
+ * Generate documentation for properties in an exported type/interface
+ */
+declare function generateDocumentation(file: string, name: string, options?: GenerateDocumentationOptions): GeneratedDoc | undefined;
+declare function generate(program: ts.Program, symbol: ts.Symbol, options: GenerateOptions): GeneratedDoc;
+
+export { type DocEntry as D, type GenerateOptions as G, type TypescriptConfig as T, type GeneratedDoc as a, type GenerateDocumentationOptions as b, generate as c, generateDocumentation as g };

package/dist/chunk-HQHQFSUJ.js

@@ -0,0 +1,156 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/generate/base.ts
+import ts2 from "typescript";
+
+// src/program.ts
+import ts from "typescript";
+var cache = /* @__PURE__ */ new Map();
+function getFileSymbol(file, program) {
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(file);
+  if (!sourceFile)
+    return;
+  return checker.getSymbolAtLocation(sourceFile);
+}
+function getProgram(options = {}) {
+  var _a, _b, _c;
+  const key = JSON.stringify(options);
+  const cached = cache.get(key);
+  if (cached)
+    return cached;
+  const configFile = ts.readJsonConfigFile(
+    (_a = options.tsconfigPath) != null ? _a : "./tsconfig.json",
+    (path) => ts.sys.readFile(path)
+  );
+  const parsed = ts.parseJsonSourceFileConfigFileContent(
+    configFile,
+    ts.sys,
+    (_b = options.basePath) != null ? _b : "./"
+  );
+  const program = ts.createProgram({
+    rootNames: (_c = options.files) != null ? _c : parsed.fileNames,
+    options: __spreadProps(__spreadValues({}, parsed.options), {
+      incremental: false
+    })
+  });
+  cache.set(key, program);
+  return program;
+}
+
+// src/generate/base.ts
+function generateDocumentation(file, name, options = {}) {
+  const program = getProgram(options.config);
+  const fileSymbol = getFileSymbol(file, program);
+  if (!fileSymbol)
+    return;
+  const symbol = program.getTypeChecker().getExportsOfModule(fileSymbol).find((e) => e.getEscapedName().toString() === name);
+  if (!symbol)
+    return;
+  return generate(program, symbol, options);
+}
+function generate(program, symbol, options) {
+  const checker = program.getTypeChecker();
+  const type = checker.getDeclaredTypeOfSymbol(symbol);
+  const entryContext = {
+    checker,
+    options,
+    program,
+    type,
+    symbol
+  };
+  return {
+    name: symbol.getEscapedName().toString(),
+    description: ts2.displayPartsToString(
+      symbol.getDocumentationComment(checker)
+    ),
+    entries: type.getProperties().map((prop) => getDocEntry(prop, entryContext))
+  };
+}
+function getDocEntry(prop, context) {
+  var _a, _b, _c;
+  const { checker, options } = context;
+  const subType = checker.getTypeOfSymbol(prop);
+  const tags = Object.fromEntries(
+    prop.getJsDocTags().map((tag) => [tag.name, ts2.displayPartsToString(tag.text)])
+  );
+  let typeName = checker.typeToString(
+    subType.getNonNullableType(),
+    void 0,
+    ts2.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
+  );
+  if (subType.aliasSymbol && !subType.aliasTypeArguments) {
+    typeName = subType.aliasSymbol.escapedName.toString();
+  }
+  if (tags.remarks) {
+    typeName = (_b = (_a = new RegExp("^`(?<name>.+)`").exec(tags.remarks)) == null ? void 0 : _a[1]) != null ? _b : typeName;
+  }
+  const entry = {
+    name: prop.getName(),
+    description: ts2.displayPartsToString(prop.getDocumentationComment(checker)),
+    tags,
+    type: typeName
+  };
+  (_c = options.transform) == null ? void 0 : _c.call(context, entry, subType, prop);
+  return entry;
+}
+
+export {
+  __spreadValues,
+  __objRest,
+  __async,
+  getFileSymbol,
+  getProgram,
+  generateDocumentation,
+  generate
+};

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { G as GenerateOptions, T as TypescriptConfig, a as GeneratedDoc, D as DocEntry } from './base-tTG4_ClF.js';
+export { b as GenerateDocumentationOptions, c as generate, g as generateDocumentation } from './base-tTG4_ClF.js';
+import fg from 'fast-glob';
+import 'typescript';
+
+interface Templates {
+    block: (doc: GeneratedDoc, children: string) => string;
+    property: (entry: DocEntry) => string;
+}
+interface GenerateMDXOptions extends GenerateOptions {
+    /**
+     * a root directory to resolve relative file paths
+     */
+    basePath?: string;
+    templates?: Partial<Templates>;
+    config?: TypescriptConfig;
+}
+declare function generateMDX(source: string, { basePath, templates: overrides, config: options, ...rest }?: GenerateMDXOptions): string;
+
+interface GenerateFilesOptions {
+    input: string | string[];
+    /**
+     * Output directory, or a function that returns the output path
+     */
+    output: string | ((inputPath: string) => string);
+    globOptions?: fg.Options;
+    options?: GenerateMDXOptions;
+    /**
+     * @returns New content
+     */
+    transformOutput?: (path: string, content: string) => string;
+}
+declare function generateFiles(options: GenerateFilesOptions): Promise<void>;
+
+export { DocEntry, type GenerateFilesOptions, type GenerateMDXOptions, GenerateOptions, GeneratedDoc, generateFiles, generateMDX };

package/dist/index.js

@@ -0,0 +1,107 @@
+import {
+  __async,
+  __objRest,
+  __spreadValues,
+  generate,
+  generateDocumentation,
+  getFileSymbol,
+  getProgram
+} from "./chunk-HQHQFSUJ.js";
+
+// src/generate/mdx.ts
+import * as path from "path";
+var regex = new RegExp("^---type-table---\\r?\\n(?<file>.+?)(?:#(?<name>.+))?\\r?\\n---end---$", "gm");
+var defaultTemplates = {
+  block: (doc, c) => `### ${doc.name}
+
+${doc.description}
+
+<div className='*:border-b [&>*:last-child]:border-b-0'>${c}</div>`,
+  property: (c) => `<div className='text-sm text-muted-foreground py-4'>
+
+<div className="flex flex-row items-center gap-4">
+  <code className="text-sm">${c.name}</code>
+  <code className="text-muted-foreground">{${JSON.stringify(c.type)}}</code>
+</div>
+
+${c.description || "No Description"}
+
+${Object.entries(c.tags).map(([tag, value]) => `- ${tag}:
+${replaceJsDocLinks(value)}`).join("\n")}
+
+</div>`
+};
+function generateMDX(source, _a = {}) {
+  var _b = _a, {
+    basePath = "./",
+    templates: overrides,
+    config: options
+  } = _b, rest = __objRest(_b, [
+    "basePath",
+    "templates",
+    "config"
+  ]);
+  const templates = __spreadValues(__spreadValues({}, defaultTemplates), overrides);
+  const program = getProgram(options);
+  return source.replace(regex, (...args) => {
+    const groups = args[args.length - 1];
+    const file = path.resolve(basePath, groups.file);
+    const fileSymbol = getFileSymbol(file, program);
+    if (!fileSymbol)
+      throw new Error(`${file} doesn't exist`);
+    let docs;
+    if (!groups.name) {
+      docs = program.getTypeChecker().getExportsOfModule(fileSymbol).map((symbol) => generate(program, symbol, rest));
+    } else {
+      const symbol = program.getTypeChecker().getExportsOfModule(fileSymbol).find((s) => s.getEscapedName().toString() === groups.name);
+      if (!symbol)
+        throw new Error(`Type ${groups.name} doesn't exist`);
+      docs = [generate(program, symbol, rest)];
+    }
+    return docs.map(
+      (doc) => templates.block(doc, doc.entries.map(templates.property).join("\n"))
+    ).join("\n\n");
+  });
+}
+function replaceJsDocLinks(md) {
+  return md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1");
+}
+
+// src/generate/file.ts
+import * as path2 from "path";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import fg from "fast-glob";
+function generateFiles(options) {
+  return __async(this, null, function* () {
+    const files = yield fg(options.input, options.globOptions);
+    const produce = files.map((file) => __async(this, null, function* () {
+      const absolutePath = path2.resolve(file);
+      const outputPath = typeof options.output === "function" ? options.output(file) : path2.resolve(
+        options.output,
+        `${path2.basename(file, path2.extname(file))}.mdx`
+      );
+      const content = (yield readFile(absolutePath)).toString();
+      let result = generateMDX(content, __spreadValues({
+        basePath: path2.dirname(absolutePath)
+      }, options.options));
+      if (options.transformOutput) {
+        result = options.transformOutput(outputPath, result);
+      }
+      yield write(outputPath, result);
+      console.log(`Generated: ${outputPath}`);
+    }));
+    yield Promise.all(produce);
+  });
+}
+function write(file, content) {
+  return __async(this, null, function* () {
+    yield mkdir(path2.dirname(file), { recursive: true });
+    yield writeFile(file, content);
+  });
+}
+export {
+  generate,
+  generateDocumentation,
+  generateFiles,
+  generateMDX
+};

package/dist/ui/index.d.ts

@@ -0,0 +1,15 @@
+import { G as GenerateOptions } from '../base-tTG4_ClF.js';
+import 'typescript';
+
+/**
+ * **Server Component Only**
+ *
+ * Display properties in an exported interface via Type Table
+ */
+declare function AutoTypeTable({ path, name, options, }: {
+    path: string;
+    name: string;
+    options?: GenerateOptions;
+}): JSX.Element;
+
+export { AutoTypeTable };

package/dist/ui/index.js

@@ -0,0 +1,58 @@
+import {
+  generateDocumentation
+} from "../chunk-HQHQFSUJ.js";
+
+// src/ui/auto-type-table.tsx
+import { TypeTable } from "fumadocs-ui/components/type-table";
+
+// src/markdown.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { toHast } from "mdast-util-to-hast";
+import {
+  toJsxRuntime
+} from "hast-util-to-jsx-runtime";
+import * as runtime from "react/jsx-runtime";
+function renderMarkdown(md) {
+  const mdast = fromMarkdown(
+    md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1"),
+    // replace jsdoc links
+    { mdastExtensions: [gfmFromMarkdown()] }
+  );
+  return toJsxRuntime(toHast(mdast), {
+    Fragment: runtime.Fragment,
+    jsx: runtime.jsx,
+    jsxs: runtime.jsxs
+  });
+}
+
+// src/ui/auto-type-table.tsx
+import "server-only";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function AutoTypeTable({
+  path,
+  name,
+  options
+}) {
+  const output = generateDocumentation(path, name, options);
+  if (!output)
+    throw new Error(`${name} in ${path} doesn't exist`);
+  return /* @__PURE__ */ jsx2(
+    TypeTable,
+    {
+      type: Object.fromEntries(
+        output.entries.map((entry) => [
+          entry.name,
+          {
+            type: entry.type,
+            description: renderMarkdown(entry.description),
+            default: entry.tags.default || entry.tags.defaultValue
+          }
+        ])
+      )
+    }
+  );
+}
+export {
+  AutoTypeTable
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "fumadocs-typescript",
+  "version": "1.0.0",
+  "description": "Typescript Integration for Fumadocs",
+  "keywords": [
+    "NextJs",
+    "fumadocs",
+    "Docs"
+  ],
+  "homepage": "https://fumadocs.vercel.app",
+  "repository": "github:fuma-nama/fumadocs",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./ui": {
+      "import": "./dist/ui/index.js",
+      "types": "./dist/ui/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "ui": [
+        "./dist/ui/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist/*"
+  ],
+  "dependencies": {
+    "fast-glob": "^3.3.1",
+    "hast-util-to-jsx-runtime": "^2.3.0",
+    "mdast-util-from-markdown": "^2.0.0",
+    "mdast-util-gfm": "^3.0.0",
+    "mdast-util-to-hast": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.4",
+    "@types/mdast": "^4.0.3",
+    "@types/react": "18.2.0",
+    "@types/react-dom": "18.2.1",
+    "eslint-config-custom": "0.0.0",
+    "fumadocs-ui": "10.0.0",
+    "tsconfig": "0.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch",
+    "lint": "eslint .",
+    "types:check": "tsc --noEmit"
+  }
+}