ai-hero-cli 0.0.5 → 0.0.7

package/docs/tsconfig/explainFiles.md

@@ -1,54 +0,0 @@
----
-display: 'Explain Files'
-oneline: 'Print files read during the compilation including why it was included.'
----
-
-Print names of files which TypeScript sees as a part of your project and the reason they are part of the compilation.
-
-For example, with this project of just a single `index.ts` file
-
-```sh
-example
-├── index.ts
-├── package.json
-└── tsconfig.json
-```
-
-Using a `tsconfig.json` which has `explainFiles` set to true:
-
-```json
-{
-  "compilerOptions": {
-    "target": "es5",
-    "module": "commonjs",
-    "explainFiles": true
-  }
-}
-```
-
-Running TypeScript against this folder would have output like this:
-
-```
-❯ tsc
-node_modules/typescript/lib/lib.d.ts
-  Default library for target 'es5'
-node_modules/typescript/lib/lib.es5.d.ts
-  Library referenced via 'es5' from file 'node_modules/typescript/lib/lib.d.ts'
-node_modules/typescript/lib/lib.dom.d.ts
-  Library referenced via 'dom' from file 'node_modules/typescript/lib/lib.d.ts'
-node_modules/typescript/lib/lib.webworker.importscripts.d.ts
-  Library referenced via 'webworker.importscripts' from
-    file 'node_modules/typescript/lib/lib.d.ts'
-node_modules/typescript/lib/lib.scripthost.d.ts
-  Library referenced via 'scripthost'
-    from file 'node_modules/typescript/lib/lib.d.ts'
-index.ts
-  Matched by include pattern '**/*' in 'tsconfig.json'
-```
-
-The output above show:
-
-- The initial lib.d.ts lookup based on [`target`](#target), and the chain of `.d.ts` files which are referenced
-- The `index.ts` file located via the default pattern of [`include`](#include)
-
-This option is intended for debugging how a file has become a part of your compile.

package/docs/tsconfig/extendedDiagnostics.md

@@ -1,9 +0,0 @@
----
-display: 'Extended Diagnostics'
-oneline: 'Output more detailed compiler performance information after building.'
----
-
-You can use this flag to discover where TypeScript is spending its time when compiling.
-This is a tool used for understanding the performance characteristics of your codebase overall.
-
-You can learn more about how to measure and understand the output in the performance [section of the wiki](https://github.com/microsoft/TypeScript/wiki/Performance).

package/docs/tsconfig/extends.md

@@ -1,49 +0,0 @@
----
-display: 'Extends'
-oneline: 'Specify one or more path or node module references to base configuration files from which settings are inherited.'
----
-
-The value of `extends` is a string which contains a path to another configuration file to inherit from.
-The path may use Node.js style resolution.
-
-The configuration from the base file are loaded first, then overridden by those in the inheriting config file. All relative paths found in the configuration file will be resolved relative to the configuration file they originated in.
-
-It's worth noting that [`files`](#files), [`include`](#include), and [`exclude`](#exclude) from the inheriting config file _overwrite_ those from the
-base config file, and that circularity between configuration files is not allowed.
-
-Currently, the only top-level property that is excluded from inheritance is [`references`](#references).
-
-##### Example
-
-`configs/base.json`:
-
-```json tsconfig
-{
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "strictNullChecks": true
-  }
-}
-```
-
-`tsconfig.json`:
-
-```json tsconfig
-{
-  "extends": "./configs/base",
-  "files": ["main.ts", "supplemental.ts"]
-}
-```
-
-`tsconfig.nostrictnull.json`:
-
-```json tsconfig
-{
-  "extends": "./tsconfig",
-  "compilerOptions": {
-    "strictNullChecks": false
-  }
-}
-```
-
-Properties with relative paths found in the configuration file, which aren't excluded from inheritance, will be resolved relative to the configuration file they originated in.

package/docs/tsconfig/fallbackPolling.md

@@ -1,11 +0,0 @@
----
-display: 'Fallback Polling'
-oneline: 'Specify what approach the watcher should use if the system runs out of native file watchers.'
----
-
-When using file system events, this option specifies the polling strategy that gets used when the system runs out of native file watchers and/or doesn't support native file watchers.
-
-- `fixedPollingInterval`: Check every file for changes several times a second at a fixed interval.
-- `priorityPollingInterval`: Check every file for changes several times a second, but use heuristics to check certain types of files less frequently than others.
-- `dynamicPriorityPolling`: Use a dynamic queue where less-frequently modified files will be checked less often.
-- `synchronousWatchDirectory`: Disable deferred watching on directories. Deferred watching is useful when lots of file changes might occur at once (e.g. a change in `node_modules` from running `npm install`), but you might want to disable it with this flag for some less-common setups.

package/docs/tsconfig/files.md

@@ -1,26 +0,0 @@
----
-display: 'Files'
-oneline: 'Include a list of files. This does not support glob patterns, as opposed to [`include`](#include).'
----
-
-Specifies an allowlist of files to include in the program. An error occurs if any of the files can't be found.
-
-```json tsconfig
-{
-  "compilerOptions": {},
-  "files": [
-    "core.ts",
-    "sys.ts",
-    "types.ts",
-    "scanner.ts",
-    "parser.ts",
-    "utilities.ts",
-    "binder.ts",
-    "checker.ts",
-    "tsc.ts"
-  ]
-}
-```
-
-This is useful when you only have a small number of files and don't need to use a glob to reference many files.
-If you need that then use [`include`](#include).

package/docs/tsconfig/force.md

@@ -1,6 +0,0 @@
----
-display: 'Force'
-oneline: 'Build all projects, including those that appear to be up to date.'
----
-
-Build all projects, including those that appear to be up to date

package/docs/tsconfig/forceConsistentCasingInFileNames.md

@@ -1,10 +0,0 @@
----
-display: 'Force Consistent Casing In File Names'
-oneline: 'Ensure that casing is correct in imports.'
----
-
-TypeScript follows the case sensitivity rules of the file system it's running on.
-This can be problematic if some developers are working in a case-sensitive file system and others aren't.
-If a file attempts to import `fileManager.ts` by specifying `./FileManager.ts` the file will be found in a case-insensitive file system, but not on a case-sensitive file system.
-
-When this option is set, TypeScript will issue an error if a program tries to include a file by a casing different from the casing on disk.

package/docs/tsconfig/generateCpuProfile.md

@@ -1,15 +0,0 @@
----
-display: 'Generate CPU Profile'
-oneline: 'Emit a v8 CPU profile of the compiler run for debugging.'
----
-
-This option gives you the chance to have TypeScript emit a v8 CPU profile during the compiler run. The CPU profile can provide insight into why your builds may be slow.
-
-This option can only be used from the CLI via: `--generateCpuProfile tsc-output.cpuprofile`.
-
-```sh
-npm run tsc --generateCpuProfile tsc-output.cpuprofile
-```
-
-This file can be opened in a chromium based browser like Chrome or Edge Developer in [the CPU profiler](https://developers.google.com/web/tools/chrome-devtools/rendering-tools/js-execution) section.
-You can learn more about understanding the compilers performance in the [TypeScript wiki section on performance](https://github.com/microsoft/TypeScript/wiki/Performance).

package/docs/tsconfig/generateTrace.md

@@ -1,6 +0,0 @@
----
-display: 'generateTrace'
-oneline: 'Generates an event trace and a list of types.'
----
-
-Generates an event trace and a list of types.

package/docs/tsconfig/importHelpers.md

@@ -1,46 +0,0 @@
----
-display: 'Import Helpers'
-oneline: 'Allow importing helper functions from tslib once per project, instead of including them per-file.'
----
-
-For certain downleveling operations, TypeScript uses some helper code for operations like extending class, spreading arrays or objects, and async operations.
-By default, these helpers are inserted into files which use them.
-This can result in code duplication if the same helper is used in many different modules.
-
-If the `importHelpers` flag is on, these helper functions are instead imported from the [tslib](https://www.npmjs.com/package/tslib) module.
-You will need to ensure that the `tslib` module is able to be imported at runtime.
-This only affects modules; global script files will not attempt to import modules.
-
-For example, with this TypeScript:
-
-```ts
-export function fn(arr: number[]) {
-  const arr2 = [1, ...arr];
-}
-```
-
-Turning on [`downlevelIteration`](#downlevelIteration) and `importHelpers` is still false:
-
-```ts twoslash
-// @showEmit
-// @target: ES5
-// @downleveliteration
-export function fn(arr: number[]) {
-  const arr2 = [1, ...arr];
-}
-```
-
-Then turning on both [`downlevelIteration`](#downlevelIteration) and `importHelpers`:
-
-```ts twoslash
-// @showEmit
-// @target: ES5
-// @downleveliteration
-// @importhelpers
-// @noErrors
-export function fn(arr: number[]) {
-  const arr2 = [1, ...arr];
-}
-```
-
-You can use [`noEmitHelpers`](#noEmitHelpers) when you provide your own implementations of these functions.

package/docs/tsconfig/importsNotUsedAsValues.md

@@ -1,16 +0,0 @@
----
-display: 'Imports Not Used As Values'
-oneline: 'Specify emit/checking behavior for imports that are only used for types.'
----
-
-Deprecated in favor of [`verbatimModuleSyntax`](#verbatimModuleSyntax).
-
-This flag controls how `import` works, there are 3 different options:
-
-- `remove`: The default behavior of dropping `import` statements which only reference types.
-
-- `preserve`: Preserves all `import` statements whose values or types are never used. This can cause imports/side-effects to be preserved.
-
-- `error`: This preserves all imports (the same as the preserve option), but will error when a value import is only used as a type. This might be useful if you want to ensure no values are being accidentally imported, but still make side-effect imports explicit.
-
-This flag works because you can use `import type` to explicitly create an `import` statement which should never be emitted into JavaScript.

package/docs/tsconfig/include.md

@@ -1,66 +0,0 @@
----
-display: 'Include'
-oneline: 'Specify a list of glob patterns that match files to be included in compilation.'
----
-
-Specifies an array of filenames or patterns to include in the program.
-These filenames are resolved relative to the directory containing the `tsconfig.json` file.
-
-```json
-{
-  "include": ["src/**/*", "tests/**/*"]
-}
-```
-
-Which would include:
-
-<!-- TODO: #135
-```diff
-  .
-- ├── scripts
-- │   ├── lint.ts
-- │   ├── update_deps.ts
-- │   └── utils.ts
-+ ├── src
-+ │   ├── client
-+ │   │    ├── index.ts
-+ │   │    └── utils.ts
-+ │   ├── server
-+ │   │    └── index.ts
-+ ├── tests
-+ │   ├── app.test.ts
-+ │   ├── utils.ts
-+ │   └── tests.d.ts
-- ├── package.json
-- ├── tsconfig.json
-- └── yarn.lock
-``` -->
-
-```
-.
-├── scripts                ⨯
-│   ├── lint.ts            ⨯
-│   ├── update_deps.ts     ⨯
-│   └── utils.ts           ⨯
-├── src                    ✓
-│   ├── client             ✓
-│   │    ├── index.ts      ✓
-│   │    └── utils.ts      ✓
-│   ├── server             ✓
-│   │    └── index.ts      ✓
-├── tests                  ✓
-│   ├── app.test.ts        ✓
-│   ├── utils.ts           ✓
-│   └── tests.d.ts         ✓
-├── package.json
-├── tsconfig.json
-└── yarn.lock
-```
-
-`include` and `exclude` support wildcard characters to make glob patterns:
-
-- `*` matches zero or more characters (excluding directory separators)
-- `?` matches any one character (excluding directory separators)
-- `**/` matches any directory nested to any level
-
-If the last path segment in a pattern does not contain a file extension or wildcard character, then it is treated as a directory, and files with supported extensions inside that directory are included (e.g. `.ts`, `.tsx`, and `.d.ts` by default, with `.js` and `.jsx` if [`allowJs`](#allowJs) is set to true).

package/docs/tsconfig/incremental.md

@@ -1,10 +0,0 @@
----
-display: 'Incremental'
-oneline: 'Save .tsbuildinfo files to allow for incremental compilation of projects.'
----
-
-Tells TypeScript to save information about the project graph from the last compilation to files stored on disk. This
-creates a series of `.tsbuildinfo` files in the same folder as your compilation output. They are not used by your
-JavaScript at runtime and can be safely deleted. You can read more about the flag in the [3.4 release notes](/docs/handbook/release-notes/typescript-3-4.html#faster-subsequent-builds-with-the---incremental-flag).
-
-To control which folders you want to the files to be built to, use the config option [`tsBuildInfoFile`](#tsBuildInfoFile).

package/docs/tsconfig/inlineSourceMap.md

@@ -1,35 +0,0 @@
----
-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

@@ -1,36 +0,0 @@
----
-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

@@ -1,8 +0,0 @@
----
-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

@@ -1,77 +0,0 @@
----
-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

@@ -1,111 +0,0 @@
----
-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

@@ -1,43 +0,0 @@
----
-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`.