Microsoft annonce la disponibilité de TypeScript 5.8 Beta avec plusieurs améliorations

Dont une meilleure vérification des types de retours pour les types d'accès conditionnels et indexés

npm install -D typescript@beta

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/** 
 * @param prompt The text to show to a user. 
 * @param selectionKind Whether a user can select multiple options, or just a single option. 
 * @param items Each of the options presented to the user. 
 **/ 
async function showQuickPick( 
    prompt: string, 
    selectionKind: SelectionKind, 
    items: readonly string[], 
): Promise<string | string[]> { 
    // ... 
} 
 
enum SelectionKind { 
    Single, 
    Multiple, 
}

1
2
3
4
5
6
7
8
9
10
11
let shoppingList = await showQuickPick( 
    "Which fruits do you want to purchase?", 
    SelectionKind.Multiple, 
    ["apples", "oranges", "bananas", "durian"], 
); 
 
console.log(`Alright, going out to buy some ${shoppingList.join(", ")}`); 
//                                                         ~~~~ 
// error! 
// Property 'join' does not exist on type 'string | string[]'. 
//  Property 'join' does not exist on type 'string'.

1
2
3
4
5
6
7
8
9
10
type QuickPickReturn<S extends SelectionKind> = 
    S extends SelectionKind.Multiple ? string[] : string 
 
async function showQuickPick<S extends SelectionKind>( 
    prompt: string, 
    selectionKind: S, 
    items: readonly string[], 
): Promise<QuickPickReturn<S>> { 
    // ... 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// `SelectionKind.Multiple` gives a `string[]` - works  
let shoppingList: string[] = await showQuickPick( 
    "Which fruits do you want to purchase?", 
    SelectionKind.Multiple, 
    ["apples", "oranges", "bananas", "durian"], 
); 
 
// `SelectionKind.Single` gives a `string` - works  
let dinner: string = await showQuickPick( 
    "What's for dinner tonight?", 
    SelectionKind.Single, 
    ["sushi", "pasta", "tacos", "ugh I'm too hungry to think, whatever you want"], 
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
async function showQuickPick<S extends SelectionKind>( 
    prompt: string, 
    selectionKind: S, 
    items: readonly string[], 
): Promise<QuickPickReturn<S>> { 
    if (items.length < 1) { 
        throw new Error("At least one item must be provided."); 
    } 
     
    // Create buttons for every option. 
    let buttons = items.map(item => ({ 
        selected: false, 
        text: item, 
    })); 
 
    // Default to the first element if necessary. 
    if (selectionKind === SelectionKind.Single) { 
        buttons[0].selected = true; 
    } 
 
    // Event handling code goes here... 
 
    // Figure out the selected items 
    const selectedItems = buttons 
        .filter(button => button.selected) 
        .map(button => button.text); 
 
    if (selectionKind === SelectionKind.Single) { 
        // Pick the first (only) selected item. 
        return selectedItems[0]; 
    } 
    else { 
        // Return all selected items. 
        return selectedItems; 
    } 
}

1
2
Type 'string[]' is not assignable to type 'QuickPickReturn<S>'. 
Type 'string' is not assignable to type 'QuickPickReturn<S>'.

1
2
3
4
5
6
7
8
9
10
      if (selectionKind === SelectionKind.Single) { 
          // Pick the first (only) selected item. 
-         return selectedItems[0]; 
+         return selectedItems[0] as QuickPickReturn<S>; 
      } 
      else { 
          // Return all selected items. 
-         return selectedItems; 
+         return selectedItems as QuickPickReturn<S>; 
      }

1
2
3
4
5
6
7
8
    if (selectionKind === SelectionKind.Single) { 
        // Oops! Returning an array when the caller expects a single item! 
        return selectedItems; 
    } 
    else { 
        // Oops! Returning a single item when the caller expects an array!  
        return selectedItems[0]; 
    }

1
2
3
4
type QuickPickReturn<S extends SelectionKind> = 
    S extends SelectionKind.Multiple ? string[] : 
    S extends SelectionKind.Single ? string : 
    never;

1
2
3
4
5
6
7
8
9
10
11
12
    if (selectionKind === SelectionKind.Single) { 
        // Oops! Returning an array when the caller expects a single item! 
        return selectedItems; 
    //  ~~~~~~ 
    // error! Type 'string[]' is not assignable to type 'string'. 
    } 
    else { 
        // Oops! Returning a single item when the caller expects an array!  
        return selectedItems[0]; 
    //  ~~~~~~ 
    // error! Type 'string[]' is not assignable to type 'string'. 
}

1
2
3
4
5
6
7
8
9
10
11
12
interface QuickPickReturn { 
    [SelectionKind.Single]: string; 
    [SelectionKind.Multiple]: string[]; 
} 
 
async function showQuickPick<S extends SelectionKind>( 
    prompt: string, 
    selectionKind: S, 
    items: readonly string[], 
): Promise<QuickPickReturn[S]> { 
    // ... 
}