ai-hero-cli 0.0.4 → 0.0.6

package/docs/tsconfig/checkJs.md

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

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

package/docs/tsconfig/composite.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/docs/tsconfig/emitDecoratorMetadata.md

@@ -1,81 +0,0 @@
----
-display: 'Emit Decorator Metadata'
-oneline: 'Emit design-type metadata for decorated declarations in source files.'
----
-
-Enables experimental support for emitting type metadata for decorators which works with the module [`reflect-metadata`](https://www.npmjs.com/package/reflect-metadata).
-
-For example, here is the TypeScript
-
-```ts twoslash
-// @experimentalDecorators
-function LogMethod(
-  target: any,
-  propertyKey: string | symbol,
-  descriptor: PropertyDescriptor,
-) {
-  console.log(target);
-  console.log(propertyKey);
-  console.log(descriptor);
-}
-
-class Demo {
-  @LogMethod
-  public foo(bar: number) {
-    // do nothing
-  }
-}
-
-const demo = new Demo();
-```
-
-With `emitDecoratorMetadata` not set to true (default) the emitted JavaScript is:
-
-```ts twoslash
-// @experimentalDecorators
-// @showEmit
-function LogMethod(
-  target: any,
-  propertyKey: string | symbol,
-  descriptor: PropertyDescriptor,
-) {
-  console.log(target);
-  console.log(propertyKey);
-  console.log(descriptor);
-}
-
-class Demo {
-  @LogMethod
-  public foo(bar: number) {
-    // do nothing
-  }
-}
-
-const demo = new Demo();
-```
-
-With `emitDecoratorMetadata` set to true the emitted JavaScript is:
-
-```ts twoslash
-// @experimentalDecorators
-// @showEmit
-// @emitDecoratorMetadata
-function LogMethod(
-  target: any,
-  propertyKey: string | symbol,
-  descriptor: PropertyDescriptor,
-) {
-  console.log(target);
-  console.log(propertyKey);
-  console.log(descriptor);
-}
-
-class Demo {
-  @LogMethod
-  public foo(bar: number) {
-    // do nothing
-  }
-}
-
-const demo = new Demo();
-```

package/docs/tsconfig/enable.md

@@ -1,14 +0,0 @@
----
-display: 'Enable'
-oneline: 'Disable the type acquisition for JavaScript projects.'
----
-
-Disables automatic type acquisition in JavaScript projects:
-
-```json
-{
-  "typeAcquisition": {
-    "enable": false
-  }
-}
-```

package/docs/tsconfig/erasableSyntaxOnly.md

@@ -1,65 +0,0 @@
----
-display: 'Erasable Syntax Only'
-oneline: 'Do not allow runtime constructs that are not part of ECMAScript.'
----
-
-Node.js [supports running TypeScript files directly](https://nodejs.org/api/typescript.html#type-stripping) as of v23.6;
-however, only TypeScript-specific syntax that does not have runtime semantics are supported under this mode.
-In other words, it must be possible to easily _erase_ any TypeScript-specific syntax from a file, leaving behind a valid JavaScript file.
-
-That means the following constructs are not supported:
-
-- `enum` declarations
-- `namespace`s and `module`s with runtime code
-- parameter properties in classes
-- Non-ECMAScript `import =` and `export =` assignments
-
-```ts
-// ❌ error: An `import ... = require(...)` alias
-import foo = require('foo');
-
-// ❌ error: A namespace with runtime code.
-namespace container {
-  foo.method();
-
-  export type Bar = string;
-}
-
-// ❌ error: An `import =` alias
-import Bar = container.Bar;
-
-class Point {
-  // ❌ error: Parameter properties
-  constructor(
-    public x: number,
-    public y: number,
-  ) {}
-}
-
-// ❌ error: An `export =` assignment.
-export = Point;
-
-// ❌ error: An enum declaration.
-enum Direction {
-  Up,
-  Down,
-  Left,
-  Right,
-}
-```
-
-Similar tools like [ts-blank-space](https://github.com/bloomberg/ts-blank-space) or [Amaro](https://github.com/nodejs/amaro) (the underlying library for type-stripping in Node.js) have the same limitations.
-These tools will provide helpful error messages if they encounter code that doesn't meet these requirements, but you still won't find out your code doesn't work until you actually try to run it.
-
-The `--erasableSyntaxOnly` flag will cause TypeScript to error on most TypeScript-specific constructs that have runtime behavior.
-
-```ts
-class C {
-    constructor(public x: number) { }
-    //          ~~~~~~~~~~~~~~~~
-    // error! This syntax is not allowed when 'erasableSyntaxOnly' is enabled.
-    }
-}
-```
-
-Typically, you will want to combine this flag with the `--verbatimModuleSyntax`, which ensures that a module contains the appropriate import syntax, and that import elision does not take place.

package/docs/tsconfig/esModuleInterop.md

@@ -1,74 +0,0 @@
----
-display: 'ES Module Interop'
-oneline: 'Emit additional JavaScript to ease support for importing CommonJS modules. This enables [`allowSyntheticDefaultImports`](#allowSyntheticDefaultImports) for type compatibility.'
----
-
-By default (with `esModuleInterop` false or not set) TypeScript treats CommonJS/AMD/UMD modules similar to ES6 modules. In doing this, there are two parts in particular which turned out to be flawed assumptions:
-
-- a namespace import like `import * as moment from "moment"` acts the same as `const moment = require("moment")`
-
-- a default import like `import moment from "moment"` acts the same as `const moment = require("moment").default`
-
-This mis-match causes these two issues:
-
-- the ES6 modules spec states that a namespace import (`import * as x`) can only be an object, by having TypeScript
-  treating it the same as `= require("x")` then TypeScript allowed for the import to be treated as a function and be callable. That's not valid according to the spec.
-
-- while accurate to the ES6 modules spec, most libraries with CommonJS/AMD/UMD modules didn't conform as strictly as TypeScript's implementation.
-
-Turning on `esModuleInterop` will fix both of these problems in the code transpiled by TypeScript. The first changes the behavior in the compiler, the second is fixed by two new helper functions which provide a shim to ensure compatibility in the emitted JavaScript:
-
-```ts
-import * as fs from 'fs';
-import _ from 'lodash';
-
-fs.readFileSync('file.txt', 'utf8');
-_.chunk(['a', 'b', 'c', 'd'], 2);
-```
-
-With `esModuleInterop` disabled:
-
-```ts twoslash
-// @noErrors
-// @showEmit
-// @esModuleInterop: false
-// @module: commonjs
-import * as fs from 'fs';
-import _ from 'lodash';
-
-fs.readFileSync('file.txt', 'utf8');
-_.chunk(['a', 'b', 'c', 'd'], 2);
-```
-
-With `esModuleInterop` set to `true`:
-
-```ts twoslash
-// @noErrors
-// @showEmit
-// @esModuleInterop
-// @module: commonjs
-import * as fs from 'fs';
-import _ from 'lodash';
-
-fs.readFileSync('file.txt', 'utf8');
-_.chunk(['a', 'b', 'c', 'd'], 2);
-```
-
-_Note_: The namespace import `import * as fs from "fs"` only accounts for properties which [are owned](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty) (basically properties set on the object and not via the prototype chain) on the imported object. If the module you're importing defines its API using inherited properties, you need to use the default import form (`import fs from "fs"`), or disable `esModuleInterop`.
-
-_Note_: You can make JS emit terser by enabling [`importHelpers`](#importHelpers):
-
-```ts twoslash
-// @noErrors
-// @showEmit
-// @esModuleInterop
-// @importHelpers
-// @module: commonjs
-import * as fs from 'fs';
-import _ from 'lodash';
-
-fs.readFileSync('file.txt', 'utf8');
-_.chunk(['a', 'b', 'c', 'd'], 2);
-```
-
-Enabling `esModuleInterop` will also enable [`allowSyntheticDefaultImports`](#allowSyntheticDefaultImports).

package/docs/tsconfig/exactOptionalPropertyTypes.md

@@ -1,37 +0,0 @@
----
-display: 'Exact Optional Property Types'
-oneline: 'Interpret optional property types as written, rather than adding `undefined`.'
----
-
-With exactOptionalPropertyTypes enabled, TypeScript applies stricter rules around how it handles properties on `type` or `interfaces` which have a `?` prefix.
-
-For example, this interface declares that there is a property which can be one of two strings: 'dark' or 'light' or it should not be in the object.
-
-```ts
-interface UserDefaults {
-  // The absence of a value represents 'system'
-  colorThemeOverride?: 'dark' | 'light';
-}
-```
-
-Without this flag enabled, there are three values which you can set `colorThemeOverride` to be: "dark", "light" and `undefined`.
-
-Setting the value to `undefined` will allow most JavaScript runtime checks for the existence to fail, which is effectively falsy. However, this isn't quite accurate; `colorThemeOverride: undefined` is not the same as `colorThemeOverride` not being defined. For example, `"colorThemeOverride" in settings` would have different behavior with `undefined` as the key compared to not being defined.
-
-`exactOptionalPropertyTypes` makes TypeScript truly enforce the definition provided as an optional property:
-
-```ts twoslash
-// @exactOptionalPropertyTypes
-// @errors: 2322 2412
-interface UserDefaults {
-  colorThemeOverride?: 'dark' | 'light';
-}
-declare function getUserSettings(): UserDefaults;
-// ---cut---
-const settings = getUserSettings();
-settings.colorThemeOverride = 'dark';
-settings.colorThemeOverride = 'light';
-
-// But not:
-settings.colorThemeOverride = undefined;
-```

package/docs/tsconfig/exclude.md

@@ -1,11 +0,0 @@
----
-display: 'Exclude'
-oneline: 'Filters results from the [`include`](#include) option.'
----
-
-Specifies an array of filenames or patterns that should be skipped when resolving [`include`](#include).
-
-**Important**: `exclude` _only_ changes which files are included as a result of the [`include`](#include) setting.
-A file specified by `exclude` can still become part of your codebase due to an `import` statement in your code, a `types` inclusion, a `/// <reference` directive, or being specified in the [`files`](#files) list.
-
-It is not a mechanism that **prevents** a file from being included in the codebase - it simply changes what the [`include`](#include) setting finds.