fix(deps): update dependency ts-pattern to v5 #51

renovate · 2023-06-16T04:48:59Z

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
ts-pattern	`^4.1.4` -> `^5.0.0`

Release Notes

gvergnaud/ts-pattern (ts-pattern)

Bug fixes

The P module was mistakenly exposing some pattern methods that were intended to be namespaced by type. This release fixes this problem.

If you happened to use on of those following methods, here is where to find them now:

- P.between
+ P.number.between

- P.lt
+ P.number.lt

- P.gt
+ P.number.gt

- P.lte
+ P.number.lte

- P.gte
+ P.number.gte

- P.int
+ P.number.int

- P.finite
+ P.number.finite

- P.positive
+ P.number.positive

- P.negative
+ P.number.negative

- P.betweenBigInt
+ P.bigint.between

- P.ltBigInt
+ P.bigint.lt

- P.gtBigInt
+ P.bigint.gt

- P.lteBigInt
+ P.bigint.lte

- P.gteBigInt
+ P.bigint.gte

- P.positiveBigInt
+ P.bigint.positive

- P.negativeBigInt
+ P.bigint.negative

`v5.0.4`

Compare Source

What's Changed

🐛 fix: Accept branded primitive types as patterns by @gvergnaud in https://github.com/gvergnaud/ts-pattern/pull/180

Full Changelog: gvergnaud/ts-pattern@v5.0.3...v5.0.4

`v5.0.3`

Compare Source

What's Changed

🐛 fix: Allow re-exporting patterns from ES Modules by @gvergnaud in https://github.com/gvergnaud/ts-pattern/pull/175

Full Changelog: gvergnaud/ts-pattern@v5.0.2...v5.0.3

`v5.0.2`

Compare Source

What's Changed

fix(P.infer): Fix inference of arrays containing tuples in gvergnaud/ts-pattern@c52af6a
refactoring: simplify selection types in gvergnaud/ts-pattern@1b7a36b
perf: runtime perf improvement in .with in gvergnaud/ts-pattern@9b27384
fix: use Symbol.for to make sure two concurrent versions of ts-pattern are compatible with one-another in gvergnaud/ts-pattern@d6d2e23
docs: fix typo by @juicyjusung in https://github.com/gvergnaud/ts-pattern/pull/170

New Contributors

@juicyjusung made their first contribution in https://github.com/gvergnaud/ts-pattern/pull/170

Full Changelog: gvergnaud/ts-pattern@v5.0.0...v5.0.2

`v5.0.1`

Compare Source

`v5.0.0`: ❤️

Compare Source

TS-Pattern v5 is finally out ❤️

Breaking changes

`.with` is now evaluated eagerly

In the previous version of TS-Pattern, no code would execute until you called .exhaustive() or .otherwise(...). For example, in the following code block, nothing would be logged to the console or thrown:

// TS-Pattern v4
type Input = { type: 'ok'; value: number } | { type: 'error'; error: Error };

// We don't call `.exhaustive`, so handlers don't run.
function someFunction(input: Input) {
  match(input)
    .with({ type: 'ok' }, ({ value }) => {
      console.log(value);
    })
    .with({ type: 'error' }, ({ error }) => {
      throw error;
    });
}

someFunction({ type: 'ok', value: 42 }); // nothing happens

In TS-Pattern v5, however, the library will execute the matching handler as soon as it finds it:

// TS-Pattern v5
someFunction({ type: 'ok', value: 42 }); // logs "42" to the console!

Handlers are now evaluated eagerly instead of lazily. In practice, this shouldn't change anything as long as you always finish your pattern matching expressions by either .exhaustive or .otherwise.

Matching on Maps and Sets

Matching Set and Map instances using .with(new Set(...)) and .with(new Map(...)) is no longer supported. If you want to match specific sets and maps, you should now use the P.map(keyPattern, valuePattern) and P.set(valuePattern) patterns:

- import { match } from 'ts-pattern';
+ import { match, P } from 'ts-pattern';

const someFunction = (value: Set<number> | Map<string, number>) =>
  match(value)
-   .with(new Set([P.number]), (set) => `a set of numbers`)
-   .with(new Map([['key', P.number]]), (map) => `map.get('key') is a number`)
+   .with(P.set(P.number), (set) => `a set of numbers`)
+   .with(P.map('key', P.number), (map) => `map.get('key') is a number`)
    .otherwise(() => null);

The subpattern we provide in P.set(subpattern) should match all values in the set.
The value subpattern we provide in P.map(keyPattern, subpattern) should only match the values matching keyPattern for the whole P.map(..) pattern to match the input.

New features

chainable methods

TS-Pattern v5's major addition is the ability to chain methods to narrow down the values matched by primitive patterns, like P.string or P.number.

Since a few examples is worth a thousand words, here are a few ways you can use chainable methods:

P.number methods

