typedoc 0.28.18 → 0.28.20

package/README.md

@@ -17,14 +17,15 @@ npm install typedoc --save-dev
 ## Usage
 
 To generate documentation TypeDoc needs to know your project entry point and TypeScript
-compiler options. It will automatically try to find your `tsconfig.json` file, so you can
-just specify the entry point of your library:
+compiler options. It will automatically try to find your `tsconfig.json` file and figure
+out your entry points from `package.json`, so you can probably run TypeDoc without any options:
 
 ```text
-typedoc src/index.ts
+typedoc
 ```
 
-If you have multiple entry points, specify each of them.
+If TypeDoc does not automatically choose the entry points you wanted, you can specify them
+manually:
 
 ```text
 typedoc package1/index.ts package2/index.ts
@@ -40,26 +41,24 @@ and merge the results together into a single site by setting `entryPointStrategy
 requires configuration to be present in each directory to specify the entry points. For an example setup, see
 https://github.com/Gerrit0/typedoc-packages-example
 
-### Arguments
+### Options
 
-For a complete list of the command line arguments run `typedoc --help` or visit
-[our website](https://typedoc.org/options/).
+TypeDoc can be configured with command line arguments or a configuration file.
+Visit [TypeDoc's site](https://typedoc.org/documents/Options.html) for a list
+of available options. Some commonly used options are:
 
 - `--out <path/to/documentation/>`<br>
   Specifies the location the documentation should be written to. Defaults to `./docs`
 - `--json <path/to/output.json>`<br>
   Specifies the location and file name a json file describing the project is
-  written to. When specified no documentation will be generated unless `--out` is also
+  written to. When specified no HTML documentation will be generated unless `--out` is also
   specified.
 - `--options`<br>
   Specify a json option file that should be loaded. If not specified TypeDoc
-  will look for 'typedoc.json' in the current directory.
+  will check for several common file names in the current directory.
 - `--tsconfig <path/to/tsconfig.json>`<br>
   Specify a typescript config file that should be loaded. If not
-  specified TypeDoc will look for 'tsconfig.json' in the current directory.
-- `--exclude <pattern>`<br>
-  Exclude files by the given pattern when a path is provided as source.
-  Supports standard minimatch patterns.
+  specified TypeDoc will look for `tsconfig.json` in the current directory.
 
 #### Theming
 

package/bin/typedoc

@@ -4,7 +4,7 @@
 const { fork } = require("child_process");
 
 function main() {
-    fork(__dirname + "/../dist/lib/cli.js", process.argv.slice(2), {
+    fork(__dirname + "/../dist/cli.js", process.argv.slice(2), {
         stdio: "inherit",
     }).on("exit", (code) => {
         // Watch restart required? Fork a new child

package/dist/browser-locales/fr.d.ts

@@ -0,0 +1,2 @@
+const translations: Record<string, string>;
+export default translations;

package/dist/browser-locales/fr.js

@@ -0,0 +1,62 @@
+export default {
+    "serialized_project_referenced_0_not_part_of_project": "Le projet sérialisé référence la réflexion {0}, qui ne fait pas partie du projet",
+    "kind_project": "Projet",
+    "kind_module": "Module",
+    "kind_namespace": "Espace de noms",
+    "kind_enum": "Énumération",
+    "kind_enum_member": "Membre d'énumération",
+    "kind_variable": "Variable",
+    "kind_function": "Fonction",
+    "kind_class": "Classe",
+    "kind_interface": "Interface",
+    "kind_constructor": "Constructeur",
+    "kind_property": "Propriété",
+    "kind_method": "Méthode",
+    "kind_call_signature": "Signature d'appel",
+    "kind_index_signature": "Signature d'index",
+    "kind_constructor_signature": "Signature de constructeur",
+    "kind_parameter": "Paramètre",
+    "kind_type_literal": "Littéral de type",
+    "kind_type_parameter": "Paramètre de type",
+    "kind_accessor": "Accesseur",
+    "kind_get_signature": "Signature d'obtention",
+    "kind_set_signature": "Signature de définition",
+    "kind_type_alias": "Alias de type",
+    "kind_reference": "Référence",
+    "kind_document": "Document",
+    "kind_plural_project": "Projets",
+    "kind_plural_module": "Modules",
+    "kind_plural_namespace": "Espaces de noms",
+    "kind_plural_enum": "Énumérations",
+    "kind_plural_enum_member": "Membres d'énumération",
+    "kind_plural_variable": "Variables",
+    "kind_plural_function": "Fonctions",
+    "kind_plural_class": "Classes",
+    "kind_plural_interface": "Interfaces",
+    "kind_plural_constructor": "Constructeurs",
+    "kind_plural_property": "Propriétés",
+    "kind_plural_method": "Méthodes",
+    "kind_plural_call_signature": "Signatures d'appel",
+    "kind_plural_index_signature": "Signatures d'index",
+    "kind_plural_constructor_signature": "Signatures de constructeur",
+    "kind_plural_parameter": "Paramètres",
+    "kind_plural_type_literal": "Littéraux de type",
+    "kind_plural_type_parameter": "Paramètres de type",
+    "kind_plural_accessor": "Accesseurs",
+    "kind_plural_get_signature": "Signatures d'obtention",
+    "kind_plural_set_signature": "Signatures de définition",
+    "kind_plural_type_alias": "Alias de type",
+    "kind_plural_reference": "Références",
+    "kind_plural_document": "Documents",
+    "flag_private": "Privé",
+    "flag_protected": "Protégé",
+    "flag_public": "Public",
+    "flag_static": "Statique",
+    "flag_external": "Externe",
+    "flag_optional": "Optionnel",
+    "flag_rest": "Reste",
+    "flag_abstract": "Abstrait",
+    "flag_const": "Constante",
+    "flag_readonly": "Lecture seule",
+    "flag_inherited": "Hérité"
+}

package/dist/browser-utils.js

@@ -1,3 +1,30 @@
+// src/lib/browser-utils.ts
 export * from "#models";
-export { addTranslations, ConsoleLogger, Logger, LogLevel, MinimalSourceFile, setTranslations, translateTagName, } from "#utils";
-export { Deserializer, JSONOutput, SerializeEvent, Serializer, } from "#serialization";
+import {
+  addTranslations,
+  ConsoleLogger,
+  Logger,
+  LogLevel,
+  MinimalSourceFile,
+  setTranslations,
+  translateTagName
+} from "#utils";
+import {
+  Deserializer,
+  JSONOutput,
+  SerializeEvent,
+  Serializer
+} from "#serialization";
+export {
+  ConsoleLogger,
+  Deserializer,
+  JSONOutput,
+  LogLevel,
+  Logger,
+  MinimalSourceFile,
+  SerializeEvent,
+  Serializer,
+  addTranslations,
+  setTranslations,
+  translateTagName
+};

package/dist/cli.js

@@ -0,0 +1,111 @@
+// src/lib/cli.ts
+import * as td from "typedoc";
+var ExitCodes = {
+  Ok: 0,
+  OptionError: 1,
+  CompileError: 3,
+  ValidationError: 4,
+  OutputError: 5,
+  ExceptionThrown: 6,
+  Watching: 7
+};
+void main();
+async function main() {
+  let app;
+  try {
+    const start = Date.now();
+    app = await td.Application.bootstrapWithPlugins({}, [
+      new td.ArgumentsReader(0),
+      new td.TypeDocReader(),
+      new td.PackageJsonReader(),
+      new td.TSConfigReader(),
+      new td.ArgumentsReader(300).ignoreErrors()
+    ]);
+    const exitCode = await run(app);
+    if (exitCode !== ExitCodes.Watching) {
+      app.logger.verbose(`Full run took ${Date.now() - start}ms`);
+      logRunSummary(app.logger);
+    }
+    process.exit(exitCode);
+  } catch (error) {
+    console.error("TypeDoc exiting with unexpected error:");
+    console.error(error);
+    if (app?.options.getValue("skipErrorChecking")) {
+      console.error(
+        "Try turning off --skipErrorChecking. If TypeDoc still crashes, please report a bug."
+      );
+    }
+    process.exit(ExitCodes.ExceptionThrown);
+  }
+}
+async function run(app) {
+  if (app.options.getValue("version")) {
+    console.log(app.toString());
+    return ExitCodes.Ok;
+  }
+  if (app.options.getValue("help")) {
+    console.log(app.options.getHelp());
+    return ExitCodes.Ok;
+  }
+  if (app.options.getValue("showConfig")) {
+    console.log(app.options.getRawValues());
+    return ExitCodes.Ok;
+  }
+  if (app.logger.hasErrors()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("watch") || process.env["TYPEDOC_FORCE_WATCH"]) {
+    const continueWatching = await app.convertAndWatch(async (project2) => {
+      app.validate(project2);
+      await app.generateOutputs(project2);
+    });
+    return continueWatching ? ExitCodes.Watching : ExitCodes.OptionError;
+  }
+  const project = await app.convert();
+  if (!project) {
+    return ExitCodes.CompileError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.CompileError;
+  }
+  const preValidationWarnCount = app.logger.warningCount;
+  app.validate(project);
+  const hadValidationWarnings = app.logger.warningCount !== preValidationWarnCount || app.logger.validationWarningCount != 0;
+  if (app.logger.hasErrors()) {
+    return ExitCodes.ValidationError;
+  }
+  if (hadValidationWarnings && (app.options.getValue("treatWarningsAsErrors") || app.options.getValue("treatValidationWarningsAsErrors"))) {
+    return ExitCodes.ValidationError;
+  }
+  if (app.options.getValue("emit") !== "none") {
+    await app.generateOutputs(project);
+    if (app.logger.hasErrors()) {
+      return ExitCodes.OutputError;
+    }
+    if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+      return ExitCodes.OutputError;
+    }
+  }
+  return ExitCodes.Ok;
+}
+function logRunSummary(logger) {
+  const { errorCount, warningCount } = logger;
+  if (errorCount) {
+    logger.error(
+      td.i18n.found_0_errors_and_1_warnings(
+        errorCount.toString(),
+        warningCount.toString()
+      )
+    );
+  } else if (warningCount) {
+    logger.warn(
+      td.i18n.found_0_errors_and_1_warnings(
+        errorCount.toString(),
+        warningCount.toString()
+      )
+    );
+  }
+}