chore: add utility types

Author: bartstc

src/features/products/types/IProduct.ts

@@ -1,8 +1,12 @@
+import type { Branded } from "@/types/Branded";
+
 import { Category } from "./Category";
 import type { IRating } from "./IRating";
 
+export type ProductId = Branded<number, "ProductId">;
+
 export interface IProduct {
-  id: number;
+  id: ProductId;
   title: string;
   description: string;
   category: Category;

src/types/AllOrNothing.test.ts

@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import type { ReactNode } from "react";
+import { describe, it, expectTypeOf } from "vitest";
+
+import type { AllOrNothing } from "./AllOrNothing";
+
+type ChangeFn = () => void;
+
+type ControllableValue<TValue> = AllOrNothing<{
+  value: TValue;
+  onValueChange: ChangeFn;
+}>;
+
+type Props = ControllableValue<string> & { children: ReactNode };
+
+describe("AllOrNothing", () => {
+  it("matches the type when only required properties defined", () => {
+    expectTypeOf({
+      children: "child",
+    }).toMatchTypeOf<Props>();
+  });
+
+  it(`doesn't match the type when only value defined`, () => {
+    expectTypeOf({
+      children: "child",
+      value: "value",
+    }).not.toMatchTypeOf<Props>();
+  });
+
+  it(`doesn't match the type when only onValueChange defined`, () => {
+    expectTypeOf({
+      children: "child",
+      onValueChange: () => {},
+    }).not.toMatchTypeOf<Props>();
+  });
+
+  it("matches the type when all properties defined", () => {
+    expectTypeOf({
+      children: "child",
+      value: "value",
+      onValueChange: () => {},
+    }).toMatchTypeOf<Props>();
+  });
+});

src/types/AllOrNothing.ts

@@ -0,0 +1,8 @@
+export type AllOrNothing<T extends AnyObject> = T | ToUndefinedObject<T>;
+
+type ToUndefinedObject<T extends AnyObject> = Partial<
+  Record<keyof T, undefined>
+>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyObject = Record<string, any>;

src/types/Autocomplete.ts

@@ -0,0 +1 @@
+export type Autocomplete<T extends string> = T & (string & {});

src/types/Branded.ts

@@ -0,0 +1,6 @@
+declare const __brand: unique symbol;
+
+interface Brand<B> {
+  [__brand]: B;
+}
+export type Branded<T, B> = T & Brand<B>;

src/types/DeepPartial.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = {
+  [P in keyof T]?: DeepPartial<T[P]>;
+};

src/types/NonEmptyArray.ts

@@ -0,0 +1 @@
+export type NonEmptyArray<T> = [T, ...T[]];

src/types/NonNullableProps.ts

@@ -0,0 +1,3 @@
+export type NonNullableProps<T> = {
+  [P in keyof T]-?: NonNullable<T[P]>;
+};

src/types/OneOfUnion.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expectTypeOf } from "vitest";
+
+import type { OneOfUnion } from "./OneOfUnion";
+
+type MyUnion =
+  | { type: "a"; value: number }
+  | { type: "b"; value: string }
+  | { type: "c"; value: boolean };
+
+describe("OneOfUnion", () => {
+  it("extracts correct type", () => {
+    type ExtractedA = OneOfUnion<MyUnion, "a">;
+    type ExtractedB = OneOfUnion<MyUnion, "b">;
+    type ExtractedC = OneOfUnion<MyUnion, "c">;
+
+    expectTypeOf<ExtractedA>().toEqualTypeOf<{ type: "a"; value: number }>();
+    expectTypeOf<ExtractedB>().toEqualTypeOf<{ type: "b"; value: string }>();
+    expectTypeOf<ExtractedC>().toEqualTypeOf<{ type: "c"; value: boolean }>();
+  });
+});

src/types/OneOfUnion.ts

@@ -0,0 +1,4 @@
+export type OneOfUnion<
+  TUnion extends { type: string },
+  TType extends TUnion["type"],
+> = Extract<TUnion, { type: TType }>;