const example = (position: { x: number; y: number }) =>
  match(position)
    .with({ x: P.number.gte(100) }, (value) => '🎮')
    .with({ x: P.number.between(0, 100) }, (value) => '🎮')
    .with(
      {
        x: P.number.positive().int(),
        y: P.number.positive().int(),
      },
      (value) => '🎮'
    )
    .otherwise(() => 'x or y is negative');

Here is the full list of number methods:

P.number.between(min, max): matches numbers between min and max.
P.number.lt(max): matches numbers smaller than max.
P.number.gt(min): matches numbers greater than min.
P.number.lte(max): matches numbers smaller than or equal to max.
P.number.gte(min): matches numbers greater than or equal to min.
P.number.int(): matches integers.
P.number.finite(): matches all numbers except Infinity and -Infinity
P.number.positive(): matches positive numbers.
P.number.negative(): matches negative numbers.

P.string methods

const example = (query: string) =>
  match(query)
    .with(P.string.startsWith('SELECT'), (query) => `selection`)
    .with(P.string.endsWith('FROM user'), (query) => `👯‍♂️`)
    .with(P.string.includes('*'), () => 'contains a star')
    // Methods can be chained:
    .with(P.string.startsWith('SET').includes('*'), (query) => `🤯`)
    .exhaustive();

Here is the full list of string methods:

P.string.startsWith(str): matches strings that start with str.
P.string.endsWith(str): matches strings that end with str.
P.string.minLength(min): matches strings with at least min characters.
P.string.maxLength(max): matches strings with at most max characters.
P.string.includes(str): matches strings that contain str.
P.string.regex(RegExp): matches strings if they match this regular expression.

Global methods

Some methods are available for all primitive type patterns:

P.{..}.optional(): matches even if this property isn't present on the input object.
P.{..}.select(): injects the matched value into the handler function.
P.{..}.and(pattern): matches if the current pattern and the provided pattern match.
P.{..}.or(pattern): matches if either the current pattern or the provided pattern match.

const example = (value: unknown) =>
  match(value)
    .with(
      {
        username: P.string,
        displayName: P.string.optional(),
      },
      () => `{ username:string, displayName?: string }`
    )
    .with(
      {
        title: P.string,
        author: { username: P.string.select() },
      },
      (username) => `author.username is ${username}`
    )
    .with(
      P.instanceOf(Error).and({ source: P.string }),
      () => `Error & { source: string }`
    )
    .with(P.string.or(P.number), () => `string | number`)
    .otherwise(() => null);

Variadic tuple patterns

With TS-Pattern, you are now able to create array (or more accurately tuple) pattern with a variable number of elements:

const example = (value: unknown) =>
  match(value)
    .with(
      // non-empty list of strings
      [P.string, ...P.array(P.string)],
      (value) => `value: [string, ...string[]]`
    )
    .otherwise(() => null);

Array patterns that include a ...P.array are called variadic tuple patterns. You may only have a single ...P.array, but as many fixed-index patterns as you want:

const example = (value: unknown) =>
  match(value)
    .with(
      [P.string, P.string, P.string, ...P.array(P.string)],
      (value) => `value: [string, string, string, ...string[]]`
    )
    .with(
      [P.string, P.string, ...P.array(P.string)],
      (value) => `value: [string, string, ...string[]]`
    )
    .with([], (value) => `value: []`)
    .otherwise(() => null);

Fixed-index patterns can also be set after the ...P.array variadic, or on both sides!

const example = (value: unknown) =>
  match(value)
    .with(
      [...P.array(P.number), P.string, P.number],
      (value) => `value: [...number[], string, number]`
    )
    .with(
      [P.boolean, ...P.array(P.string), P.number, P.symbol],
      (value) => `value: [boolean, ...string[], number, symbol]`
    )
    .otherwise(() => null);

Lastly, argument of P.array is now optional, and will default to P._, which matches anything:

const example = (value: unknown) =>
  match(value)
    //                         👇
    .with([P.string, ...P.array()], (value) => `value: [string, ...unknown[]]`)
    .otherwise(() => null);

`.returnType`

In TS-Pattern v4, the only way to explicitly set the return type of your match expression is to set the two <Input, Output> type parameters of match:

// TS-Pattern v4
match<
  { isAdmin: boolean; plan: 'free' | 'paid' }, // input type
  number // return type
>({ isAdmin, plan })
  .with({ isAdmin: true }, () => 123)
  .with({ plan: 'free' }, () => 'Oops!');
//                              ~~~~~~ ❌ not a number.

the main drawback is that you need to set the input type explicitly too, even though TypeScript should be able to infer it.

In TS-Pattern v5, you can use the .returnType<Type>() method to only set the return type:

match({ isAdmin, plan })
  .returnType<number>() // 👈 new
  .with({ isAdmin: true }, () => 123)
  .with({ plan: 'free' }, () => 'Oops!');
//                              ~~~~~~ ❌ not a number.

What's Changed

TS-Pattern v5 base branch by @gvergnaud in https://github.com/gvergnaud/ts-pattern/pull/139

