ai-hero-cli 0.0.3 → 0.0.4

package/docs/tsconfig/locale.md

@@ -0,0 +1,26 @@
+---
+display: 'Locale'
+oneline: 'Set the language of the messaging from TypeScript. This does not affect emit.'
+---
+
+TypeScript supports a number of languages, however this cannot be set via the `tsconfig.json`, only
+via the host environment or the CLI flag `--locale`. E.g. `tsc --locale ru`.
+
+### Locales supported as of TypeScript 3.7
+
+| Name                  | Locale  |
+| --------------------- | ------- |
+| Brazilian Portuguese  | `pr-BR` |
+| Chinese (Simplified)  | `zh-TW` |
+| Chinese (Traditional) | `zh-CN` |
+| Czech                 | `cs-CZ` |
+| English (US)          | `en-US` |
+| French                | `fr-FR` |
+| German                | `de-DE` |
+| Italian               | `it-IT` |
+| Japanese              | `ja-JP` |
+| Korean                | `ko-KR` |
+| Polish                | `pl-PL` |
+| Russian               | `ru-RU` |
+| Spanish               | `es-ES` |
+| Turkish               | `tr-TR` |

package/docs/tsconfig/mapRoot.md

@@ -0,0 +1,18 @@
+---
+display: 'Map Root'
+oneline: 'Specify the location where debugger should locate map files instead of generated locations.'
+---
+
+Specify the location where debugger should locate map files instead of generated locations.
+This string is treated verbatim inside the source-map, for example:
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "mapRoot": "https://my-website.com/debug/sourcemaps/"
+  }
+}
+```
+
+Would declare that `index.js` will have sourcemaps at `https://my-website.com/debug/sourcemaps/index.js.map`.

package/docs/tsconfig/maxNodeModuleJsDepth.md

