chore(changesets): bump package version (#5)

chore: bump package version

Co-authored-by: Luke Morales <[email protected]>

CHANGELOG.md

@@ -1,5 +1,71 @@
 # exhaustive
 
+## 1.0.0
+
+### Major Changes
+
+- [#4](https://github.com/lukemorales/exhaustive/pull/4) [`b287bbb`](https://github.com/lukemorales/exhaustive/commit/b287bbbb0fcb7a5f433bff2ff4124d5ae995a8ed) Thanks [@lukemorales](https://github.com/lukemorales)! - ## Exposed `Exhaustive` types and added new generic slot in core function for type of output
+
+  The types `ExhaustiveUnion` and `Exhaustiveag` are now exposed for your own convenience if you'd like to override the generic slots of `exhaustive`. The inferred output was also added as a new slot in the function generics, allowing you to also override the output value of `exhaustive`:
+
+  ```tsx
+  import { exhaustive, type ExhaustiveTag } from "exhaustive";
+
+  exhaustive<
+    RequestState,
+    "state",
+    ExhaustiveTag<RequestState, "state">,
+    JSX.Element
+  >(request, "state", {
+    IDLE: () => null,
+    LOADING: (value) => <Loading />,
+    SUCCESS: (value) => <List data={value.data} />,
+    ERROR: (value) => <Error message={value.error} />,
+  });
+  ```
+
+  ### BREAKING CHANGES
+
+  #### Renamed `_tag` method to `tag`
+
+  The `_tag` method was exposed as a some sort of secondary method to enhance the experience with Tagged Unions. Since the DX of using it is vastly superior compared to the Tagged Union overload in `exhaustive`, and it seems that we cannot improve the overload inference on the core funcion, the underscore has been removed from the method name and now you should used it as `exhaustive.tag` to make it official as the preferred way to exhaustive check Tagged Unions:
+
+  ```diff
+  const area = (s: Shape) => {
+  - return exhaustive._tag(s, 'kind', {
+  + return exhaustive.tag(s, 'kind', {
+      square: (shape) => shape.size ** 2,
+      rectangle: (shape) => shape.width * shape.height,
+      circle: (shape) => Math.PI * shape.radius ** 2,
+    });
+  };
+  ```
+
+### Minor Changes
+
+- [#4](https://github.com/lukemorales/exhaustive/pull/4) [`b287bbb`](https://github.com/lukemorales/exhaustive/commit/b287bbbb0fcb7a5f433bff2ff4124d5ae995a8ed) Thanks [@lukemorales](https://github.com/lukemorales)! - ## Add `exhaustive.tag` overload to core function
+
+  The same functionality of `exhaustive.tag` is available in the main function by adding a third argument to `exhaustive` that will trigger the Tagged Union overload.
+
+  ```ts
+  const area = (s: Shape) => {
+    return exhaustive(s, "kind", {
+      square: (shape) => shape.size ** 2,
+      rectangle: (shape) => shape.width * shape.height,
+      circle: (shape) => Math.PI * shape.radius ** 2,
+    });
+  };
+  ```
+
+  PS: Note that TypeScript has a limitation inferring the Tagged Union overload via argument types because they are generic values. Typescript will only fallback to the Tagged Union overload when you add a third argument. This means autocomplete for the Tagged Union keys will not exist until you declare an empty object as the third argument:
+
+  ```ts
+  exhaustive(shape, "kind", {});
+  //                        ^ this will trigger the Tagged Union overload
+  ```
+
+  This feature is being added as a reflect of how the API was originally intended. Use it at your own convenience, but if you prefer the better DX of inferred types from the start, calling `exhaustive.tag` is still preferrable.
+
 ## 0.1.0
 
 ### Minor Changes

package.json

@@ -1,6 +1,6 @@
 {
   "name": "exhaustive",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Exhaustiveness checking in TypeScript",
   "author": "Luke Morales <[email protected]>",
   "license": "MIT",