typedoc 0.26.10 → 0.27.0-beta.0

package/dist/lib/utils/entry-point.js

@@ -1,49 +1,17 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntryPointStrategy = void 0;
-exports.getEntryPoints = getEntryPoints;
-exports.getDocumentEntryPoints = getDocumentEntryPoints;
-exports.getWatchEntryPoints = getWatchEntryPoints;
-exports.getPackageDirectories = getPackageDirectories;
-exports.getExpandedEntryPointsForPaths = getExpandedEntryPointsForPaths;
-const path_1 = require("path");
-const typescript_1 = __importDefault(require("typescript"));
-const FS = __importStar(require("fs"));
-const package_manifest_1 = require("./package-manifest");
-const paths_1 = require("./paths");
-const fs_1 = require("./fs");
-const general_1 = require("./general");
+import { dirname, join, relative, resolve } from "path";
+import ts from "typescript";
+import * as FS from "fs";
+import { expandPackages } from "./package-manifest.js";
+import { createMinimatch, matchesAny, nicePath, normalizePath, } from "./paths.js";
+import { deriveRootDir, discoverPackageJson, getCommonDirectory, glob, isDir, } from "./fs.js";
+import { assertNever } from "./general.js";
+import { resolveAllExports } from "resolve-import/resolve-all-exports";
+import { fileURLToPath } from "url";
 /**
  * Defines how entry points are interpreted.
  * @enum
  */