@@ -0,0 +1,11 @@
+---
+display: 'Max Node Module JS Depth'
+oneline: 'Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with [`allowJs`](#allowJs).'
+---
+
+The maximum dependency depth to search under `node_modules` and load JavaScript files.
+
+This flag can only be used when [`allowJs`](#allowJs) is enabled, and is used if you want to have TypeScript infer types for all of the JavaScript inside your `node_modules`.
+
+Ideally this should stay at 0 (the default), and `d.ts` files should be used to explicitly define the shape of modules.
+However, there are cases where you may want to turn this on at the expense of speed and potential accuracy.

package/docs/tsconfig/module.md

@@ -0,0 +1,125 @@
+---
+display: 'Module'
+oneline: 'Specify what module code is generated.'
+---
+
+Sets the module system for the program. See the [theory behind TypeScript’s `module` option](/docs/handbook/modules/theory.html#the-module-output-format) and [its reference page](/docs/handbook/modules/reference.html#the-module-compiler-option) for more information. You very likely want `"nodenext"` for modern Node.js projects and `preserve` or `esnext` for code that will be bundled.
+
+Changing `module` affects [`moduleResolution`](#moduleResolution) which [also has a reference page](/docs/handbook/modules/reference.html#the-moduleresolution-compiler-option).
+
+Here's some example output for this file:
+
+```ts twoslash
+// @filename: constants.ts
+export const valueOfPi = 3.142;
+// ---cut---
+// @filename: index.ts
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```
+
+#### `CommonJS`
+
+```ts twoslash
+// @showEmit
+// @module: commonjs
+// @noErrors
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```
+
+#### `UMD`
+
+```ts twoslash
+// @showEmit
+// @module: umd
+// @noErrors
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```
+
+#### `AMD`
+
+```ts twoslash
+// @showEmit
+// @module: amd
+// @noErrors
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```
+
+#### `System`
+
+```ts twoslash
+// @showEmit
+// @module: system
+// @noErrors
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```
+
+#### `ESNext`
+
+```ts twoslash
+// @showEmit
+// @module: esnext
+// @noErrors
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```
+
+#### `ES2015`/`ES6`/`ES2020`/`ES2022`
+
+```ts twoslash
+// @showEmit
+// @module: es2015
+// @noErrors
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```
+
+In addition to the base functionality of `ES2015`/`ES6`, `ES2020` adds support for [dynamic `import`s](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import), and [`import.meta`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta) while `ES2022` further adds support for [top level `await`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await#top_level_await).
+
+#### `node16`/`node18`/`nodenext`
+
+The `node16`, `node18`, and `nodenext` modes integrate with Node's [native ECMAScript Module support](https://nodejs.org/api/esm.html). The emitted JavaScript uses either `CommonJS` or `ES2020` output depending on the file extension and the value of the `type` setting in the nearest `package.json`. Module resolution also works differently. You can learn more in the [handbook](/docs/handbook/esm-node.html) and [Modules Reference](/docs/handbook/modules/reference.html#node16-node18-nodenext).
+
+- `node16` is available from TypeScript 4.7
+- `node18` is available from TypeScript 5.8 as a replacement for `node16`, with added support for import attributes.
+- `nodenext` is available from TypeScript 4.7, but its behavior changes with the latest stable versions of Node.js. As of TypeScript 5.8, `nodenext` supports `require` of ECMAScript modules.
+
+#### `preserve`
+
+In `--module preserve` ([added](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-4.html#support-for-require-calls-in---moduleresolution-bundler-and---module-preserve) in TypeScript 5.4), ECMAScript imports and exports written in input files are preserved in the output, and CommonJS-style `import x = require("...")` and `export = ...` statements are emitted as CommonJS `require` and `module.exports`. In other words, the format of each individual import or export statement is preserved, rather than being coerced into a single format for the whole compilation (or even a whole file).
+
+```ts twoslash
+// @showEmit
+// @module: preserve
+// @noErrors
+import { valueOfPi } from './constants';
+import constants = require('./constants');
+
+export const piSquared = valueOfPi * constants.valueOfPi;
+```
+
+While it’s rare to need to mix imports and require calls in the same file, this `module` mode best reflects the capabilities of most modern bundlers, as well as the Bun runtime.
+
+> Why care about TypeScript’s `module` emit with a bundler or with Bun, where you’re likely also setting `noEmit`? TypeScript’s type checking and module resolution behavior are affected by the module format that it _would_ emit. Setting `module` gives TypeScript information about how your bundler or runtime will process imports and exports, which ensures that the types you see on imported values accurately reflect what will happen at runtime or after bundling.
+
+#### `None`
+
+```ts twoslash
+// @showEmit
+// @module: none
+// @noErrors
+import { valueOfPi } from './constants';
+
+export const twoPi = valueOfPi * 2;
+```

package/docs/tsconfig/moduleDetection.md

@@ -0,0 +1,15 @@
+---
+display: 'Module Detection'
+oneline: 'Specify what method is used to detect whether a file is a script or a module.'
+---
+
+This setting controls how TypeScript determines whether a file is a
+[script or a module](/docs/handbook/modules/theory.html#scripts-and-modules-in-javascript).
+
+There are three choices:
+
+- `"auto"` (default) - TypeScript will not only look for import and export statements, but it will also check whether the `"type"` field in a `package.json` is set to `"module"` when running with [`module`](#module): `nodenext` or `node16`, and check whether the current file is a JSX file when running under [`jsx`](#jsx): `react-jsx`.
+
+- `"legacy"` - The same behavior as 4.6 and prior, usings import and export statements to determine whether a file is a module.
+
+- `"force"` - Ensures that every non-declaration file is treated as a module.

package/docs/tsconfig/moduleResolution.md

@@ -0,0 +1,13 @@
+---
+display: 'Module Resolution'
+oneline: 'Specify how TypeScript looks up a file from a given module specifier.'
+---
+
+Specify the module resolution strategy:
+
+- `'node16'` or `'nodenext'` for modern versions of Node.js. Node.js v12 and later supports both ECMAScript imports and CommonJS `require`, which resolve using different algorithms. These `moduleResolution` values, when combined with the corresponding [`module`](#module) values, picks the right algorithm for each resolution based on whether Node.js will see an `import` or `require` in the output JavaScript code.
+- `'node10'` (previously called `'node'`) for Node.js versions older than v10, which only support CommonJS `require`. You probably won't need to use `node10` in modern code.
+- `'bundler'` for use with bundlers. Like `node16` and `nodenext`, this mode supports package.json `"imports"` and `"exports"`, but unlike the Node.js resolution modes, `bundler` never requires file extensions on relative paths in imports.
+- `'classic'` was used in TypeScript before the release of 1.6. `classic` should not be used.
+
+There are reference pages explaining the [theory behind TypeScript’s module resolution](https://www.typescriptlang.org/docs/handbook/modules/theory.html#module-resolution) and the [details of each option](/docs/handbook/modules/reference.html#the-moduleresolution-compiler-option).

package/docs/tsconfig/moduleSuffixes.md

@@ -0,0 +1,26 @@
+---
+display: 'Module Suffixes'
+oneline: 'List of file name suffixes to search when resolving a module.'
+---
+
+Provides a way to override the default list of file name suffixes to search when resolving a module.
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "moduleSuffixes": [".ios", ".native", ""]
+  }
+}
+```
+
+Given the above configuration, an import like the following:
+
+```ts
+import * as foo from './foo';
+```
+
+TypeScript will look for the relative files `./foo.ios.ts`, `./foo.native.ts`, and finally `./foo.ts`.
+
+Note the empty string `""` in [`moduleSuffixes`](#moduleSuffixes) which is necessary for TypeScript to also look-up `./foo.ts`.
+
+This feature can be useful for React Native projects where each target platform can use a separate tsconfig.json with differing `moduleSuffixes`.

package/docs/tsconfig/newLine.md

@@ -0,0 +1,6 @@
+---
+display: 'New Line'
+oneline: 'Set the newline character for emitting files.'
+---
+
+Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix).

package/docs/tsconfig/noCheck.md

@@ -0,0 +1,6 @@
+---
+display: 'noCheck'
+oneline: 'Disable full type checking (only critical parse and emit errors will be reported).'
+---
+
+Disable full type checking (only critical parse and emit errors will be reported).

package/docs/tsconfig/noEmit.md

@@ -0,0 +1,10 @@
+---
+display: 'No Emit'
+oneline: 'Disable emitting files from a compilation.'
+---
+
+Do not emit compiler output files like JavaScript source code, source-maps or declarations.
+
+This makes room for another tool like [Babel](https://babeljs.io), or [swc](https://github.com/swc-project/swc) to handle converting the TypeScript file to a file which can run inside a JavaScript environment.
+
+You can then use TypeScript as a tool for providing editor integration, and as a source code type-checker.

package/docs/tsconfig/noEmitHelpers.md

@@ -0,0 +1,38 @@
+---
+display: 'No Emit Helpers'
+oneline: 'Disable generating custom helper functions like `__extends` in compiled output.'
+---
+
+Instead of importing helpers with [`importHelpers`](#importHelpers), you can provide implementations in the global scope for the helpers you use and completely turn off emitting of helper functions.
+
+For example, using this `async` function in ES5 requires a `await`-like function and `generator`-like function to run:
+
+```ts twoslash
+const getAPI = async (url: string) => {
+  // Get API
+  return {};
+};
+```
+
+Which creates quite a lot of JavaScript:
+
+```ts twoslash
+// @showEmit
+// @target: ES5
+const getAPI = async (url: string) => {
+  // Get API
+  return {};
+};
+```
+
+Which can be switched out with your own globals via this flag:
+
+```ts twoslash
+// @showEmit
+// @target: ES5
+// @noEmitHelpers
+const getAPI = async (url: string) => {
+  // Get API
+  return {};
+};
+```

package/docs/tsconfig/noEmitOnError.md

@@ -0,0 +1,8 @@
+---
+display: 'No Emit On Error'
+oneline: 'Disable emitting files if any type checking errors are reported.'
+---
+
+Do not emit compiler output files like JavaScript source code, source-maps or declarations if any errors were reported.
+
+This defaults to `false`, making it easier to work with TypeScript in a watch-like environment where you may want to see results of changes to your code in another environment before making sure all errors are resolved.

package/docs/tsconfig/noErrorTruncation.md

@@ -0,0 +1,45 @@
+---
+display: 'No Error Truncation'
+oneline: 'Disable truncating types in error messages.'
+---
+
+Do not truncate error messages.
+
+With `false`, the default.
+
+```ts twoslash
+// @errors: 2322 2454
+var x: {
+  propertyWithAnExceedinglyLongName1: string;
+  propertyWithAnExceedinglyLongName2: string;
+  propertyWithAnExceedinglyLongName3: string;
+  propertyWithAnExceedinglyLongName4: string;
+  propertyWithAnExceedinglyLongName5: string;
+  propertyWithAnExceedinglyLongName6: string;
+  propertyWithAnExceedinglyLongName7: string;
+  propertyWithAnExceedinglyLongName8: string;
+};
+
+// String representation of type of 'x' should be truncated in error message
+var s: string = x;
+```
+
+With `true`
+
+```ts twoslash
+// @errors: 2322 2454
+// @noErrorTruncation: true
+var x: {
+  propertyWithAnExceedinglyLongName1: string;
+  propertyWithAnExceedinglyLongName2: string;
+  propertyWithAnExceedinglyLongName3: string;
+  propertyWithAnExceedinglyLongName4: string;
+  propertyWithAnExceedinglyLongName5: string;
+  propertyWithAnExceedinglyLongName6: string;
+  propertyWithAnExceedinglyLongName7: string;
+  propertyWithAnExceedinglyLongName8: string;
+};
+
+// String representation of type of 'x' should be truncated in error message
+var s: string = x;
+```

package/docs/tsconfig/noFallthroughCasesInSwitch.md

@@ -0,0 +1,22 @@
+---
+display: 'No Fallthrough Cases In Switch'
+oneline: 'Enable error reporting for fallthrough cases in switch statements.'
+---
+
+Report errors for fallthrough cases in switch statements.
+Ensures that any non-empty case inside a switch statement includes either `break`, `return`, or `throw`.
+This means you won't accidentally ship a case fallthrough bug.
+
+```ts twoslash
+// @noFallthroughCasesInSwitch
+// @errors: 7029
+const a: number = 6;
+
+switch (a) {
+  case 0:
+    console.log('even');
+  case 1:
+    console.log('odd');
+    break;
+}
+```

package/docs/tsconfig/noImplicitAny.md

@@ -0,0 +1,26 @@
+---
+display: 'No Implicit Any'
+oneline: 'Enable error reporting for expressions and declarations with an implied `any` type.'
+---
+
+In some cases where no type annotations are present, TypeScript will fall back to a type of `any` for a variable when it cannot infer the type.
+
+This can cause some errors to be missed, for example:
+
+```ts twoslash
+// @noImplicitAny: false
+function fn(s) {
+  // No error?
+  console.log(s.subtr(3));
+}
+fn(42);
+```
+
+Turning on `noImplicitAny` however TypeScript will issue an error whenever it would have inferred `any`:
+
+```ts twoslash
+// @errors: 7006
+function fn(s) {
+  console.log(s.subtr(3));
+}
+```

package/docs/tsconfig/noImplicitOverride.md

@@ -0,0 +1,66 @@
+---
+display: 'No Implicit Override'
+oneline: 'Ensure overriding members in derived classes are marked with an override modifier.'
+---
+
+When working with classes which use inheritance, it's possible for a sub-class to get "out of sync" with the functions it overloads when they are renamed in the base class.
+
+For example, imagine you are modeling a music album syncing system:
+
+```ts twoslash
+class Album {
+  download() {
+    // Default behavior
+  }
+}
+
+class SharedAlbum extends Album {
+  download() {
+    // Override to get info from many sources
+  }
+}
+```
+
+Then when you add support for machine-learning generated playlists, you refactor the `Album` class to have a 'setup' function instead:
+
+```ts twoslash
+class Album {
+  setup() {
+    // Default behavior
+  }
+}
+
+class MLAlbum extends Album {
+  setup() {
+    // Override to get info from algorithm
+  }
+}
+
+class SharedAlbum extends Album {
+  download() {
+    // Override to get info from many sources
+  }
+}
+```
+
+In this case, TypeScript has provided no warning that `download` on `SharedAlbum` _expected_ to override a function in the base class.
+
+Using `noImplicitOverride` you can ensure that the sub-classes never go out of sync, by ensuring that functions which override include the keyword `override`.
+
+The following example has `noImplicitOverride` enabled, and you can see the error received when `override` is missing:
+
+```ts twoslash
+// @noImplicitOverride
+// @errors: 4114
+class Album {
+  setup() {}
+}
+
+class MLAlbum extends Album {
+  override setup() {}
+}
+
+class SharedAlbum extends Album {
+  setup() {}
+}
+```

package/docs/tsconfig/noImplicitReturns.md

@@ -0,0 +1,17 @@
+---
+display: 'No Implicit Returns'
+oneline: 'Enable error reporting for codepaths that do not explicitly return in a function.'
+---
+
+When enabled, TypeScript will check all code paths in a function to ensure they return a value.
+
+```ts twoslash
+// @errors: 2366 2322
+function lookupHeadphonesManufacturer(color: 'blue' | 'black'): string {
+  if (color === 'blue') {
+    return 'beats';
+  } else {
+    ('bose');
+  }
+}
+```

package/docs/tsconfig/noImplicitThis.md

@@ -0,0 +1,28 @@
+---
+display: 'No Implicit This'
+oneline: 'Enable error reporting when `this` is given the type `any`.'
+---
+
+Raise error on 'this' expressions with an implied 'any' type.
+
+For example, the class below returns a function which tries to access `this.width` and `this.height` – but the context
+for `this` inside the function inside `getAreaFunction` is not the instance of the Rectangle.
+
+```ts twoslash
+// @errors: 2683
+class Rectangle {
+  width: number;
+  height: number;
+
+  constructor(width: number, height: number) {
+    this.width = width;
+    this.height = height;
+  }
+
+  getAreaFunction() {
+    return function () {
+      return this.width * this.height;
+    };
+  }
+}
+```

package/docs/tsconfig/noImplicitUseStrict.md

@@ -0,0 +1,7 @@
+---
+display: 'No Implicit Use Strict'
+oneline: "Disable adding 'use strict' directives in emitted JavaScript files."
+---
+
+You shouldn't need this. By default, when emitting a module file to a non-ES6 target, TypeScript emits a `"use strict";` prologue at the top of the file.
+This setting disables the prologue.

package/docs/tsconfig/noLib.md

@@ -0,0 +1,9 @@
+---
+display: 'No Lib'
+oneline: 'Disable including any library files, including the default lib.d.ts.'
+---
+
+Disables the automatic inclusion of any library files.
+If this option is set, `lib` is ignored.
+
+TypeScript _cannot_ compile anything without a set of interfaces for key primitives like: `Array`, `Boolean`, `Function`, `IArguments`, `Number`, `Object`, `RegExp`, and `String`. It is expected that if you use `noLib` you will be including your own type definitions for these.

package/docs/tsconfig/noPropertyAccessFromIndexSignature.md

@@ -0,0 +1,57 @@
+---
+display: 'No Property Access From Index Signature'
+oneline: 'Enforces using indexed accessors for keys declared using an indexed type.'
+---
+
+This setting ensures consistency between accessing a field via the "dot" (`obj.key`) syntax, and "indexed" (`obj["key"]`) and the way which the property is declared in the type.
+
+Without this flag, TypeScript will allow you to use the dot syntax to access fields which are not defined:
+
+```ts twoslash
+// @errors: 4111
+declare function getSettings(): GameSettings;
+// ---cut---
+interface GameSettings {
+  // Known up-front properties
+  speed: 'fast' | 'medium' | 'slow';
+  quality: 'high' | 'low';
+
+  // Assume anything unknown to the interface
+  // is a string.
+  [key: string]: string;
+}
+
+const settings = getSettings();
+settings.speed;
+//       ^?
+settings.quality;
+//       ^?
+
+// Unknown key accessors are allowed on
+// this object, and are `string`
+settings.username;
+//       ^?
+```
+
+Turning the flag on will raise an error because the unknown field uses dot syntax instead of indexed syntax.
+
+```ts twoslash
+// @errors: 4111
+// @noPropertyAccessFromIndexSignature
+declare function getSettings(): GameSettings;
+interface GameSettings {
+  speed: 'fast' | 'medium' | 'slow';
+  quality: 'high' | 'low';
+  [key: string]: string;
+}
+// ---cut---
+const settings = getSettings();
+settings.speed;
+settings.quality;
+
+// This would need to be settings["username"];
+settings.username;
+//       ^?
+```
+
+The goal of this flag is to signal intent in your calling syntax about how certain you are this property exists.

package/docs/tsconfig/noResolve.md

@@ -0,0 +1,9 @@
+---
+display: 'No Resolve'
+oneline: 'Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project.'
+---
+
+By default, TypeScript will examine the initial set of files for `import` and `<reference` directives and add these resolved files to your program.
+
+If `noResolve` is set, this process doesn't happen.
+However, `import` statements are still checked to see if they resolve to a valid module, so you'll need to make sure this is satisfied by some other means.

package/docs/tsconfig/noStrictGenericChecks.md

@@ -0,0 +1,20 @@
+---
+display: 'No Strict Generic Checks'
+oneline: 'Disable strict checking of generic signatures in function types.'
+---
+
+TypeScript will unify type parameters when comparing two generic functions.
+
+```ts twoslash
+// @errors: 2322
+
+type A = <T, U>(x: T, y: U) => [T, U];
+type B = <S>(x: S, y: S) => [S, S];
+
+function f(a: A, b: B) {
+  b = a; // Ok
+  a = b; // Error
+}
+```
+
+This flag can be used to remove that check.