Stub TypeScript definitions entry for prettier, which provides its own types definitions

types

@types/prettier

//          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

// 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

// 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 });

// 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];

type ArrayProperties<T> = { [K in keyof T]: NonNullable<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']>

// 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

// 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

    callParent<U>(callback: (path: this) => U, count?: number): U;

    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>,

    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>,

        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>,

    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>>,

    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>>,

        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>>,

    "description": "TypeScript definitions for prettier",

    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/prettier",

            "url": "https://github.com/ikatyang",

            "url": "https://github.com/ifiokjr",

            "url": "https://github.com/ffflorian",

            "githubUsername": "ffflorian"

            "url": "https://github.com/sosukesuzuki",

            "githubUsername": "sosukesuzuki"

            "name": "Christopher Quadflieg",

            "url": "https://github.com/Shinigami92",

            "githubUsername": "Shinigami92"

            "url": "https://github.com/thorn0",

            "url": "https://github.com/JounQin",

            "url": "https://github.com/shian15810",

            "githubUsername": "shian15810"

        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",

    "typesPublisherContentHash": "1f8bd31de941c105038a0118731a95a48ca87963a5b76098ffc7b2c494917c11",

    "typesPublisherContentHash": "fb2b12d7afb5ceabf6cbcf703bb4c93aa8baa41a3531660c12add3a60364c43d",

This package contains type definitions for prettier (https://prettier.io).

Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/prettier.

 * Last updated: Thu, 12 May 2022 18:31:39 GMT

 * Last updated: Sat, 28 May 2022 01:31:28 GMT

These definitions were written 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), and [Chuah Chee Shian](https://github.com/shian15810).

		{
		"name": "@types/prettier",
		"version": "2.6.1",
		"version": "2.6.2",
		"description": "TypeScript definitions for prettier",
		@@ -58,4 +58,4 @@ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/prettier",
		"dependencies": {},
		"typesPublisherContentHash": "1f8bd31de941c105038a0118731a95a48ca87963a5b76098ffc7b2c494917c11",
		"typesPublisherContentHash": "fb2b12d7afb5ceabf6cbcf703bb4c93aa8baa41a3531660c12add3a60364c43d",
		"typeScriptVersion": "4.2"
		}

		@@ -11,3 +11,3 @@ # Installation
		### Additional Details
		* Last updated: Thu, 12 May 2022 18:31:39 GMT
		* Last updated: Sat, 28 May 2022 01:31:28 GMT
		* Dependencies: none
		@@ -14,0 +14,0 @@ * Global values: `prettier`

		@@ -36,3 +36,3 @@ // Type definitions for prettier 2.6
		// 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];
		type ArrayProperties<T> = { [K in keyof T]: NonNullable<T[K]> extends any[] ? K : never }[keyof T];

		@@ -39,0 +39,0 @@ // A union of the properties of the given array T that can be used to index it.

Improved metrics