// Type definitions for prettier 2.6
|
// Project: https://prettier.io
|
// https://github.com/prettier/prettier
|
// Definitions by: Ika <https://github.com/ikatyang>
|
// Ifiok Jr. <https://github.com/ifiokjr>
|
// Florian Imdahl <https://github.com/ffflorian>
|
// Sosuke Suzuki <https://github.com/sosukesuzuki>
|
// Christopher Quadflieg <https://github.com/Shinigami92>
|
// Georgii Dolzhykov <https://github.com/thorn0>
|
// JounQin <https://github.com/JounQin>
|
// Chuah Chee Shian <https://github.com/shian15810>
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
// Minimum TypeScript Version: 4.2
|
|
// Adding export {} here to shut off automatic exporting from index.d.ts. There
|
// are quite a few utility types here that don't need to be shipped with the
|
// exported module.
|
export {};
|
|
// This utility is here to handle the case where you have an explicit union
|
// between string literals and the generic string type. It would normally
|
// resolve out to just the string type, but this generic LiteralUnion maintains
|
// the intellisense of the original union.
|
//
|
// It comes from this issue: microsoft/TypeScript#29729:
|
// https://github.com/microsoft/TypeScript/issues/29729#issuecomment-700527227
|
export type LiteralUnion<T extends U, U = string> = T | (Pick<U, never> & { _?: never | undefined });
|
|
export type AST = any;
|
export type Doc = doc.builders.Doc;
|
|
// The type of elements that make up the given array T.
|
type ArrayElement<T> = T extends Array<infer E> ? E : never;
|
|
// A union of the properties of the given object that are arrays.
|
type ArrayProperties<T> = { [K in keyof T]: T[K] extends any[] ? K : never }[keyof T];
|
|
// A union of the properties of the given array T that can be used to index it.
|
// If the array is a tuple, then that's going to be the explicit indices of the
|
// array, otherwise it's going to just be number.
|
type IndexProperties<T extends { length: number }> = IsTuple<T> extends true
|
? Exclude<Partial<T>['length'], T['length']>
|
: number;
|
|
// Effectively performing T[P], except that it's telling TypeScript that it's
|
// safe to do this for tuples, arrays, or objects.
|
type IndexValue<T, P> = T extends any[] ? (P extends number ? T[P] : never) : P extends keyof T ? T[P] : never;
|
|
// Determines if an object T is an array like string[] (in which case this
|
// evaluates to false) or a tuple like [string] (in which case this evaluates to
|
// true).
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
type IsTuple<T> = T extends [] ? true : T extends [infer First, ...infer Remain] ? IsTuple<Remain> : false;
|
|
type CallProperties<T> = T extends any[] ? IndexProperties<T> : keyof T;
|
type IterProperties<T> = T extends any[] ? IndexProperties<T> : ArrayProperties<T>;
|
|
type CallCallback<T, U> = (path: AstPath<T>, index: number, value: any) => U;
|
type EachCallback<T> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => void;
|
type MapCallback<T, U> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => U;
|
|
// https://github.com/prettier/prettier/blob/main/src/common/ast-path.js
|
export class AstPath<T = any> {
|
constructor(value: T);
|
stack: T[];
|
callParent<U>(callback: (path: this) => U, count?: number): U;
|
getName(): PropertyKey | null;
|
getValue(): T;
|
getNode(count?: number): T | null;
|
getParentNode(count?: number): T | null;
|
match(...predicates: Array<(node: any, name: string | null, number: number | null) => boolean>): boolean;
|
|
// For each of the tree walk functions (call, each, and map) this provides 5
|
// strict type signatures, along with a fallback at the end if you end up
|
// calling more than 5 properties deep. This helps a lot with typing because
|
// for the majority of cases you're calling fewer than 5 properties, so the
|
// tree walk functions have a clearer understanding of what you're doing.
|
//
|
// Note that resolving these types is somewhat complicated, and it wasn't
|
// even supported until TypeScript 4.2 (before it would just say that the
|
// type instantiation was excessively deep and possibly infinite).
|
|
call<U>(callback: CallCallback<T, U>): U;
|
call<U, P1 extends CallProperties<T>>(callback: CallCallback<IndexValue<T, P1>, U>, prop1: P1): U;
|
call<U, P1 extends keyof T, P2 extends CallProperties<T[P1]>>(
|
callback: CallCallback<IndexValue<IndexValue<T, P1>, P2>, U>,
|
prop1: P1,
|
prop2: P2,
|
): U;
|
call<U, P1 extends keyof T, P2 extends CallProperties<T[P1]>, P3 extends CallProperties<IndexValue<T[P1], P2>>>(
|
callback: CallCallback<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, U>,
|
prop1: P1,
|
prop2: P2,
|
prop3: P3,
|
): U;
|
call<
|
U,
|
P1 extends keyof T,
|
P2 extends CallProperties<T[P1]>,
|
P3 extends CallProperties<IndexValue<T[P1], P2>>,
|
P4 extends CallProperties<IndexValue<IndexValue<T[P1], P2>, P3>>
|
>(
|
callback: CallCallback<IndexValue<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, P4>, U>,
|
prop1: P1,
|
prop2: P2,
|
prop3: P3,
|
prop4: P4,
|
): U;
|
call<U, P extends PropertyKey>(
|
callback: CallCallback<any, U>,
|
prop1: P,
|
prop2: P,
|
prop3: P,
|
prop4: P,
|
...props: P[]
|
): U;
|
|
each(callback: EachCallback<T>): void;
|
each<P1 extends IterProperties<T>>(callback: EachCallback<IndexValue<T, P1>>, prop1: P1): void;
|
each<P1 extends keyof T, P2 extends IterProperties<T[P1]>>(
|
callback: EachCallback<IndexValue<IndexValue<T, P1>, P2>>,
|
prop1: P1,
|
prop2: P2,
|
): void;
|
each<P1 extends keyof T, P2 extends IterProperties<T[P1]>, P3 extends IterProperties<IndexValue<T[P1], P2>>>(
|
callback: EachCallback<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>>,
|
prop1: P1,
|
prop2: P2,
|
prop3: P3,
|
): void;
|
each<
|
P1 extends keyof T,
|
P2 extends IterProperties<T[P1]>,
|
P3 extends IterProperties<IndexValue<T[P1], P2>>,
|
P4 extends IterProperties<IndexValue<IndexValue<T[P1], P2>, P3>>
|
>(
|
callback: EachCallback<IndexValue<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, P4>>,
|
prop1: P1,
|
prop2: P2,
|
prop3: P3,
|
prop4: P4,
|
): void;
|
each(
|
callback: EachCallback<any[]>,
|
prop1: PropertyKey,
|
prop2: PropertyKey,
|
prop3: PropertyKey,
|
prop4: PropertyKey,
|
...props: PropertyKey[]
|
): void;
|
|
map<U>(callback: MapCallback<T, U>): U[];
|
map<U, P1 extends IterProperties<T>>(callback: MapCallback<IndexValue<T, P1>, U>, prop1: P1): U[];
|
map<U, P1 extends keyof T, P2 extends IterProperties<T[P1]>>(
|
callback: MapCallback<IndexValue<IndexValue<T, P1>, P2>, U>,
|
prop1: P1,
|
prop2: P2,
|
): U[];
|
map<U, P1 extends keyof T, P2 extends IterProperties<T[P1]>, P3 extends IterProperties<IndexValue<T[P1], P2>>>(
|
callback: MapCallback<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, U>,
|
prop1: P1,
|
prop2: P2,
|
prop3: P3,
|
): U[];
|
map<
|
U,
|
P1 extends keyof T,
|
P2 extends IterProperties<T[P1]>,
|
P3 extends IterProperties<IndexValue<T[P1], P2>>,
|
P4 extends IterProperties<IndexValue<IndexValue<T[P1], P2>, P3>>
|
>(
|
callback: MapCallback<IndexValue<IndexValue<IndexValue<IndexValue<T, P1>, P2>, P3>, P4>, U>,
|
prop1: P1,
|
prop2: P2,
|
prop3: P3,
|
prop4: P4,
|
): U[];
|
map<U>(
|
callback: MapCallback<any[], U>,
|
prop1: PropertyKey,
|
prop2: PropertyKey,
|
prop3: PropertyKey,
|
prop4: PropertyKey,
|
...props: PropertyKey[]
|
): U[];
|
}
|
|
/** @deprecated `FastPath` was renamed to `AstPath` */
|
export type FastPath<T = any> = AstPath<T>;
|
|
export type BuiltInParser = (text: string, options?: any) => AST;
|
export type BuiltInParserName =
|
| 'angular'
|
| 'babel-flow'
|
| 'babel-ts'
|
| 'babel'
|
| 'css'
|
| 'espree'
|
| 'flow'
|
| 'glimmer'
|
| 'graphql'
|
| 'html'
|
| 'json-stringify'
|
| 'json'
|
| 'json5'
|
| 'less'
|
| 'lwc'
|
| 'markdown'
|
| 'mdx'
|
| 'meriyah'
|
| 'scss'
|
| 'typescript'
|
| 'vue'
|
| 'yaml';
|
export type BuiltInParsers = Record<BuiltInParserName, BuiltInParser>;
|
|
export type CustomParser = (text: string, parsers: BuiltInParsers, options: Options) => AST;
|
|
/**
|
* For use in `.prettierrc.js`, `.prettierrc.cjs`, `prettier.config.js` or `prettier.config.cjs`.
|
*/
|
export interface Config extends Options {
|
overrides?: Array<{
|
files: string | string[];
|
excludeFiles?: string | string[];
|
options?: Options;
|
}>;
|
}
|
|
export interface Options extends Partial<RequiredOptions> {}
|
|
export interface RequiredOptions extends doc.printer.Options {
|
/**
|
* Print semicolons at the ends of statements.
|
* @default true
|
*/
|
semi: boolean;
|
/**
|
* Use single quotes instead of double quotes.
|
* @default false
|
*/
|
singleQuote: boolean;
|
/**
|
* Use single quotes in JSX.
|
* @default false
|
*/
|
jsxSingleQuote: boolean;
|
/**
|
* Print trailing commas wherever possible.
|
* @default 'es5'
|
*/
|
trailingComma: 'none' | 'es5' | 'all';
|
/**
|
* Print spaces between brackets in object literals.
|
* @default true
|
*/
|
bracketSpacing: boolean;
|
/**
|
* Put the `>` of a multi-line HTML (HTML, JSX, Vue, Angular) element at the end of the last line instead of being
|
* alone on the next line (does not apply to self closing elements).
|
* @default false
|
*/
|
bracketSameLine: boolean;
|
/**
|
* Put the `>` of a multi-line JSX element at the end of the last line instead of being alone on the next line.
|
* @default false
|
* @deprecated use bracketSameLine instead
|
*/
|
jsxBracketSameLine: boolean;
|
/**
|
* Format only a segment of a file.
|
* @default 0
|
*/
|
rangeStart: number;
|
/**
|
* Format only a segment of a file.
|
* @default Infinity
|
*/
|
rangeEnd: number;
|
/**
|
* Specify which parser to use.
|
*/
|
parser: LiteralUnion<BuiltInParserName> | CustomParser;
|
/**
|
* Specify the input filepath. This will be used to do parser inference.
|
*/
|
filepath: string;
|
/**
|
* Prettier can restrict itself to only format files that contain a special comment, called a pragma, at the top of the file.
|
* This is very useful when gradually transitioning large, unformatted codebases to prettier.
|
* @default false
|
*/
|
requirePragma: boolean;
|
/**
|
* Prettier can insert a special @format marker at the top of files specifying that
|
* the file has been formatted with prettier. This works well when used in tandem with
|
* the --require-pragma option. If there is already a docblock at the top of
|
* the file then this option will add a newline to it with the @format marker.
|
* @default false
|
*/
|
insertPragma: boolean;
|
/**
|
* By default, Prettier will wrap markdown text as-is since some services use a linebreak-sensitive renderer.
|
* In some cases you may want to rely on editor/viewer soft wrapping instead, so this option allows you to opt out.
|
* @default 'preserve'
|
*/
|
proseWrap: 'always' | 'never' | 'preserve';
|
/**
|
* Include parentheses around a sole arrow function parameter.
|
* @default 'always'
|
*/
|
arrowParens: 'avoid' | 'always';
|
/**
|
* Provide ability to support new languages to prettier.
|
*/
|
plugins: Array<string | Plugin>;
|
/**
|
* Specify plugin directory paths to search for plugins if not installed in the same `node_modules` where prettier is located.
|
*/
|
pluginSearchDirs: string[] | false;
|
/**
|
* How to handle whitespaces in HTML.
|
* @default 'css'
|
*/
|
htmlWhitespaceSensitivity: 'css' | 'strict' | 'ignore';
|
/**
|
* Which end of line characters to apply.
|
* @default 'lf'
|
*/
|
endOfLine: 'auto' | 'lf' | 'crlf' | 'cr';
|
/**
|
* Change when properties in objects are quoted.
|
* @default 'as-needed'
|
*/
|
quoteProps: 'as-needed' | 'consistent' | 'preserve';
|
/**
|
* Whether or not to indent the code inside <script> and <style> tags in Vue files.
|
* @default false
|
*/
|
vueIndentScriptAndStyle: boolean;
|
/**
|
* Control whether Prettier formats quoted code embedded in the file.
|
* @default 'auto'
|
*/
|
embeddedLanguageFormatting: 'auto' | 'off';
|
/**
|
* Enforce single attribute per line in HTML, Vue and JSX.
|
* @default false
|
*/
|
singleAttributePerLine: boolean;
|
}
|
|
export interface ParserOptions<T = any> extends RequiredOptions {
|
locStart: (node: T) => number;
|
locEnd: (node: T) => number;
|
originalText: string;
|
}
|
|
export interface Plugin<T = any> {
|
languages?: SupportLanguage[] | undefined;
|
parsers?: { [parserName: string]: Parser<T> } | undefined;
|
printers?: { [astFormat: string]: Printer<T> } | undefined;
|
options?: SupportOptions | undefined;
|
defaultOptions?: Partial<RequiredOptions> | undefined;
|
}
|
|
export interface Parser<T = any> {
|
parse: (text: string, parsers: { [parserName: string]: Parser }, options: ParserOptions<T>) => T;
|
astFormat: string;
|
hasPragma?: ((text: string) => boolean) | undefined;
|
locStart: (node: T) => number;
|
locEnd: (node: T) => number;
|
preprocess?: ((text: string, options: ParserOptions<T>) => string) | undefined;
|
}
|
|
export interface Printer<T = any> {
|
print(path: AstPath<T>, options: ParserOptions<T>, print: (path: AstPath<T>) => Doc): Doc;
|
embed?:
|
| ((
|
path: AstPath<T>,
|
print: (path: AstPath<T>) => Doc,
|
textToDoc: (text: string, options: Options) => Doc,
|
options: ParserOptions<T>,
|
) => Doc | null)
|
| undefined;
|
insertPragma?: ((text: string) => string) | undefined;
|
/**
|
* @returns `null` if you want to remove this node
|
* @returns `void` if you want to use modified newNode
|
* @returns anything if you want to replace the node with it
|
*/
|
massageAstNode?: ((node: any, newNode: any, parent: any) => any) | undefined;
|
hasPrettierIgnore?: ((path: AstPath<T>) => boolean) | undefined;
|
canAttachComment?: ((node: T) => boolean) | undefined;
|
isBlockComment?: ((node: T) => boolean) | undefined;
|
willPrintOwnComments?: ((path: AstPath<T>) => boolean) | undefined;
|
printComment?: ((commentPath: AstPath<T>, options: ParserOptions<T>) => Doc) | undefined;
|
handleComments?:
|
| {
|
ownLine?:
|
| ((
|
commentNode: any,
|
text: string,
|
options: ParserOptions<T>,
|
ast: T,
|
isLastComment: boolean,
|
) => boolean)
|
| undefined;
|
endOfLine?:
|
| ((
|
commentNode: any,
|
text: string,
|
options: ParserOptions<T>,
|
ast: T,
|
isLastComment: boolean,
|
) => boolean)
|
| undefined;
|
remaining?:
|
| ((
|
commentNode: any,
|
text: string,
|
options: ParserOptions<T>,
|
ast: T,
|
isLastComment: boolean,
|
) => boolean)
|
| undefined;
|
}
|
| undefined;
|
}
|
|
export interface CursorOptions extends Options {
|
/**
|
* Specify where the cursor is.
|
*/
|
cursorOffset: number;
|
rangeStart?: never;
|
rangeEnd?: never;
|
}
|
|
export interface CursorResult {
|
formatted: string;
|
cursorOffset: number;
|
}
|
|
/**
|
* `format` is used to format text using Prettier. [Options](https://prettier.io/docs/en/options.html) may be provided to override the defaults.
|
*/
|
export function format(source: string, options?: Options): string;
|
|
/**
|
* `check` checks to see if the file has been formatted with Prettier given those options and returns a `Boolean`.
|
* This is similar to the `--list-different` parameter in the CLI and is useful for running Prettier in CI scenarios.
|
*/
|
export function check(source: string, options?: Options): boolean;
|
|
/**
|
* `formatWithCursor` both formats the code, and translates a cursor position from unformatted code to formatted code.
|
* This is useful for editor integrations, to prevent the cursor from moving when code is formatted.
|
*
|
* The `cursorOffset` option should be provided, to specify where the cursor is. This option cannot be used with `rangeStart` and `rangeEnd`.
|
*/
|
export function formatWithCursor(source: string, options: CursorOptions): CursorResult;
|
|
export interface ResolveConfigOptions {
|
/**
|
* If set to `false`, all caching will be bypassed.
|
*/
|
useCache?: boolean | undefined;
|
/**
|
* Pass directly the path of the config file if you don't wish to search for it.
|
*/
|
config?: string | undefined;
|
/**
|
* If set to `true` and an `.editorconfig` file is in your project,
|
* Prettier will parse it and convert its properties to the corresponding prettier configuration.
|
* This configuration will be overridden by `.prettierrc`, etc. Currently,
|
* the following EditorConfig properties are supported:
|
* - indent_style
|
* - indent_size/tab_width
|
* - max_line_length
|
*/
|
editorconfig?: boolean | undefined;
|
}
|
|
/**
|
* `resolveConfig` can be used to resolve configuration for a given source file,
|
* passing its path as the first argument. The config search will start at the
|
* file path and continue to search up the directory.
|
* (You can use `process.cwd()` to start searching from the current directory).
|
*
|
* A promise is returned which will resolve to:
|
*
|
* - An options object, providing a [config file](https://prettier.io/docs/en/configuration.html) was found.
|
* - `null`, if no file was found.
|
*
|
* The promise will be rejected if there was an error parsing the configuration file.
|
*/
|
export function resolveConfig(filePath: string, options?: ResolveConfigOptions): Promise<Options | null>;
|
export namespace resolveConfig {
|
function sync(filePath: string, options?: ResolveConfigOptions): Options | null;
|
}
|
|
/**
|
* `resolveConfigFile` can be used to find the path of the Prettier configuration file,
|
* that will be used when resolving the config (i.e. when calling `resolveConfig`).
|
*
|
* A promise is returned which will resolve to:
|
*
|
* - The path of the configuration file.
|
* - `null`, if no file was found.
|
*
|
* The promise will be rejected if there was an error parsing the configuration file.
|
*/
|
export function resolveConfigFile(filePath?: string): Promise<string | null>;
|
export namespace resolveConfigFile {
|
function sync(filePath?: string): string | null;
|
}
|
|
/**
|
* As you repeatedly call `resolveConfig`, the file system structure will be cached for performance. This function will clear the cache.
|
* Generally this is only needed for editor integrations that know that the file system has changed since the last format took place.
|
*/
|
export function clearConfigCache(): void;
|
|
export interface SupportLanguage {
|
name: string;
|
since?: string | undefined;
|
parsers: BuiltInParserName[] | string[];
|
group?: string | undefined;
|
tmScope?: string | undefined;
|
aceMode?: string | undefined;
|
codemirrorMode?: string | undefined;
|
codemirrorMimeType?: string | undefined;
|
aliases?: string[] | undefined;
|
extensions?: string[] | undefined;
|
filenames?: string[] | undefined;
|
linguistLanguageId?: number | undefined;
|
vscodeLanguageIds?: string[] | undefined;
|
}
|
|
export interface SupportOptionRange {
|
start: number;
|
end: number;
|
step: number;
|
}
|
|
export type SupportOptionType = 'int' | 'boolean' | 'choice' | 'path';
|
|
export type CoreCategoryType = 'Config' | 'Editor' | 'Format' | 'Other' | 'Output' | 'Global' | 'Special';
|
|
export interface BaseSupportOption<Type extends SupportOptionType> {
|
readonly name?: string | undefined;
|
since: string;
|
/**
|
* Usually you can use {@link CoreCategoryType}
|
*/
|
category: string;
|
/**
|
* The type of the option.
|
*
|
* When passing a type other than the ones listed below, the option is
|
* treated as taking any string as argument, and `--option <${type}>` will
|
* be displayed in --help.
|
*/
|
type: Type;
|
/**
|
* Indicate that the option is deprecated.
|
*
|
* Use a string to add an extra message to --help for the option,
|
* for example to suggest a replacement option.
|
*/
|
deprecated?: true | string | undefined;
|
/**
|
* Description to be displayed in --help. If omitted, the option won't be
|
* shown at all in --help.
|
*/
|
description?: string | undefined;
|
}
|
|
export interface IntSupportOption extends BaseSupportOption<'int'> {
|
default?: number | undefined;
|
array?: false | undefined;
|
range?: SupportOptionRange | undefined;
|
}
|
|
export interface IntArraySupportOption extends BaseSupportOption<'int'> {
|
default?: Array<{ value: number[] }> | undefined;
|
array: true;
|
}
|
|
export interface BooleanSupportOption extends BaseSupportOption<'boolean'> {
|
default?: boolean | undefined;
|
array?: false | undefined;
|
description: string;
|
oppositeDescription?: string | undefined;
|
}
|
|
export interface BooleanArraySupportOption extends BaseSupportOption<'boolean'> {
|
default?: Array<{ value: boolean[] }> | undefined;
|
array: true;
|
}
|
|
export interface ChoiceSupportOption<Value = any> extends BaseSupportOption<'choice'> {
|
default?: Value | Array<{ since: string; value: Value }> | undefined;
|
description: string;
|
choices: Array<{
|
since?: string | undefined;
|
value: Value;
|
description: string;
|
}>;
|
}
|
|
export interface PathSupportOption extends BaseSupportOption<'path'> {
|
default?: string | undefined;
|
array?: false | undefined;
|
}
|
|
export interface PathArraySupportOption extends BaseSupportOption<'path'> {
|
default?: Array<{ value: string[] }> | undefined;
|
array: true;
|
}
|
|
export type SupportOption =
|
| IntSupportOption
|
| IntArraySupportOption
|
| BooleanSupportOption
|
| BooleanArraySupportOption
|
| ChoiceSupportOption
|
| PathSupportOption
|
| PathArraySupportOption;
|
|
export interface SupportOptions extends Record<string, SupportOption> {}
|
|
export interface SupportInfo {
|
languages: SupportLanguage[];
|
options: SupportOption[];
|
}
|
|
export interface FileInfoOptions {
|
ignorePath?: string | undefined;
|
withNodeModules?: boolean | undefined;
|
plugins?: string[] | undefined;
|
resolveConfig?: boolean | undefined;
|
}
|
|
export interface FileInfoResult {
|
ignored: boolean;
|
inferredParser: string | null;
|
}
|
|
export function getFileInfo(filePath: string, options?: FileInfoOptions): Promise<FileInfoResult>;
|
|
export namespace getFileInfo {
|
function sync(filePath: string, options?: FileInfoOptions): FileInfoResult;
|
}
|
|
/**
|
* Returns an object representing the parsers, languages and file types Prettier supports for the current version.
|
*/
|
export function getSupportInfo(): SupportInfo;
|
|
/**
|
* `version` field in `package.json`
|
*/
|
export const version: string;
|
|
// https://github.com/prettier/prettier/blob/main/src/common/util-shared.js
|
export namespace util {
|
interface SkipOptions {
|
backwards?: boolean | undefined;
|
}
|
|
type Quote = "'" | '"';
|
|
function addDanglingComment(node: any, comment: any, marker: any): void;
|
function addLeadingComment(node: any, comment: any): void;
|
function addTrailingComment(node: any, comment: any): void;
|
function getAlignmentSize(value: string, tabWidth: number, startIndex?: number): number;
|
function getIndentSize(value: string, tabWidth: number): number;
|
function getMaxContinuousCount(str: string, target: string): number;
|
function getNextNonSpaceNonCommentCharacterIndex<N>(
|
text: string,
|
node: N,
|
locEnd: (node: N) => number,
|
): number | false;
|
function getStringWidth(text: string): number;
|
function hasNewline(text: string, index: number, opts?: SkipOptions): boolean;
|
function hasNewlineInRange(text: string, start: number, end: number): boolean;
|
function hasSpaces(text: string, index: number, opts?: SkipOptions): boolean;
|
function isNextLineEmpty<N>(text: string, node: N, locEnd: (node: N) => number): boolean;
|
function isNextLineEmptyAfterIndex(text: string, index: number): boolean;
|
function isPreviousLineEmpty<N>(text: string, node: N, locStart: (node: N) => number): boolean;
|
function makeString(rawContent: string, enclosingQuote: Quote, unescapeUnnecessaryEscapes?: boolean): string;
|
function skip(chars: string | RegExp): (text: string, index: number | false, opts?: SkipOptions) => number | false;
|
function skipEverythingButNewLine(text: string, index: number | false, opts?: SkipOptions): number | false;
|
function skipInlineComment(text: string, index: number | false): number | false;
|
function skipNewline(text: string, index: number | false, opts?: SkipOptions): number | false;
|
function skipSpaces(text: string, index: number | false, opts?: SkipOptions): number | false;
|
function skipToLineEnd(text: string, index: number | false, opts?: SkipOptions): number | false;
|
function skipTrailingComment(text: string, index: number | false): number | false;
|
function skipWhitespace(text: string, index: number | false, opts?: SkipOptions): number | false;
|
}
|
|
// https://github.com/prettier/prettier/blob/main/src/document/index.js
|
export namespace doc {
|
namespace builders {
|
type DocCommand =
|
| Align
|
| BreakParent
|
| Concat
|
| Cursor
|
| Fill
|
| Group
|
| IfBreak
|
| Indent
|
| IndentIfBreak
|
| Label
|
| Line
|
| LineSuffix
|
| LineSuffixBoundary
|
| Trim;
|
type Doc = string | Doc[] | DocCommand;
|
|
interface Align {
|
type: 'align';
|
contents: Doc;
|
n: number | string | { type: 'root' };
|
}
|
|
interface BreakParent {
|
type: 'break-parent';
|
}
|
|
interface Concat {
|
type: 'concat';
|
parts: Doc[];
|
}
|
|
interface Cursor {
|
type: 'cursor';
|
placeholder: symbol;
|
}
|
|
interface Fill {
|
type: 'fill';
|
parts: Doc[];
|
}
|
|
interface Group {
|
type: 'group';
|
contents: Doc;
|
break: boolean;
|
expandedStates: Doc[];
|
}
|
|
interface HardlineWithoutBreakParent extends Line {
|
hard: true;
|
}
|
|
interface IfBreak {
|
type: 'if-break';
|
breakContents: Doc;
|
flatContents: Doc;
|
}
|
|
interface Indent {
|
type: 'indent';
|
contents: Doc;
|
}
|
|
interface IndentIfBreak {
|
type: 'indent-if-break';
|
}
|
|
interface Label {
|
type: 'label';
|
}
|
|
interface Line {
|
type: 'line';
|
soft?: boolean | undefined;
|
hard?: boolean | undefined;
|
literal?: boolean | undefined;
|
}
|
|
interface LineSuffix {
|
type: 'line-suffix';
|
contents: Doc;
|
}
|
|
interface LineSuffixBoundary {
|
type: 'line-suffix-boundary';
|
}
|
|
interface LiterallineWithoutBreakParent extends Line {
|
hard: true;
|
literal: true;
|
}
|
|
interface Softline extends Line {
|
soft: true;
|
}
|
|
interface Trim {
|
type: 'trim';
|
}
|
|
interface GroupOptions {
|
shouldBreak?: boolean | undefined;
|
id?: symbol | undefined;
|
}
|
|
function addAlignmentToDoc(doc: Doc, size: number, tabWidth: number): Doc;
|
/** @see [align](https://github.com/prettier/prettier/blob/main/commands.md#align) */
|
function align(widthOrString: Align['n'], doc: Doc): Align;
|
/** @see [breakParent](https://github.com/prettier/prettier/blob/main/commands.md#breakparent) */
|
const breakParent: BreakParent;
|
/**
|
* @see [concat](https://github.com/prettier/prettier/blob/main/commands.md#deprecated-concat)
|
* @deprecated use `Doc[]` instead
|
*/
|
function concat(docs: Doc[]): Concat;
|
/** @see [conditionalGroup](https://github.com/prettier/prettier/blob/main/commands.md#conditionalgroup) */
|
function conditionalGroup(alternatives: Doc[], options?: GroupOptions): Group;
|
/** @see [dedent](https://github.com/prettier/prettier/blob/main/commands.md#dedent) */
|
function dedent(doc: Doc): Align;
|
/** @see [dedentToRoot](https://github.com/prettier/prettier/blob/main/commands.md#dedenttoroot) */
|
function dedentToRoot(doc: Doc): Align;
|
/** @see [fill](https://github.com/prettier/prettier/blob/main/commands.md#fill) */
|
function fill(docs: Doc[]): Fill;
|
/** @see [group](https://github.com/prettier/prettier/blob/main/commands.md#group) */
|
function group(doc: Doc, opts?: GroupOptions): Group;
|
/** @see [hardline](https://github.com/prettier/prettier/blob/main/commands.md#hardline) */
|
const hardline: Concat;
|
/** @see [hardlineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent) */
|
const hardlineWithoutBreakParent: HardlineWithoutBreakParent;
|
/** @see [ifBreak](https://github.com/prettier/prettier/blob/main/commands.md#ifbreak) */
|
function ifBreak(ifBreak: Doc, noBreak?: Doc, options?: { groupId?: symbol | undefined }): IfBreak;
|
/** @see [indent](https://github.com/prettier/prettier/blob/main/commands.md#indent) */
|
function indent(doc: Doc): Indent;
|
/** @see [indentIfBreak](https://github.com/prettier/prettier/blob/main/commands.md#indentifbreak) */
|
function indentIfBreak(doc: Doc, opts: { groupId: symbol; negate?: boolean | undefined }): IndentIfBreak;
|
/** @see [join](https://github.com/prettier/prettier/blob/main/commands.md#join) */
|
function join(sep: Doc, docs: Doc[]): Concat;
|
/** @see [label](https://github.com/prettier/prettier/blob/main/commands.md#label) */
|
function label(label: string, doc: Doc): Label;
|
/** @see [line](https://github.com/prettier/prettier/blob/main/commands.md#line) */
|
const line: Line;
|
/** @see [lineSuffix](https://github.com/prettier/prettier/blob/main/commands.md#linesuffix) */
|
function lineSuffix(suffix: Doc): LineSuffix;
|
/** @see [lineSuffixBoundary](https://github.com/prettier/prettier/blob/main/commands.md#linesuffixboundary) */
|
const lineSuffixBoundary: LineSuffixBoundary;
|
/** @see [literalline](https://github.com/prettier/prettier/blob/main/commands.md#literalline) */
|
const literalline: Concat;
|
/** @see [literallineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent) */
|
const literallineWithoutBreakParent: LiterallineWithoutBreakParent;
|
/** @see [markAsRoot](https://github.com/prettier/prettier/blob/main/commands.md#markasroot) */
|
function markAsRoot(doc: Doc): Align;
|
/** @see [softline](https://github.com/prettier/prettier/blob/main/commands.md#softline) */
|
const softline: Softline;
|
/** @see [trim](https://github.com/prettier/prettier/blob/main/commands.md#trim) */
|
const trim: Trim;
|
/** @see [cursor](https://github.com/prettier/prettier/blob/main/commands.md#cursor) */
|
const cursor: Cursor;
|
}
|
namespace debug {
|
function printDocToDebug(doc: Doc): string;
|
}
|
namespace printer {
|
function printDocToString(
|
doc: Doc,
|
options: Options,
|
): {
|
formatted: string;
|
cursorNodeStart?: number | undefined;
|
cursorNodeText?: string | undefined;
|
};
|
interface Options {
|
/**
|
* Specify the line length that the printer will wrap on.
|
* @default 80
|
*/
|
printWidth: number;
|
/**
|
* Specify the number of spaces per indentation-level.
|
* @default 2
|
*/
|
tabWidth: number;
|
/**
|
* Indent lines with tabs instead of spaces
|
* @default false
|
*/
|
useTabs: boolean;
|
parentParser?: string | undefined;
|
__embeddedInHtml?: boolean | undefined;
|
}
|
}
|
namespace utils {
|
function cleanDoc(doc: Doc): Doc;
|
function findInDoc<T = Doc>(doc: Doc, callback: (doc: Doc) => T, defaultValue: T): T;
|
function getDocParts(doc: Doc): Doc;
|
function isConcat(doc: Doc): boolean;
|
function isEmpty(doc: Doc): boolean;
|
function isLineNext(doc: Doc): boolean;
|
function mapDoc<T = Doc>(doc: Doc, callback: (doc: Doc) => T): T;
|
function normalizeDoc(doc: Doc): Doc;
|
function normalizeParts(parts: Doc[]): Doc[];
|
function propagateBreaks(doc: Doc): void;
|
function removeLines(doc: Doc): Doc;
|
function replaceNewlinesWithLiterallines(doc: Doc): Doc;
|
function stripTrailingHardline(doc: Doc): Doc;
|
function traverseDoc(
|
doc: Doc,
|
onEnter?: (doc: Doc) => void | boolean,
|
onExit?: (doc: Doc) => void,
|
shouldTraverseConditionalGroups?: boolean,
|
): void;
|
function willBreak(doc: Doc): boolean;
|
}
|
}
|
