ai-hero-cli 0.0.3 → 0.0.4

package/docs/tsconfig/allowArbitraryExtensions.md

@@ -0,0 +1,38 @@
+---
+display: 'Allow Arbitrary Extensions'
+oneline: 'Enable importing files with any extension, provided a declaration file is present.'
+---
+
+In TypeScript 5.0, when an import path ends in an extension that isn't a known JavaScript or TypeScript file extension, the compiler will look for a declaration file for that path in the form of `{file basename}.d.{extension}.ts`.
+For example, if you are using a CSS loader in a bundler project, you might want to write (or generate) declaration files for those stylesheets:
+
+```css
+/* app.css */
+.cookie-banner {
+  display: none;
+}
+```
+
+```ts
+// app.d.css.ts
+declare const css: {
+  cookieBanner: string;
+};
+export default css;
+```
+
+```ts
+// App.tsx
+import styles from './app.css';
+
+styles.cookieBanner; // string
+```
+
+By default, this import will raise an error to let you know that TypeScript doesn't understand this file type and your runtime might not support importing it.
+But if you've configured your runtime or bundler to handle it, you can suppress the error with the new `--allowArbitraryExtensions` compiler option.
+
+Note that historically, a similar effect has often been achievable by adding a declaration file named `app.css.d.ts` instead of `app.d.css.ts` - however, this just worked through Node's `require` resolution rules for CommonJS.
+Strictly speaking, the former is interpreted as a declaration file for a JavaScript file named `app.css.js`.
+Because relative files imports need to include extensions in Node's ESM support, TypeScript would error on our example in an ESM file under `--moduleResolution node16` or `nodenext`.
+
+For more information, read up [the proposal for this feature](https://github.com/microsoft/TypeScript/issues/50133) and [its corresponding pull request](https://github.com/microsoft/TypeScript/pull/51435).

package/docs/tsconfig/allowImportingTsExtensions.md

@@ -0,0 +1,9 @@
+---
+display: 'Allow Importing TS Extensions'
+oneline: 'Allow imports to include TypeScript file extensions.'
+---
+
+`--allowImportingTsExtensions` allows TypeScript files to import each other with a TypeScript-specific extension like `.ts`, `.mts`, or `.tsx`.
+
+This flag is only allowed when `--noEmit` or `--emitDeclarationOnly` is enabled, since these import paths would not be resolvable at runtime in JavaScript output files.
+The expectation here is that your resolver (e.g. your bundler, a runtime, or some other tool) is going to make these imports between `.ts` files work.

package/docs/tsconfig/allowJs.md

@@ -0,0 +1,41 @@
+---
+display: 'Allow JS'
+oneline: 'Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files.'
+---
+
+Allow JavaScript files to be imported inside your project, instead of just `.ts` and `.tsx` files. For example, this JS file:
+
+```js twoslash
+// @filename: card.js
+export const defaultCardDeck = 'Heart';
+```
+
+When imported into a TypeScript file will raise an error:
+
+```ts twoslash
+// @errors: 2307
+// @filename: card.js
+module.exports.defaultCardDeck = 'Heart';
+// ---cut---
+// @filename: index.ts
+import { defaultCardDeck } from './card';
+
+console.log(defaultCardDeck);
+```
+
+Imports fine with `allowJs` enabled:
+
+```ts twoslash
+// @filename: card.js
+module.exports.defaultCardDeck = 'Heart';
+// ---cut---
+// @allowJs
+// @filename: index.ts
+import { defaultCardDeck } from './card';
+
+console.log(defaultCardDeck);
+```
+
+This flag can be used as a way to incrementally add TypeScript files into JS projects by allowing the `.ts` and `.tsx` files to live along-side existing JavaScript files.
+
+It can also be used along-side [`declaration`](#declaration) and [`emitDeclarationOnly`](#emitDeclarationOnly) to [create declarations for JS files](/docs/handbook/declaration-files/dts-from-js.html).

package/docs/tsconfig/allowSyntheticDefaultImports.md

@@ -0,0 +1,56 @@
+---
+display: 'Allow Synthetic Default Imports'
+oneline: "Allow 'import x from y' when a module doesn't have a default export."
+---
+
+When set to true, `allowSyntheticDefaultImports` allows you to write an import like:
+
+```ts
+import React from 'react';
+```
+
+instead of:
+
+```ts
+import * as React from 'react';
+```
+
+When the module **does not** explicitly specify a default export.
+
+For example, without `allowSyntheticDefaultImports` as true:
+
+```ts twoslash
+// @errors: 1259 1192
+// @checkJs
+// @allowJs
+// @esModuleInterop: false
+// @filename: utilFunctions.js
+// @noImplicitAny: false
+const getStringLength = (str) => str.length;
+
+module.exports = {
+  getStringLength,
+};
+
+// @filename: index.ts
+import utils from './utilFunctions';
+
+const count = utils.getStringLength('Check JS');
+```
+
+This code raises an error because there isn't a `default` object which you can import. Even though it feels like it should.
+For convenience, transpilers like Babel will automatically create a default if one isn't created. Making the module look a bit more like:
+
+```js
+// @filename: utilFunctions.js
+const getStringLength = (str) => str.length;
+const allFunctions = {
+  getStringLength,
+};
+
+module.exports = allFunctions;
+module.exports.default = allFunctions;
+```
+
+This flag does not affect the JavaScript emitted by TypeScript, it's only for the type checking.
+This option brings the behavior of TypeScript in-line with Babel, where extra code is emitted to make using a default export of a module more ergonomic.

package/docs/tsconfig/allowUmdGlobalAccess.md

@@ -0,0 +1,8 @@
+---
+display: 'Allow Umd Global Access'
+oneline: 'Allow accessing UMD globals from modules.'
+---
+
+When set to true, `allowUmdGlobalAccess` lets you access UMD exports as globals from inside module files. A module file is a file that has imports and/or exports. Without this flag, using an export from a UMD module requires an import declaration.
+
+An example use case for this flag would be a web project where you know the particular library (like jQuery or Lodash) will always be available at runtime, but you can’t access it with an import.

package/docs/tsconfig/allowUnreachableCode.md

@@ -0,0 +1,40 @@
+---
+display: 'Allow Unreachable Code'
+oneline: 'Disable error reporting for unreachable code.'
+---
+
+When:
+
+- `undefined` (default) provide suggestions as warnings to editors
+- `true` unreachable code is ignored
+- `false` raises compiler errors about unreachable code
+
+These warnings are only about code which is provably unreachable due to the use of JavaScript syntax, for example:
+
+```ts
+function fn(n: number) {
+  if (n > 5) {
+    return true;
+  } else {
+    return false;
+  }
+  return true;
+}
+```
+
+With `"allowUnreachableCode": false`:
+
+```ts twoslash
+// @errors: 7027
+// @allowUnreachableCode: false
+function fn(n: number) {
+  if (n > 5) {
+    return true;
+  } else {
+    return false;
+  }
+  return true;
+}
+```
+
+This does not affect errors on the basis of code which _appears_ to be unreachable due to type analysis.

package/docs/tsconfig/allowUnusedLabels.md

@@ -0,0 +1,23 @@
+---
+display: 'Allow Unused Labels'
+oneline: 'Disable error reporting for unused labels.'
+---
+
+When:
+
+- `undefined` (default) provide suggestions as warnings to editors
+- `true` unused labels are ignored
+- `false` raises compiler errors about unused labels
+
+Labels are very rare in JavaScript and typically indicate an attempt to write an object literal:
+
+```ts twoslash
+// @errors: 7028
+// @allowUnusedLabels: false
+function verifyAge(age: number) {
+  // Forgot 'return' statement
+  if (age > 18) {
+    verified: true;
+  }
+}
+```

package/docs/tsconfig/alwaysStrict.md

@@ -0,0 +1,8 @@
+---
+display: 'Always Strict'
+oneline: "Ensure 'use strict' is always emitted."
+---
+
+Ensures that your files are parsed in the ECMAScript strict mode, and emit "use strict" for each source file.
+
+[ECMAScript strict](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Strict_mode) mode was introduced in ES5 and provides behavior tweaks to the runtime of the JavaScript engine to improve performance, and makes a set of errors throw instead of silently ignoring them.

package/docs/tsconfig/assumeChangesOnlyAffectDirectDependencies.md

@@ -0,0 +1,8 @@
+---
+display: 'Assume Changes Only Affect Direct Dependencies'
+oneline: 'Have recompiles in projects that use [`incremental`](#incremental) and `watch` mode assume that changes within a file will only affect files directly depending on it.'
+---
+
+When this option is enabled, TypeScript will avoid rechecking/rebuilding all truly possibly-affected files, and only recheck/rebuild files that have changed as well as files that directly import them.
+
+This can be considered a 'fast & loose' implementation of the watching algorithm, which can drastically reduce incremental rebuild times at the expense of having to run the full build occasionally to get all compiler error messages.

package/docs/tsconfig/baseUrl.md

@@ -0,0 +1,26 @@
+---
+display: 'Base URL'
+oneline: 'Specify the base directory to resolve bare specifier module names.'
+---
+
+Sets a base directory from which to resolve bare specifier module names. For example, in the directory structure:
+
+```
+project
+├── ex.ts
+├── hello
+│   └── world.ts
+└── tsconfig.json
+```
+
+With `"baseUrl": "./"`, TypeScript will look for files starting at the same folder as the `tsconfig.json`:
+
+```ts
+import { helloWorld } from 'hello/world';
+
+console.log(helloWorld);
+```
+
+This resolution has higher priority than lookups from `node_modules`.
+
+This feature was designed for use in conjunction with AMD module loaders in the browser, and is not recommended in any other context. As of TypeScript 4.1, `baseUrl` is no longer required to be set when using [`paths`](#paths).

package/docs/tsconfig/charset.md

@@ -0,0 +1,7 @@
+---
+display: 'Charset'
+oneline: 'No longer supported. In early versions, manually set the text encoding for reading files.'
+---
+
+In prior versions of TypeScript, this controlled what encoding was used when reading text files from disk.
+Today, TypeScript assumes UTF-8 encoding, but will correctly detect UTF-16 (BE and LE) or UTF-8 BOMs.

package/docs/tsconfig/checkJs.md

@@ -0,0 +1,40 @@
+---
+display: 'Check JS'
+oneline: 'Enable error reporting in type-checked JavaScript files.'
+---
+
+Works in tandem with [`allowJs`](#allowJs). When `checkJs` is enabled then errors are reported in JavaScript files. This is
+the equivalent of including `// @ts-check` at the top of all JavaScript files which are included in your project.
+
+For example, this is incorrect JavaScript according to the `parseFloat` type definition which comes with TypeScript:
+
+```js
+// parseFloat only takes a string
+module.exports.pi = parseFloat(3.142);
+```
+
+When imported into a TypeScript module:
+
+```ts twoslash
+// @allowJs
+// @filename: constants.js
+module.exports.pi = parseFloat(3.142);
+
+// @filename: index.ts
+import { pi } from './constants';
+console.log(pi);
+```
+
+You will not get any errors. However, if you turn on `checkJs` then you will get error messages from the JavaScript file.
+
+```ts twoslash
+// @errors: 2345
+// @allowjs: true
+// @checkjs: true
+// @filename: constants.js
+module.exports.pi = parseFloat(3.142);
+
+// @filename: index.ts
+import { pi } from './constants';
+console.log(pi);
+```

package/docs/tsconfig/clean.md

@@ -0,0 +1,6 @@
+---
+display: 'Clean'
+oneline: 'Delete the outputs of all projects.'
+---
+
+Delete the outputs of all projects

package/docs/tsconfig/composite.md

@@ -0,0 +1,17 @@
+---
+display: 'Composite'
+oneline: 'Enable constraints that allow a TypeScript project to be used with project references.'
+---
+
+The `composite` option enforces certain constraints which make it possible for build tools (including TypeScript
+itself, under `--build` mode) to quickly determine if a project has been built yet.
+
+When this setting is on:
+
+- The [`rootDir`](#rootDir) setting, if not explicitly set, defaults to the directory containing the `tsconfig.json` file.
+
+- All implementation files must be matched by an [`include`](#include) pattern or listed in the [`files`](#files) array. If this constraint is violated, `tsc` will inform you which files weren't specified.
+
+- [`declaration`](#declaration) defaults to `true`
+
+You can find documentation on TypeScript projects in [the handbook](https://www.typescriptlang.org/docs/handbook/project-references.html).

package/docs/tsconfig/customConditions.md

@@ -0,0 +1,41 @@
+---
+display: 'Custom Conditions'
+oneline: 'Conditions to set in addition to the resolver-specific defaults when resolving imports.'
+---
+
+`--customConditions` takes a list of additional [conditions](https://nodejs.org/api/packages.html#nested-conditions) that should succeed when TypeScript resolves from an [`exports`](https://nodejs.org/api/packages.html#exports) or [`imports`](https://nodejs.org/api/packages.html#imports) field of a `package.json`.
+These conditions are added to whatever existing conditions a resolver will use by default.
+
+For example, when this field is set in a `tsconfig.json` as so:
+
+```jsonc
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "moduleResolution": "bundler",
+    "customConditions": ["my-condition"],
+  },
+}
+```
+
+Any time an `exports` or `imports` field is referenced in `package.json`, TypeScript will consider conditions called `my-condition`.
+
+So when importing from a package with the following `package.json`
+
+```jsonc
+{
+  // ...
+  "exports": {
+    ".": {
+      "my-condition": "./foo.mjs",
+      "node": "./bar.mjs",
+      "import": "./baz.mjs",
+      "require": "./biz.mjs",
+    },
+  },
+}
+```
+
+TypeScript will try to look for files corresponding to `foo.mjs`.
+
+This field is only valid under the `node16`, `nodenext`, and `bundler` options for [`--moduleResolution`](#moduleResolution).

package/docs/tsconfig/declaration.md

@@ -0,0 +1,32 @@
+---
+display: 'Declaration'
+oneline: 'Generate .d.ts files from TypeScript and JavaScript files in your project.'
+---
+
+Generate `.d.ts` files for every TypeScript or JavaScript file inside your project.
+These `.d.ts` files are type definition files which describe the external API of your module.
+With `.d.ts` files, tools like TypeScript can provide intellisense and accurate types for un-typed code.
+
+When `declaration` is set to `true`, running the compiler with this TypeScript code:
+
+```ts twoslash
+export let helloWorld = 'hi';
+```
+
+Will generate an `index.js` file like this:
+
+```ts twoslash
+// @showEmit
+export let helloWorld = 'hi';
+```
+
+With a corresponding `helloWorld.d.ts`:
+
+```ts twoslash
+// @showEmittedFile: index.d.ts
+// @showEmit
+// @declaration
+export let helloWorld = 'hi';
+```
+
+When working with `.d.ts` files for JavaScript files you may want to use [`emitDeclarationOnly`](#emitDeclarationOnly) or use [`outDir`](#outDir) to ensure that the JavaScript files are not overwritten.

package/docs/tsconfig/declarationDir.md

@@ -0,0 +1,36 @@
+---
+display: 'Declaration Dir'
+oneline: 'Specify the output directory for generated declaration files.'
+---
+
+Offers a way to configure the root directory for where declaration files are emitted.
+
+```
+example
+├── index.ts
+├── package.json
+└── tsconfig.json
+```
+
+with this `tsconfig.json`:
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationDir": "./types"
+  }
+}
+```
+
+Would place the d.ts for the `index.ts` in a `types` folder:
+
+```
+example
+├── index.js
+├── index.ts
+├── package.json
+├── tsconfig.json
+└── types
+    └── index.d.ts
+```

package/docs/tsconfig/declarationMap.md

@@ -0,0 +1,9 @@
+---
+display: 'Declaration Map'
+oneline: 'Create sourcemaps for d.ts files.'
+---
+
+Generates a source map for `.d.ts` files which map back to the original `.ts` source file.
+This will allow editors such as VS Code to go to the original `.ts` file when using features like _Go to Definition_.
+
+You should strongly consider turning this on if you're using project references.

package/docs/tsconfig/diagnostics.md

@@ -0,0 +1,8 @@
+---
+display: 'Diagnostics'
+oneline: 'Output compiler performance information after building.'
+---
+
+Used to output diagnostic information for debugging. This command is a subset of [`extendedDiagnostics`](#extendedDiagnostics) which are more user-facing results, and easier to interpret.
+
+If you have been asked by a TypeScript compiler engineer to give the results using this flag in a compile, in which there is no harm in using [`extendedDiagnostics`](#extendedDiagnostics) instead.

package/docs/tsconfig/disableFilenameBasedTypeAcquisition.md

@@ -0,0 +1,16 @@
+---
+display: 'Disable Filename Based Type Acquisition'
+oneline: 'Disables inference for type acquisition by looking at filenames in a project.'
+---
+
+TypeScript's type acquisition can infer what types should be added based on filenames in a project. This means that having a file like `jquery.js` in your project would automatically download the types for JQuery from DefinitelyTyped.
+
+You can disable this via `disableFilenameBasedTypeAcquisition`.
+
+```json
+{
+  "typeAcquisition": {
+    "disableFilenameBasedTypeAcquisition": true
+  }
+}
+```

package/docs/tsconfig/disableReferencedProjectLoad.md

@@ -0,0 +1,8 @@
+---
+display: 'Disable Referenced Project Load'
+oneline: 'Reduce the number of projects loaded automatically by TypeScript.'
+---
+
+In multi-project TypeScript programs, TypeScript will load all of the available projects into memory in order to provide accurate results for editor responses which require a full knowledge graph like 'Find All References'.
+
+If your project is large, you can use the flag `disableReferencedProjectLoad` to disable the automatic loading of all projects. Instead, projects are loaded dynamically as you open files through your editor.

package/docs/tsconfig/disableSizeLimit.md

@@ -0,0 +1,6 @@
+---
+display: 'Disable Size Limit'
+oneline: 'Remove the 20mb cap on total source code size for JavaScript files in the TypeScript language server.'
+---
+
+To avoid a possible memory bloat issues when working with very large JavaScript projects, there is an upper limit to the amount of memory TypeScript will allocate. Turning this flag on will remove the limit.

package/docs/tsconfig/disableSolutionSearching.md

@@ -0,0 +1,8 @@
+---
+display: 'Disable Solution Searching'
+oneline: 'Opt a project out of multi-project reference checking when editing.'
+---
+
+When working with [composite TypeScript projects](/docs/handbook/project-references.html), this option provides a way to declare that you do not want a project to be included when using features like _find all references_ or _jump to definition_ in an editor.
+
+This flag is something you can use to increase responsiveness in large composite projects.

package/docs/tsconfig/disableSourceOfProjectReferenceRedirect.md

@@ -0,0 +1,7 @@
+---
+display: 'Disable Source Project Reference Redirect'
+oneline: 'Disable preferring source files instead of declaration files when referencing composite projects.'
+---
+
+When working with [composite TypeScript projects](/docs/handbook/project-references.html), this option provides a way to go [back to the pre-3.7](/docs/handbook/release-notes/typescript-3-7.html#build-free-editing-with-project-references) behavior where d.ts files were used to as the boundaries between modules.
+In 3.7 the source of truth is now your TypeScript files.

package/docs/tsconfig/downlevelIteration.md

@@ -0,0 +1,100 @@
+---
+display: 'Downlevel Iteration'
+oneline: 'Emit more compliant, but verbose and less performant JavaScript for iteration.'
+---
+
+Downleveling is TypeScript's term for transpiling to an older version of JavaScript.
+This flag is to enable support for a more accurate implementation of how modern JavaScript iterates through new concepts in older JavaScript runtimes.
+
+ECMAScript 6 added several new iteration primitives: the `for / of` loop (`for (el of arr)`), Array spread (`[a, ...b]`), argument spread (`fn(...args)`), and `Symbol.iterator`.
+`downlevelIteration` allows for these iteration primitives to be used more accurately in ES5 environments if a `Symbol.iterator` implementation is present.
+
+#### Example: Effects on `for / of`
+
+With this TypeScript code:
+
+```ts twoslash
+const str = 'Hello!';
+for (const s of str) {
+  console.log(s);
+}
+```
+
+Without `downlevelIteration` enabled, a `for / of` loop on any object is downleveled to a traditional `for` loop:
+
+```ts twoslash
+// @target: ES5
+// @showEmit
+const str = 'Hello!';
+for (const s of str) {
+  console.log(s);
+}
+```
+
+This is often what people expect, but it's not 100% compliant with ECMAScript iteration protocol.
+Certain strings, such as emoji (😜), have a `.length` of 2 (or even more!), but should iterate as 1 unit in a `for-of` loop.
+See [this blog post by Jonathan New](https://blog.jonnew.com/posts/poo-dot-length-equals-two) for a longer explanation.
+
+When `downlevelIteration` is enabled, TypeScript will use a helper function that checks for a `Symbol.iterator` implementation (either native or polyfill).
+If this implementation is missing, you'll fall back to index-based iteration.
+
+```ts twoslash
+// @target: ES5
+// @downlevelIteration
+// @showEmit
+const str = 'Hello!';
+for (const s of str) {
+  console.log(s);
+}
+```
+
+You can use [tslib](https://www.npmjs.com/package/tslib) via [`importHelpers`](#importHelpers) to reduce the amount of inline JavaScript too:
+
+```ts twoslash
+// @target: ES5
+// @downlevelIteration
+// @importHelpers
+// @showEmit
+const str = 'Hello!';
+for (const s of str) {
+  console.log(s);
+}
+```
+
+**Note:** enabling `downlevelIteration` does not improve compliance if `Symbol.iterator` is not present in the runtime.
+
+#### Example: Effects on Array Spreads
+
+This is an array spread:
+
+```js
+// Make a new array whose elements are 1 followed by the elements of arr2
+const arr = [1, ...arr2];
+```
+
+Based on the description, it sounds easy to downlevel to ES5:
+
+```js
+// The same, right?
+const arr = [1].concat(arr2);
+```
+
+However, this is observably different in certain rare cases.
+
+For example, if a source array is missing one or more items (contains a hole), the spread syntax will replace each empty item with `undefined`, whereas `.concat` will leave them intact.
+
+```js
+// Make an array where the element at index 1 is missing
+let arrayWithHole = ['a', , 'c'];
+let spread = [...arrayWithHole];
+let concatenated = [].concat(arrayWithHole);
+
+console.log(arrayWithHole);
+// [ 'a', <1 empty item>, 'c' ]
+console.log(spread);
+// [ 'a', undefined, 'c' ]
+console.log(concatenated);
+// [ 'a', <1 empty item>, 'c' ]
+```
+
+Just as with `for / of`, `downlevelIteration` will use `Symbol.iterator` (if present) to more accurately emulate ES 6 behavior.

package/docs/tsconfig/emitBOM.md

@@ -0,0 +1,8 @@
+---
+display: 'Emit BOM'
+oneline: 'Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files.'
+---
+
+Controls whether TypeScript will emit a [byte order mark (BOM)](https://wikipedia.org/wiki/Byte_order_mark) when writing output files.
+Some runtime environments require a BOM to correctly interpret a JavaScript files; others require that it is not present.
+The default value of `false` is generally best unless you have a reason to change it.

package/docs/tsconfig/emitDeclarationOnly.md

@@ -0,0 +1,11 @@
+---
+display: 'Emit Declaration Only'
+oneline: 'Only output d.ts files and not JavaScript files.'
+---
+
+_Only_ emit `.d.ts` files; do not emit `.js` files.
+
+This setting is useful in two cases:
+
+- You are using a transpiler other than TypeScript to generate your JavaScript.
+- You are using TypeScript to only generate `d.ts` files for your consumers.