-exports.EntryPointStrategy = {
+export const EntryPointStrategy = {
     /**
      * The default behavior in v0.22+, expects all provided entry points as being part of a single program.
      * Any directories included in the entry point list will result in `dir/index.([cm][tj]s|[tj]sx?)` being used.
@@ -64,7 +32,68 @@ exports.EntryPointStrategy = {
      */
     Merge: "merge",
 };
-function getEntryPoints(logger, options) {
+export async function inferEntryPoints(logger, options) {
+    const packageJson = discoverPackageJson(process.cwd());
+    if (!packageJson) {
+        logger.warn(logger.i18n.no_entry_points_provided());
+        return [];
+    }
+    const entries = await resolveAllExports(packageJson.file, {
+        conditions: ["typedoc", "import", "node"],
+    });
+    const pathEntries = Object.entries(entries).map(([k, v]) => {
+        if (typeof v === "object") {
+            return [k, fileURLToPath(v)];
+        }
+        return [k, v];
+    });
+    // resolveAllExports doesn't create a fake export for "main"
+    // so do that here if we don't have any exports.
+    if (pathEntries.length === 0) {
+        if ("main" in packageJson.content &&
+            typeof packageJson.content["main"] === "string") {
+            pathEntries.push([
+                ".",
+                resolve(dirname(packageJson.file), packageJson.content["main"]),
+            ]);
+        }
+    }
+    const entryPoints = [];
+    const programs = getEntryPrograms(pathEntries.map((p) => p[1]), logger, options);
+    // See also: addInferredDeclarationMapPaths in ReflectionSymbolId
+    const jsToTsSource = new Map();
+    for (const program of programs) {
+        const opts = program.getCompilerOptions();
+        const rootDir = opts.rootDir || getCommonDirectory(program.getRootFileNames());
+        const outDir = opts.outDir || rootDir;
+        for (const tsFile of program.getRootFileNames()) {
+            const jsFile = normalizePath(resolve(outDir, relative(rootDir, tsFile)).replace(/\.([cm]?)[tj]sx?$/, ".$1js"));
+            jsToTsSource.set(jsFile, tsFile);
+        }
+    }
+    for (const [name, path] of pathEntries) {
+        // Strip leading ./ from the display name
+        const displayName = name.replace(/^\.\/?/, "");
+        const targetPath = jsToTsSource.get(path) || path;
+        const program = programs.find((p) => p.getSourceFile(targetPath));
+        if (program) {
+            entryPoints.push({
+                displayName,
+                program,
+                sourceFile: program.getSourceFile(targetPath),
+            });
+        }
+        else if (/\.[cm]?js$/.test(path)) {
+            logger.warn(logger.i18n.failed_to_resolve_0_to_ts_path(nicePath(path)));
+        }
+    }
+    if (entryPoints.length === 0) {
+        logger.warn(logger.i18n.no_entry_points_provided());
+        return [];
+    }
+    return entryPoints;
+}
+export function getEntryPoints(logger, options) {
     if (!options.isSet("entryPoints")) {
         logger.warn(logger.i18n.no_entry_points_provided());
         return [];
@@ -79,18 +108,18 @@ function getEntryPoints(logger, options) {
     let result;
     const strategy = options.getValue("entryPointStrategy");
     switch (strategy) {
-        case exports.EntryPointStrategy.Resolve:
+        case EntryPointStrategy.Resolve:
             result = getEntryPointsForPaths(logger, expandGlobs(entryPoints, exclude, logger), options);
             break;
-        case exports.EntryPointStrategy.Expand:
+        case EntryPointStrategy.Expand:
             result = getExpandedEntryPointsForPaths(logger, expandGlobs(entryPoints, exclude, logger), options);
             break;
-        case exports.EntryPointStrategy.Merge:
-        case exports.EntryPointStrategy.Packages:
+        case EntryPointStrategy.Merge:
+        case EntryPointStrategy.Packages:
             // Doesn't really have entry points in the traditional way of how TypeDoc has dealt with them.
             return [];
         default:
-            (0, general_1.assertNever)(strategy);
+            assertNever(strategy);
     }
     if (result.length === 0) {
         logger.error(logger.i18n.unable_to_find_any_entry_points());
@@ -104,7 +133,7 @@ function getEntryPoints(logger, options) {
  *
  * @returns A list of `.md` files to include in the documentation as documents.
  */
-function getDocumentEntryPoints(logger, options) {
+export function getDocumentEntryPoints(logger, options) {
     const docGlobs = options.getValue("projectDocuments");
     if (docGlobs.length === 0) {
         return [];
@@ -114,34 +143,34 @@ function getDocumentEntryPoints(logger, options) {
     // that have at some point or another been used for markdown: https://superuser.com/a/285878
     const supportedFileRegex = /\.(md|markdown)$/;
     const expanded = expandInputFiles(logger, docPaths, options, supportedFileRegex);
-    const baseDir = options.getValue("basePath") || (0, fs_1.deriveRootDir)(expanded);
+    const baseDir = options.getValue("basePath") || deriveRootDir(expanded);
     return expanded.map((path) => {
         return {
-            displayName: (0, path_1.relative)(baseDir, path).replace(/\.[^.]+$/, ""),
+            displayName: relative(baseDir, path).replace(/\.[^.]+$/, ""),
             path,
         };
     });
 }
-function getWatchEntryPoints(logger, options, program) {
+export function getWatchEntryPoints(logger, options, program) {
     let result;
     const entryPoints = options.getValue("entryPoints");
     const exclude = options.getValue("exclude");
     const strategy = options.getValue("entryPointStrategy");
     switch (strategy) {
-        case exports.EntryPointStrategy.Resolve:
+        case EntryPointStrategy.Resolve:
             result = getEntryPointsForPaths(logger, expandGlobs(entryPoints, exclude, logger), options, [program]);
             break;
-        case exports.EntryPointStrategy.Expand:
+        case EntryPointStrategy.Expand:
             result = getExpandedEntryPointsForPaths(logger, expandGlobs(entryPoints, exclude, logger), options, [program]);
             break;
-        case exports.EntryPointStrategy.Packages:
+        case EntryPointStrategy.Packages:
             logger.error(logger.i18n.watch_does_not_support_packages_mode());
             break;
-        case exports.EntryPointStrategy.Merge:
+        case EntryPointStrategy.Merge:
             logger.error(logger.i18n.watch_does_not_support_merge_mode());
             break;
         default:
-            (0, general_1.assertNever)(strategy);
+            assertNever(strategy);
     }
     if (result && result.length === 0) {
         logger.error(logger.i18n.unable_to_find_any_entry_points());
@@ -149,25 +178,25 @@ function getWatchEntryPoints(logger, options, program) {
     }
     return result;
 }
-function getPackageDirectories(logger, options, packageGlobPaths) {
-    const exclude = (0, paths_1.createMinimatch)(options.getValue("exclude"));
-    const rootDir = (0, fs_1.deriveRootDir)(packageGlobPaths);
+export function getPackageDirectories(logger, options, packageGlobPaths) {
+    const exclude = createMinimatch(options.getValue("exclude"));
+    const rootDir = deriveRootDir(packageGlobPaths);
     // packages arguments are workspace tree roots, or glob patterns
     // This expands them to leave only leaf packages
-    return (0, package_manifest_1.expandPackages)(logger, rootDir, packageGlobPaths, exclude);
+    return expandPackages(logger, rootDir, packageGlobPaths, exclude);
 }
 function getModuleName(fileName, baseDir) {
-    return (0, paths_1.normalizePath)((0, path_1.relative)(baseDir, fileName)).replace(/(\/index)?(\.d)?\.([cm][tj]s|[tj]sx?)$/, "");
+    return normalizePath(relative(baseDir, fileName)).replace(/(\/index)?(\.d)?\.([cm][tj]s|[tj]sx?)$/, "");
 }
 /**
  * Converts a list of file-oriented paths in to DocumentationEntryPoints for conversion.
  * This is in contrast with the package-oriented `getEntryPointsForPackages`
  */
 function getEntryPointsForPaths(logger, inputFiles, options, programs = getEntryPrograms(inputFiles, logger, options)) {
-    const baseDir = options.getValue("basePath") || (0, fs_1.deriveRootDir)(inputFiles);
+    const baseDir = options.getValue("basePath") || deriveRootDir(inputFiles);
     const entryPoints = [];
     let expandSuggestion = true;
-    entryLoop: for (const fileOrDir of inputFiles.map(paths_1.normalizePath)) {
+    entryLoop: for (const fileOrDir of inputFiles.map(normalizePath)) {
         const toCheck = [fileOrDir];
         if (!/\.([cm][tj]s|[tj]sx?)$/.test(fileOrDir)) {
             toCheck.push(`${fileOrDir}/index.ts`, `${fileOrDir}/index.cts`, `${fileOrDir}/index.mts`, `${fileOrDir}/index.tsx`, `${fileOrDir}/index.js`, `${fileOrDir}/index.cjs`, `${fileOrDir}/index.mjs`, `${fileOrDir}/index.jsx`);
@@ -177,7 +206,7 @@ function getEntryPointsForPaths(logger, inputFiles, options, programs = getEntry
                 const sourceFile = program.getSourceFile(check);
                 if (sourceFile) {
                     entryPoints.push({
-                        displayName: getModuleName((0, path_1.resolve)(check), baseDir),
+                        displayName: getModuleName(resolve(check), baseDir),
                         sourceFile,
                         program,
                     });
@@ -185,15 +214,15 @@ function getEntryPointsForPaths(logger, inputFiles, options, programs = getEntry
                 }
             }
         }
-        logger.warn(logger.i18n.entry_point_0_not_in_program((0, paths_1.nicePath)(fileOrDir)));
-        if (expandSuggestion && (0, fs_1.isDir)(fileOrDir)) {
+        logger.warn(logger.i18n.entry_point_0_not_in_program(nicePath(fileOrDir)));
+        if (expandSuggestion && isDir(fileOrDir)) {
             expandSuggestion = false;
             logger.info(logger.i18n.use_expand_or_glob_for_files_in_dir());
         }
     }
     return entryPoints;
 }
-function getExpandedEntryPointsForPaths(logger, inputFiles, options, programs = getEntryPrograms(inputFiles, logger, options)) {
+export function getExpandedEntryPointsForPaths(logger, inputFiles, options, programs = getEntryPrograms(inputFiles, logger, options)) {
     const compilerOptions = options.getCompilerOptions();
     const supportedFileRegex = compilerOptions.allowJs || compilerOptions.checkJs
         ? /\.([cm][tj]s|[tj]sx?)$/
@@ -201,23 +230,23 @@ function getExpandedEntryPointsForPaths(logger, inputFiles, options, programs =
     return getEntryPointsForPaths(logger, expandInputFiles(logger, inputFiles, options, supportedFileRegex), options, programs);
 }
 function expandGlobs(inputFiles, exclude, logger) {
-    const excludePatterns = (0, paths_1.createMinimatch)(exclude);
-    const base = (0, fs_1.deriveRootDir)(inputFiles);
+    const excludePatterns = createMinimatch(exclude);
+    const base = deriveRootDir(inputFiles);
     const result = inputFiles.flatMap((entry) => {
-        const result = (0, fs_1.glob)(entry, base, {
+        const result = glob(entry, base, {
             includeDirectories: true,
             followSymlinks: true,
         });
-        const filtered = result.filter((file) => file === entry || !(0, paths_1.matchesAny)(excludePatterns, file));
+        const filtered = result.filter((file) => file === entry || !matchesAny(excludePatterns, file));
         if (result.length === 0) {
-            logger.warn(logger.i18n.glob_0_did_not_match_any_files((0, paths_1.nicePath)(entry)));
+            logger.warn(logger.i18n.glob_0_did_not_match_any_files(nicePath(entry)));
         }
         else if (filtered.length === 0) {
-            logger.warn(logger.i18n.entry_point_0_did_not_match_any_files_after_exclude((0, paths_1.nicePath)(entry)));
+            logger.warn(logger.i18n.entry_point_0_did_not_match_any_files_after_exclude(nicePath(entry)));
         }
-        else {
-            logger.verbose(`Expanded ${(0, paths_1.nicePath)(entry)} to:\n\t${filtered
-                .map(paths_1.nicePath)
+        else if (filtered.length !== 1) {
+            logger.verbose(`Expanded ${nicePath(entry)} to:\n\t${filtered
+                .map(nicePath)
                 .join("\n\t")}`);
         }
         return filtered;
@@ -228,11 +257,11 @@ function getEntryPrograms(inputFiles, logger, options) {
     const noTsConfigFound = options.getFileNames().length === 0 &&
         options.getProjectReferences().length === 0;
     const rootProgram = noTsConfigFound
-        ? typescript_1.default.createProgram({
+        ? ts.createProgram({
             rootNames: inputFiles,
             options: options.getCompilerOptions(),
         })
-        : typescript_1.default.createProgram({
+        : ts.createProgram({
             rootNames: options.getFileNames(),
             options: options.getCompilerOptions(),
             projectReferences: options.getProjectReferences(),
@@ -246,7 +275,7 @@ function getEntryPrograms(inputFiles, logger, options) {
         for (const ref of resolvedReferences ?? []) {
             if (!ref)
                 continue; // This indicates bad configuration... will be reported later.
-            programs.push(typescript_1.default.createProgram({
+            programs.push(ts.createProgram({
                 options: options.fixCompilerOptions(ref.commandLine.options),
                 rootNames: ref.commandLine.fileNames,
                 projectReferences: ref.commandLine.projectReferences,
@@ -267,7 +296,7 @@ function getEntryPrograms(inputFiles, logger, options) {
  */
 function expandInputFiles(logger, entryPoints, options, supportedFile) {
     const files = [];
-    const exclude = (0, paths_1.createMinimatch)(options.getValue("exclude"));
+    const exclude = createMinimatch(options.getValue("exclude"));
     function add(file, entryPoint) {
         let stats;
         try {
@@ -283,18 +312,18 @@ function expandInputFiles(logger, entryPoints, options, supportedFile) {
         }
         if (fileIsDir) {
             FS.readdirSync(file).forEach((next) => {
-                add((0, path_1.join)(file, next), false);
+                add(join(file, next), false);
             });
         }
         else if (supportedFile.test(file)) {
-            if (!entryPoint && (0, paths_1.matchesAny)(exclude, file)) {
+            if (!entryPoint && matchesAny(exclude, file)) {
                 return;
             }
-            files.push((0, paths_1.normalizePath)(file));
+            files.push(normalizePath(file));
         }
     }
     entryPoints.forEach((file) => {
-        const resolved = (0, path_1.resolve)(file);
+        const resolved = resolve(file);
         if (!FS.existsSync(resolved)) {
             logger.warn(logger.i18n.entry_point_0_did_not_exist(file));
             return;

package/dist/lib/utils/enum.js

@@ -1,12 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnumFlags = getEnumFlags;
-exports.removeFlag = removeFlag;
-exports.hasAllFlags = hasAllFlags;
-exports.hasAnyFlag = hasAnyFlag;
-exports.debugFlags = debugFlags;
-exports.getEnumKeys = getEnumKeys;
-function getEnumFlags(flags) {
+export function getEnumFlags(flags) {
     const result = [];
     for (let i = 1; i <= flags; i <<= 1) {
         if (flags & i) {
@@ -16,20 +8,20 @@ function getEnumFlags(flags) {
     return result;
 }
 // T & {} reduces inference priority
-function removeFlag(flag, remove) {
+export function removeFlag(flag, remove) {
     return (flag & ~remove);
 }
-function hasAllFlags(flags, check) {
+export function hasAllFlags(flags, check) {
     return (flags & check) === check;
 }
-function hasAnyFlag(flags, check) {
+export function hasAnyFlag(flags, check) {
     return (flags & check) !== 0;
 }
-function debugFlags(Enum, flags) {
+export function debugFlags(Enum, flags) {
     return getEnumKeys(Enum).filter((key) => (Enum[key] & flags) === Enum[key]);
 }
 // Note: String enums are not handled.
-function getEnumKeys(Enum) {
+export function getEnumKeys(Enum) {
     const E = Enum;
     return Object.keys(E).filter((k) => E[E[k]] === k);
 }

package/dist/lib/utils/events.js

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventDispatcher = void 0;
-const array_1 = require("./array");
+import { insertPrioritySorted } from "./array.js";
 /**
  * Intentionally very simple event emitter.
  *
  * @privateRemarks
  * This is essentially a stripped down copy of EventHooks in hooks.ts.
  */
-class EventDispatcher {
-    constructor() {
-        // Function is *usually* not a good type to use, but here it lets us specify stricter
-        // contracts in the methods while not casting everywhere this is used.
-        this._listeners = new Map();
-    }
+export class EventDispatcher {
+    // Function is *usually* not a good type to use, but here it lets us specify stricter
+    // contracts in the methods while not casting everywhere this is used.
+    _listeners = new Map();
     /**
      * Starts listening to an event.
      * @param event the event to listen to.
@@ -22,7 +17,7 @@ class EventDispatcher {
      */
     on(event, listener, priority = 0) {
         const list = (this._listeners.get(event) || []).slice();
-        (0, array_1.insertPrioritySorted)(list, { listener, priority });
+        insertPrioritySorted(list, { listener, priority });
         this._listeners.set(event, list);
     }
     /**
@@ -51,4 +46,3 @@ class EventDispatcher {
         }
     }
 }
-exports.EventDispatcher = EventDispatcher;