@types/prettier - npm Package Compare versions

Comparing version 2.6.0 to 2.6.1

prettier/index.d.ts

@@ -13,4 +13,9 @@ // Type definitions for prettier 2.6
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 3.7
+// 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
@@ -28,7 +33,37 @@ // between string literals and the generic string type. It would normally
 
+// 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;
@@ -38,7 +73,117 @@ getValue(): T;
     getParentNode(count?: number): T | null;
-    call<U>(callback: (path: this) => U, ...names: PropertyKey[]): U;
-    callParent<U>(callback: (path: this) => U, count?: number): U;
-    each(callback: (path: this, index: number, value: any) => void, ...names: PropertyKey[]): void;
-    map<U>(callback: (path: this, index: number, value: any) => U, ...names: PropertyKey[]): U[];
     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[];
 }
@@ -45,0 +190,0 @@

prettier/package.json

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

prettier/README.md

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

No alert changes

Improved metrics

Total package byte prevSize

48805

increased by13.54%

Lines of code

1164

increased by13.01%

No dependency changes