Full Changelog: gvergnaud/ts-pattern@v4.3.0...v5.0.0

`v4.3.0`

Compare Source

TS-Pattern and node16

TS-Pattern now fully supports moduleResolution: node16, with both ES and CommonJS modules. This resolves the long standing issue number #110. Special thanks to @Andarist and @frankie303 for helping me understand and fix this issue ❤️

What's Changed

build: better support moduleResolution: bundler by @gvergnaud in https://github.com/gvergnaud/ts-pattern/pull/158
Gvergnaud/fix build for nodenext and commonjs by @gvergnaud in https://github.com/gvergnaud/ts-pattern/pull/160

Full Changelog: gvergnaud/ts-pattern@v4.2.2...v4.3.0

`v4.2.3`

Compare Source

`v4.2.2`

Compare Source

Bug fixes:

Issue #142: Fixes a type inference bug when the input type only has optional properties. commit 3c36992

`v4.2.1`

Compare Source

Bug fixes

This release fixes inference of P.array when the input is a readonly array (issue #148)

declare const input: readonly {
  readonly title: string;
  readonly content: string;
}[];

const output = match(input)
  .with(
    P.array({ title: P.string, content: P.string }),
    //      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //              Used to error, now works 
    (posts) => 'a list of posts!'
  )
  .otherwise(() => 'something else');

`v4.2.0`

Compare Source

Features

Better inference for `match` and `.with`

match

When using match with an inline array, it will now infer its type as tuple automatically, even when not using as const. This means that exhaustiveness checking will also improve in this case:

function f(a: boolean, b: boolean) {
  // infered as `[boolean, boolean]`
  return (
    match([a, b])
      // we can pattern match on all cases
      .with([true, true], () => false)
      .with([false, true], () => true)
      .with([true, false], () => true)
      .with([false, false], () => false)
      // ✅ Failed in TS-pattern v4.1 but works in v4.2!
      .exhaustive()
  );
}

`.with(...)`

Thanks to the help of @Andarist, this release fixes a long-standing issue of .with.
Until now, patterns like P.array, P.union or P.when didn't have proper type inference when used in .with() directly. Here are a few behaviors that use to be incorrect and work now:

match<'a' | 'b'>('a')
  .with(P.union('this is wrong'), x => x)
  //            ~~~~~~~~~~~~~~~
  //            ❌ no longer type-check in v4.2
  .otherwise(x => x)

match<'a' | 'b'>('a')
  .with(P.array(123), x => x)
  //            ~~~
  //            ❌ no longer type-check in v4.2
  .otherwise(x => x)

match<'a' | 'b'>('a')
  .with(P.when((x) => true), x => x)
  //            👆
  //    used to be of type `unknown`, now `'a' | 'b'`
  .otherwise(x => x)

This also fixes the following issue: https://github.com/gvergnaud/ts-pattern/issues/140

Configuration

📅 Schedule: Branch creation - "after 1pm and before 5pm on Friday" in timezone Asia/Tokyo, Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

If you want to rebase/retry this PR, check this box

This PR has been generated by Mend Renovate. View repository job log here.

renovate bot added the dependencies label Jun 16, 2023

renovate bot force-pushed the renovate/ts-pattern-5.x branch from 0820db3 to 44717bd Compare January 14, 2024 02:43

renovate bot force-pushed the renovate/ts-pattern-5.x branch from 44717bd to e73f658 Compare March 3, 2024 08:19

fix(deps): update dependency ts-pattern to v5

4374c82

turtton force-pushed the renovate/ts-pattern-5.x branch from e73f658 to 4374c82 Compare March 3, 2024 09:15

turtton merged commit 454fb2d into main Mar 3, 2024
4 checks passed

turtton deleted the renovate/ts-pattern-5.x branch March 3, 2024 09:21

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

fix(deps): update dependency ts-pattern to v5 #51

fix(deps): update dependency ts-pattern to v5 #51

renovate bot commented Jun 16, 2023 •

edited

Loading

fix(deps): update dependency ts-pattern to v5 #51

fix(deps): update dependency ts-pattern to v5 #51

Conversation

renovate bot commented Jun 16, 2023 • edited Loading

Release Notes

Close issue issues

What's Changed

New Contributors

Bug fixes

What's Changed

What's Changed

What's Changed

New Contributors

v5.0.0: ❤️

TS-Pattern v5 is finally out ❤️

Breaking changes

.with is now evaluated eagerly

Matching on Maps and Sets

New features

chainable methods

P.number methods

P.string methods

Global methods

Variadic tuple patterns

.returnType

What's Changed

TS-Pattern and node16

What's Changed

Bug fixes:

Bug fixes

Features

Better inference for match and .with

match

.with(...)

Configuration

renovate bot commented Jun 16, 2023 •

edited

Loading

`v5.0.0`: ❤️

`.with` is now evaluated eagerly

`.returnType`

Better inference for `match` and `.with`

`.with(...)`