ai-hero-cli 0.0.3 → 0.0.4

package/docs/tsconfig/inlineSourceMap.md

@@ -0,0 +1,35 @@
+---
+display: 'Inline Source Map'
+oneline: 'Include sourcemap files inside the emitted JavaScript.'
+---
+
+When set, instead of writing out a `.js.map` file to provide source maps, TypeScript will embed the source map content in the `.js` files.
+Although this results in larger JS files, it can be convenient in some scenarios.
+For example, you might want to debug JS files on a webserver that doesn't allow `.map` files to be served.
+
+Mutually exclusive with [`sourceMap`](#sourceMap).
+
+For example, with this TypeScript:
+
+```ts
+const helloWorld = 'hi';
+console.log(helloWorld);
+```
+
+Converts to this JavaScript:
+
+```ts twoslash
+// @showEmit
+const helloWorld = 'hi';
+console.log(helloWorld);
+```
+
+Then enable building it with `inlineSourceMap` enabled there is a comment at the bottom of the file which includes
+a source-map for the file.
+
+```ts twoslash
+// @inlineSourceMap
+// @showEmit
+const helloWorld = 'hi';
+console.log(helloWorld);
+```

package/docs/tsconfig/inlineSources.md

@@ -0,0 +1,36 @@
+---
+display: 'Inline Sources'
+oneline: 'Include source code in the sourcemaps inside the emitted JavaScript.'
+---
+
+When set, TypeScript will include the original content of the `.ts` file as an embedded string in the source map (using the source map's `sourcesContent` property).
+This is often useful in the same cases as [`inlineSourceMap`](#inlineSourceMap).
+
+Requires either [`sourceMap`](#sourceMap) or [`inlineSourceMap`](#inlineSourceMap) to be set.
+
+For example, with this TypeScript:
+
+```ts twoslash
+const helloWorld = 'hi';
+console.log(helloWorld);
+```
+
+By default converts to this JavaScript:
+
+```ts twoslash
+// @showEmit
+const helloWorld = 'hi';
+console.log(helloWorld);
+```
+
+Then enable building it with `inlineSources` and [`inlineSourceMap`](#inlineSourceMap) enabled there is a comment at the bottom of the file which includes
+a source-map for the file.
+Note that the end is different from the example in [`inlineSourceMap`](#inlineSourceMap) because the source-map now contains the original source code also.
+
+```ts twoslash
+// @inlineSources
+// @inlineSourceMap
+// @showEmit
+const helloWorld = 'hi';
+console.log(helloWorld);
+```

package/docs/tsconfig/isolatedDeclarations.md

@@ -0,0 +1,8 @@
+---
+display: 'isolatedDeclarations'
+oneline: 'Require sufficient annotation on exports so other tools can trivially generate declaration files.'
+---
+
+Require sufficient annotation on exports so other tools can trivially generate declaration files.
+
+For more information, see the [5.5 release notes](/docs/handbook/release-notes/typescript-5-5.html#isolated-declarations)

package/docs/tsconfig/isolatedModules.md

@@ -0,0 +1,77 @@
+---
+display: 'Isolated Modules'
+oneline: 'Ensure that each file can be safely transpiled without relying on other imports.'
+---
+
+While you can use TypeScript to produce JavaScript code from TypeScript code, it's also common to use other transpilers such as [Babel](https://babeljs.io) to do this.
+However, other transpilers only operate on a single file at a time, which means they can't apply code transforms that depend on understanding the full type system.
+This restriction also applies to TypeScript's `ts.transpileModule` API which is used by some build tools.
+
+These limitations can cause runtime problems with some TypeScript features like `const enum`s and `namespace`s.
+Setting the `isolatedModules` flag tells TypeScript to warn you if you write certain code that can't be correctly interpreted by a single-file transpilation process.
+
+It does not change the behavior of your code, or otherwise change the behavior of TypeScript's checking and emitting process.
+
+Some examples of code which does not work when `isolatedModules` is enabled.
+
+#### Exports of Non-Value Identifiers
+
+In TypeScript, you can import a _type_ and then subsequently export it:
+
+```ts twoslash
+// @noErrors
+import { someType, someFunction } from 'someModule';
+
+someFunction();
+
+export { someType, someFunction };
+```
+
+Because there's no value for `someType`, the emitted `export` will not try to export it (this would be a runtime error in JavaScript):
+
+```js
+export { someFunction };
+```
+
+Single-file transpilers don't know whether `someType` produces a value or not, so it's an error to export a name that only refers to a type.
+
+#### Non-Module Files
+
+If `isolatedModules` is set, namespaces are only allowed in _modules_ (which means it has some form of `import`/`export`). An error occurs if a namespace is found in a non-module file:
+
+```ts twoslash
+// @errors: 1277
+// @isolatedModules
+namespace Instantiated {
+  export const x = 1;
+}
+```
+
+This restriction doesn't apply to `.d.ts` files.
+
+#### References to `const enum` members
+
+In TypeScript, when you reference a `const enum` member, the reference is replaced by its actual value in the emitted JavaScript. Changing this TypeScript:
+
+```ts twoslash
+declare const enum Numbers {
+  Zero = 0,
+  One = 1,
+}
+console.log(Numbers.Zero + Numbers.One);
+```
+
+To this JavaScript:
+
+```ts twoslash
+// @showEmit
+// @removeComments
+declare const enum Numbers {
+  Zero = 0,
+  One = 1,
+}
+console.log(Numbers.Zero + Numbers.One);
+```
+
+Without knowledge of the values of these members, other transpilers can't replace the references to `Numbers`, which would be a runtime error if left alone (since there are no `Numbers` object at runtime).
+Because of this, when `isolatedModules` is set, it is an error to reference an ambient `const enum` member.

package/docs/tsconfig/jsx.md

@@ -0,0 +1,111 @@
+---
+display: 'JSX'
+oneline: 'Specify what JSX code is generated.'
+---
+
+Controls how JSX constructs are emitted in JavaScript files.
+This only affects output of JS files that started in `.tsx` files.
+
+- `react-jsx`: Emit `.js` files with the JSX changed to `_jsx` calls optimized for production
+- `react-jsxdev`: Emit `.js` files with the JSX changed to `_jsx` calls for development only
+- `preserve`: Emit `.jsx` files with the JSX unchanged
+- `react-native`: Emit `.js` files with the JSX unchanged
+- `react`: Emit `.js` files with JSX changed to the equivalent `React.createElement` calls
+
+### For example
+
+This sample code:
+
+```tsx
+export const HelloWorld = () => <h1>Hello world</h1>;
+```
+
+React: `"react-jsx"`<sup>[[1]](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html)</sup>
+
+```tsx twoslash
+declare module JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    [s: string]: any;
+  }
+}
+// @showEmit
+// @noErrors
+// @jsx: react-jsx
+export const HelloWorld = () => <h1>Hello world</h1>;
+```
+
+React dev transform: `"react-jsxdev"`<sup>[[1]](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html)</sup>
+
+```tsx twoslash
+declare module JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    [s: string]: any;
+  }
+}
+// @showEmit
+// @noErrors
+// @jsx: react-jsxdev
+export const HelloWorld = () => <h1>Hello world</h1>;
+```
+
+Preserve: `"preserve"`
+
+```tsx twoslash
+declare module JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    [s: string]: any;
+  }
+}
+// @showEmit
+// @noErrors
+// @jsx: preserve
+export const HelloWorld = () => <h1>Hello world</h1>;
+```
+
+React Native: `"react-native"`
+
+```tsx twoslash
+declare module JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    [s: string]: any;
+  }
+}
+// @showEmit
+// @noErrors
+// @jsx: react-native
+export const HelloWorld = () => <h1>Hello world</h1>;
+```
+
+Legacy React runtime: `"react"`
+
+```tsx twoslash
+declare module JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    [s: string]: any;
+  }
+}
+// @showEmit
+// @noErrors
+export const HelloWorld = () => <h1>Hello world</h1>;
+```
+
+This option can be used on a per-file basis too using an `@jsxRuntime` comment.
+
+Always use the classic runtime (`"react"`) for this file:
+
+```tsx
+/* @jsxRuntime classic */
+export const HelloWorld = () => <h1>Hello world</h1>;
+```
+
+Always use the automatic runtime (`"react-jsx"`) for this file:
+
+```tsx
+/* @jsxRuntime automatic */
+export const HelloWorld = () => <h1>Hello world</h1>;
+```

package/docs/tsconfig/jsxFactory.md

@@ -0,0 +1,43 @@
+---
+display: 'JSX Factory'
+oneline: "Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'."
+---
+
+Changes the function called in `.js` files when compiling JSX Elements using the classic JSX runtime.
+The most common change is to use `"h"` or `"preact.h"` instead of the default `"React.createElement"` if using `preact`.
+
+For example, this TSX file:
+
+```tsx
+import { h } from 'preact';
+
+const HelloWorld = () => <div>Hello</div>;
+```
+
+With `jsxFactory: "h"` looks like:
+
+```tsx twoslash
+// @showEmit
+// @showEmittedFile: index.js
+// @jsxFactory: h
+// @noErrors
+// @target: esnext
+// @module: commonjs
+
+import { h, Fragment } from 'preact';
+
+const HelloWorld = () => <div>Hello</div>;
+```
+
+This option can be used on a per-file basis too similar to [Babel's `/** @jsx h */` directive](https://babeljs.io/docs/en/babel-plugin-transform-react-jsx#custom).
+
+```tsx twoslash
+/** @jsx h */
+import { h } from 'preact';
+
+const HelloWorld = () => <div>Hello</div>;
+```
+
+The factory chosen will also affect where the `JSX` namespace is looked up (for type checking information) before falling back to the global one.
+
+If the factory is defined as `React.createElement` (the default), the compiler will check for `React.JSX` before checking for a global `JSX`. If the factory is defined as `h`, it will check for `h.JSX` before a global `JSX`.

package/docs/tsconfig/jsxFragmentFactory.md

@@ -0,0 +1,69 @@
+---
+display: 'JSX Fragment Factory'
+oneline: "Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'."
+---
+
+Specify the JSX fragment factory function to use when targeting react JSX emit with [`jsxFactory`](#jsxFactory) compiler option is specified, e.g. `Fragment`.
+
+For example with this TSConfig:
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "jsx": "react",
+    "jsxFactory": "h",
+    "jsxFragmentFactory": "Fragment"
+  }
+}
+```
+
+This TSX file:
+
+```tsx
+import { h, Fragment } from 'preact';
+
+const HelloWorld = () => (
+  <>
+    <div>Hello</div>
+  </>
+);
+```
+
+Would look like:
+
+```tsx twoslash
+// @showEmit
+// @showEmittedFile: index.js
+// @jsxFactory: h
+// @jsxFragmentFactory: Fragment
+// @noErrors
+// @target: esnext
+// @module: commonjs
+
+import { h, Fragment } from 'preact';
+
+const HelloWorld = () => (
+  <>
+    <div>Hello</div>
+  </>
+);
+```
+
+This option can be used on a per-file basis too similar to [Babel's `/* @jsxFrag h */` directive](https://babeljs.io/docs/en/babel-plugin-transform-react-jsx#fragments).
+
+For example:
+
+```tsx twoslash
+/** @jsx h */
+/** @jsxFrag Fragment */
+
+import { h, Fragment } from 'preact';
+
+const HelloWorld = () => (
+  <>
+    <div>Hello</div>
+  </>
+);
+```

package/docs/tsconfig/jsxImportSource.md

@@ -0,0 +1,95 @@
+---
+display: 'JSX Import Source'
+oneline: 'Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.'
+---
+
+Declares the module specifier to be used for importing the `jsx` and `jsxs` factory functions when using [`jsx`](#jsx) as `"react-jsx"` or `"react-jsxdev"` which were introduced in TypeScript 4.1.
+
+With [React 17](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html) the library supports a new form of JSX transformation via a separate import.
+
+For example with this code:
+
+```tsx
+import React from 'react';
+
+function App() {
+  return <h1>Hello World</h1>;
+}
+```
+
+Using this TSConfig:
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "jsx": "react-jsx"
+  }
+}
+```
+
+The emitted JavaScript from TypeScript is:
+
+```tsx twoslash
+// @showEmit
+// @noErrors
+// @jsx: react-jsx
+// @module: commonjs
+// @target: esnext
+declare module JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    [s: string]: any;
+  }
+}
+import React from 'react';
+
+function App() {
+  return <h1>Hello World</h1>;
+}
+```
+
+For example if you wanted to use `"jsxImportSource": "preact"`, you need a tsconfig like:
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+    "types": ["preact"]
+  }
+}
+```
+
+Which generates code like:
+
+```tsx twoslash
+// @showEmit
+// @jsxImportSource: preact
+// @types: preact
+// @jsx: react-jsx
+// @target: esnext
+// @module: commonjs
+// @noErrors
+
+export function App() {
+  return <h1>Hello World</h1>;
+}
+```
+
+Alternatively, you can use a per-file pragma to set this option, for example:
+
+```tsx
+/** @jsxImportSource preact */
+
+export function App() {
+  return <h1>Hello World</h1>;
+}
+```
+
+Would add `preact/jsx-runtime` as an import for the `_jsx` factory.
+
+_Note:_ In order for this to work like you would expect, your `tsx` file must include an `export` or `import` so that it is considered a module.

package/docs/tsconfig/keyofStringsOnly.md

@@ -0,0 +1,8 @@
+---
+display: 'Keyof Strings Only'
+oneline: 'Make keyof only return strings instead of string, numbers or symbols. Legacy option.'
+---
+
+This flag changes the `keyof` type operator to return `string` instead of `string | number` when applied to a type with a string index signature.
+
+This flag is used to help people keep this behavior from [before TypeScript 2.9's release](/docs/handbook/release-notes/typescript-2-9.html#support-number-and-symbol-named-properties-with-keyof-and-mapped-types).

package/docs/tsconfig/lib.md

@@ -0,0 +1,75 @@
+---
+display: 'Lib'
+oneline: 'Specify a set of bundled library declaration files that describe the target runtime environment.'
+---
+
+TypeScript includes a default set of type definitions for built-in JS APIs (like `Math`), as well as type definitions for things found in browser environments (like `document`).
+TypeScript also includes APIs for newer JS features matching the [`target`](#target) you specify; for example the definition for `Map` is available if [`target`](#target) is `ES6` or newer.
+
+You may want to change these for a few reasons:
+
+- Your program doesn't run in a browser, so you don't want the `"dom"` type definitions
+- Your runtime platform provides certain JavaScript API objects (maybe through polyfills), but doesn't yet support the full syntax of a given ECMAScript version
+- You have polyfills or native implementations for some, but not all, of a higher level ECMAScript version
+
+In TypeScript 4.5, lib files can be overridden by npm modules, find out more [in the blog](https://devblogs.microsoft.com/typescript/announcing-typescript-4-5-beta/#supporting-lib-from-node_modules).
+
+### High Level libraries
+
+| Name         | Contents                                                                                                                                          |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ES5`        | Core definitions for all ES5 functionality                                                                                                        |
+| `ES2015`     | Additional APIs available in ES2015 (also known as ES6) - `array.find`, `Promise`, `Proxy`, `Symbol`, `Map`, `Set`, `Reflect`, etc.               |
+| `ES6`        | Alias for "ES2015"                                                                                                                                |
+| `ES2016`     | Additional APIs available in ES2016 - `array.include`, etc.                                                                                       |
+| `ES7`        | Alias for "ES2016"                                                                                                                                |
+| `ES2017`     | Additional APIs available in ES2017 - `Object.entries`, `Object.values`, `Atomics`, `SharedArrayBuffer`, `date.formatToParts`, typed arrays, etc. |
+| `ES2018`     | Additional APIs available in ES2018 - `async` iterables, `promise.finally`, `Intl.PluralRules`, `regexp.groups`, etc.                             |
+| `ES2019`     | Additional APIs available in ES2019 - `array.flat`, `array.flatMap`, `Object.fromEntries`, `string.trimStart`, `string.trimEnd`, etc.             |
+| `ES2020`     | Additional APIs available in ES2020 - `string.matchAll`, etc.                                                                                     |
+| `ES2021`     | Additional APIs available in ES2021 - `promise.any`, `string.replaceAll` etc.                                                                     |
+| `ES2022`     | Additional APIs available in ES2022 - `array.at`, `RegExp.hasIndices`, etc.                                                                       |
+| `ES2023`     | Additional APIs available in ES2023 - `array.with`, `array.findLast`, `array.findLastIndex`, `array.toSorted`, `array.toReversed`, etc.           |
+| `ESNext`     | Additional APIs available in ESNext - This changes as the JavaScript specification evolves                                                        |
+| `DOM`        | [DOM](https://developer.mozilla.org/docs/Glossary/DOM) definitions - `window`, `document`, etc.                                                   |
+| `WebWorker`  | APIs available in [WebWorker](https://developer.mozilla.org/docs/Web/API/Web_Workers_API/Using_web_workers) contexts                              |
+| `ScriptHost` | APIs for the [Windows Script Hosting System](https://wikipedia.org/wiki/Windows_Script_Host)                                                      |
+
+### Individual library components
+
+| Name                      |
+| ------------------------- |
+| `DOM.Iterable`            |
+| `ES2015.Core`             |
+| `ES2015.Collection`       |
+| `ES2015.Generator`        |
+| `ES2015.Iterable`         |
+| `ES2015.Promise`          |
+| `ES2015.Proxy`            |
+| `ES2015.Reflect`          |
+| `ES2015.Symbol`           |
+| `ES2015.Symbol.WellKnown` |
+| `ES2016.Array.Include`    |
+| `ES2017.object`           |
+| `ES2017.Intl`             |
+| `ES2017.SharedMemory`     |
+| `ES2017.String`           |
+| `ES2017.TypedArrays`      |
+| `ES2018.Intl`             |
+| `ES2018.Promise`          |
+| `ES2018.RegExp`           |
+| `ES2019.Array`            |
+| `ES2019.Object`           |
+| `ES2019.String`           |
+| `ES2019.Symbol`           |
+| `ES2020.String`           |
+| `ES2020.Symbol.wellknown` |
+| `ES2021.Promise`          |
+| `ES2021.String`           |
+| `ES2021.WeakRef`          |
+| `ESNext.AsyncIterable`    |
+| `ESNext.Array`            |
+| `ESNext.Intl`             |
+| `ESNext.Symbol`           |
+
+This list may be out of date, you can see the full list in the [TypeScript source code](https://github.com/microsoft/TypeScript/tree/main/src/lib).

package/docs/tsconfig/libReplacement.md

@@ -0,0 +1,22 @@
+---
+display: 'Lib Replacement'
+oneline: 'Enable substitution of default `lib` files with custom ones.'
+---
+
+TypeScript 4.5 introduced the possibility of substituting the default `lib` files with custom ones.
+All built-in library files would first try to be resolved from packages named `@typescript/lib-*`.
+For example, you could lock your `dom` libraries onto a specific version of [the `@types/web` package](https://www.npmjs.com/package/@types/web?activeTab=readme) with the following `package.json`:
+
+```json
+{
+  "devDependencies": {
+    "@typescript/lib-dom": "npm:@types/web@0.0.199"
+  }
+}
+```
+
+When installed, a package called `@typescript/lib-dom` should exist, and TypeScript would always look there when searching for `lib.dom.d.ts`.
+
+The `--libReplacement` flag allows you to disable this behavior.
+If you're not using any `@typescript/lib-*` packages, you can now disable those package lookups with `--libReplacement false`.
+In the future, `--libReplacement false` may become the default, so if you currently rely on the behavior you should consider explicitly enabling it with `--libReplacement true`.

package/docs/tsconfig/listEmittedFiles.md

@@ -0,0 +1,42 @@
+---
+display: 'List Emitted Files'
+oneline: 'Print the names of emitted files after a compilation.'
+---
+
+Print names of generated files part of the compilation to the terminal.
+
+This flag is useful in two cases:
+
+- You want to transpile TypeScript as a part of a build chain in the terminal where the filenames are processed in the next command.
+- You are not sure that TypeScript has included a file you expected, as a part of debugging the [file inclusion settings](#Project_Files_0).
+
+For example:
+
+```
+example
+├── index.ts
+├── package.json
+└── tsconfig.json
+```
+
+With:
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "declaration": true,
+    "listEmittedFiles": true
+  }
+}
+```
+
+Would echo paths like:
+
+```
+$ npm run tsc
+
+path/to/example/index.js
+path/to/example/index.d.ts
+```
+
+Normally, TypeScript would return silently on success.

package/docs/tsconfig/listFiles.md

@@ -0,0 +1,40 @@
+---
+display: 'List Files'
+oneline: 'Print all of the files read during the compilation.'
+---
+
+Print names of files part of the compilation. This is useful when you are not sure that TypeScript has
+included a file you expected.
+
+For example:
+
+```
+example
+├── index.ts
+├── package.json
+└── tsconfig.json
+```
+
+With:
+
+```json tsconfig
+{
+  "compilerOptions": {
+    "listFiles": true
+  }
+}
+```
+
+Would echo paths like:
+
+```
+$ npm run tsc
+path/to/example/node_modules/typescript/lib/lib.d.ts
+path/to/example/node_modules/typescript/lib/lib.es5.d.ts
+path/to/example/node_modules/typescript/lib/lib.dom.d.ts
+path/to/example/node_modules/typescript/lib/lib.webworker.importscripts.d.ts
+path/to/example/node_modules/typescript/lib/lib.scripthost.d.ts
+path/to/example/index.ts
+```
+
+Note if using TypeScript 4.2, prefer [`explainFiles`](#explainFiles) which offers an explanation of why a file was added too.