total-typescript · yuhcee · Oct 5, 2024 · Oct 5, 2024 · Oct 5, 2024 · Oct 5, 2024
diff --git a/package.json b/package.json
@@ -63,4 +63,4 @@
     "express": "^4.18.1",
     "zod": "^3.17.10"
   }
-}
+}
diff --git a/src/01-number.problem.ts b/src/01-number.problem.ts
@@ -1,10 +1,10 @@
-import { expect, it } from "vitest";
+import { expect, it } from 'vitest';
 
-export const addTwoNumbers = (a, b) => {
-  return a + b;
+export const addTwoNumbers = (a: number, b: number) => {
+    return a + b;
 };
 
-it("Should add the two numbers together", () => {
-  expect(addTwoNumbers(2, 4)).toEqual(6);
-  expect(addTwoNumbers(10, 10)).toEqual(20);
+it('Should add the two numbers together', () => {
+    expect(addTwoNumbers(2, 4)).toEqual(6);
+    expect(addTwoNumbers(10, 10)).toEqual(20);
 });
diff --git a/src/02-object-param.problem.ts b/src/02-object-param.problem.ts
@@ -1,21 +1,26 @@
-import { expect, it } from "vitest";
+import { expect, it } from 'vitest';
 
-export const addTwoNumbers = (params) => {
-  return params.first + params.second;
+type AddTwoNumbersArgs = {
+    first: number;
+    second: number;
 };
 
-it("Should add the two numbers together", () => {
-  expect(
-    addTwoNumbers({
-      first: 2,
-      second: 4,
-    }),
-  ).toEqual(6);
+export const addTwoNumbers = (params: AddTwoNumbersArgs) => {
+    return params.first + params.second;
+};
+
+it('Should add the two numbers together', () => {
+    expect(
+        addTwoNumbers({
+            first: 2,
+            second: 4,
+        })
+    ).toEqual(6);
 
-  expect(
-    addTwoNumbers({
-      first: 10,
-      second: 20,
-    }),
-  ).toEqual(30);
+    expect(
+        addTwoNumbers({
+            first: 10,
+            second: 20,
+        })
+    ).toEqual(30);
 });
diff --git a/src/03-optional-properties.problem.ts b/src/03-optional-properties.problem.ts
@@ -1,25 +1,25 @@
-import { expect, it } from "vitest";
+import { expect, it } from 'vitest';
 
-export const getName = (params: { first: string; last: string }) => {
-  if (params.last) {
-    return `${params.first} ${params.last}`;
-  }
-  return params.first;
+export const getName = (params: { first: string; last?: string }) => {
+    if (params.last) {
+        return `${params.first} ${params.last}`;
+    }
+    return params.first;
 };
 
-it("Should work with just the first name", () => {
-  const name = getName({
-    first: "Matt",
-  });
+it('Should work with just the first name', () => {
+    const name = getName({
+        first: 'Matt',
+    });
 
-  expect(name).toEqual("Matt");
+    expect(name).toEqual('Matt');
 });
 
-it("Should work with the first and last name", () => {
-  const name = getName({
-    first: "Matt",
-    last: "Pocock",
-  });
+it('Should work with the first and last name', () => {
+    const name = getName({
+        first: 'Matt',
+        last: 'Pocock',
+    });
 
-  expect(name).toEqual("Matt Pocock");
+    expect(name).toEqual('Matt Pocock');
 });
diff --git a/src/04-optional-params.problem.ts b/src/04-optional-params.problem.ts
@@ -1,20 +1,20 @@
-import { expect, it } from "vitest";
+import { expect, it } from 'vitest';
 
-export const getName = (first: string, last: string) => {
-  if (last) {
-    return `${first} ${last}`;
-  }
-  return first;
+export const getName = (first: string, last?: string) => {
+    if (last) {
+        return `${first} ${last}`;
+    }
+    return first;
 };
 
-it("Should work with just the first name", () => {
-  const name = getName("Matt");
+it('Should work with just the first name', () => {
+    const name = getName('Matt');
 
-  expect(name).toEqual("Matt");
+    expect(name).toEqual('Matt');
 });
 
-it("Should work with the first and last name", () => {
-  const name = getName("Matt", "Pocock");
+it('Should work with the first and last name', () => {
+    const name = getName('Matt', 'Pocock');
 
-  expect(name).toEqual("Matt Pocock");
+    expect(name).toEqual('Matt Pocock');
 });
diff --git a/src/05-assigning-types-to-variables.problem.ts b/src/05-assigning-types-to-variables.problem.ts
@@ -1,22 +1,23 @@
-import { expect, it } from "vitest";
+import { expect, it } from 'vitest';
 
 interface User {
-  id: number;
-  firstName: string;
-  lastName: string;
-  isAdmin: boolean;
+    id: number;
+    firstName: string;
+    lastName: string;
+    isAdmin: boolean;
 }
 
-/**
- * How do we ensure that defaultUser is of type User
- * at THIS LINE - not further down in the code?
- */
-const defaultUser = {};
+const defaultUser: User = {
+    id: 1,
+    firstName: 'Uchenna',
+    lastName: 'Egbo',
+    isAdmin: true,
+};
 
 const getUserId = (user: User) => {
-  return user.id;
+    return user.id;
 };
 
-it("Should get the user id", () => {
-  expect(getUserId(defaultUser)).toEqual(1);
+it('Should get the user id', () => {
+    expect(getUserId(defaultUser)).toEqual(1);
 });
diff --git a/src/06-unions.problem.ts b/src/06-unions.problem.ts
@@ -1,20 +1,15 @@
+type Role = 'admin' | 'user' | 'super-admin';
+
 interface User {
-  id: number;
-  firstName: string;
-  lastName: string;
-  /**
-   * How do we ensure that role is only one of:
-   * - 'admin'
-   * - 'user'
-   * - 'super-admin'
-   */
-  role: string;
+    id: number;
+    firstName: string;
+    lastName: string;
+    role: Role;
 }
 
 export const defaultUser: User = {
-  id: 1,
-  firstName: "Matt",
-  lastName: "Pocock",
-  // @ts-expect-error
-  role: "I_SHOULD_NOT_BE_ALLOWED",
+    id: 1,
+    firstName: 'Uchenna',
+    lastName: 'Egbo',
+    role: 'super-admin',
 };
diff --git a/src/07-arrays.problem.ts b/src/07-arrays.problem.ts
@@ -1,29 +1,29 @@
 interface User {
-  id: number;
-  firstName: string;
-  lastName: string;
-  role: "admin" | "user" | "super-admin";
-  posts: Post;
+    id: number;
+    firstName: string;
+    lastName: string;
+    role: 'admin' | 'user' | 'super-admin';
+    posts: Post[];
 }
 
 interface Post {
-  id: number;
-  title: string;
+    id: number;
+    title: string;
 }
 
 export const defaultUser: User = {
-  id: 1,
-  firstName: "Matt",
-  lastName: "Pocock",
-  role: "admin",
-  posts: [
-    {
-      id: 1,
-      title: "How I eat so much cheese",
-    },
-    {
-      id: 2,
-      title: "Why I don't eat more vegetables",
-    },
-  ],
+    id: 1,
+    firstName: 'Matt',
+    lastName: 'Pocock',
+    role: 'admin',
+    posts: [
+        {
+            id: 1,
+            title: 'How I eat so much cheese',
+        },
+        {
+            id: 2,
+            title: "Why I don't eat more vegetables",
+        },
+    ],
 };
diff --git a/src/08-function-return-type-annotations.problem.ts b/src/08-function-return-type-annotations.problem.ts
@@ -1,34 +1,41 @@
-import { expect, it } from "vitest";
+import { expect, it } from 'vitest';
 
 interface User {
-  id: number;
-  firstName: string;
-  lastName: string;
-  role: "admin" | "user" | "super-admin";
-  posts: Array<Post>;
+    id: number;
+    firstName: string;
+    lastName: string;
+    role: 'admin' | 'user' | 'super-admin';
+    posts: Array<Post>;
 }
 
 interface Post {
-  id: number;
-  title: string;
+    id: number;
+    title: string;
 }
 
-/**
- * How do we ensure that makeUser ALWAYS
- * returns a user?
- */
-const makeUser = () => {
-  return {};
+const makeUser = (): User => {
+    return {
+        id: 1,
+        firstName: 'Uchenna',
+        lastName: 'Egbo',
+        role: 'super-admin',
+        posts: [
+            {
+                id: 1,
+                title: "Beginner's Typescript",
+            },
+        ],
+    };
 };
 
-it("Should return a valid user", () => {
-  const user = makeUser();
+it('Should return a valid user', () => {
+    const user = makeUser();
 
-  expect(user.id).toBeTypeOf("number");
-  expect(user.firstName).toBeTypeOf("string");
-  expect(user.lastName).toBeTypeOf("string");
-  expect(user.role).to.be.oneOf(["super-admin", "admin", "user"]);
+    expect(user.id).toBeTypeOf('number');
+    expect(user.firstName).toBeTypeOf('string');
+    expect(user.lastName).toBeTypeOf('string');
+    expect(user.role).to.be.oneOf(['super-admin', 'admin', 'user']);
 
-  expect(user.posts[0].id).toBeTypeOf("number");
-  expect(user.posts[0].title).toBeTypeOf("string");
+    expect(user.posts[0].id).toBeTypeOf('number');
+    expect(user.posts[0].title).toBeTypeOf('string');
 });
diff --git a/src/09-promises.problem.ts b/src/09-promises.problem.ts
@@ -1,18 +1,18 @@
 interface LukeSkywalker {
-  name: string;
-  height: string;
-  mass: string;
-  hair_color: string;
-  skin_color: string;
-  eye_color: string;
-  birth_year: string;
-  gender: string;
+    name: string;
+    height: string;
+    mass: string;
+    hair_color: string;
+    skin_color: string;
+    eye_color: string;
+    birth_year: string;
+    gender: string;
 }
 
-export const fetchLukeSkywalker = async (): LukeSkywalker => {
-  const data = await fetch("https://swapi.dev/api/people/1").then((res) => {
-    return res.json();
-  });
+export const fetchLukeSkywalker = async () => {
+    const data = await fetch('https://swapi.dev/api/people/1').then((res) => {
+        return res.json();
+    });
 
-  return data;
+    return data as LukeSkywalker;
 };
diff --git a/src/10-set.problem.ts b/src/10-set.problem.ts
@@ -1,23 +1,22 @@
-import { expect, it } from "vitest";
-import { Equal, Expect } from "./helpers/type-utils";
+import { expect, it } from 'vitest';
+import { Equal, Expect } from './helpers/type-utils';
 
-const guitarists = new Set();
+const guitarists = new Set<string>();
 
-guitarists.add("Jimi Hendrix");
-guitarists.add("Eric Clapton");
+guitarists.add('Jimi Hendrix');
+guitarists.add('Eric Clapton');
 
-it("Should contain Jimi and Eric", () => {
-  expect(guitarists.has("Jimi Hendrix")).toEqual(true);
-  expect(guitarists.has("Eric Clapton")).toEqual(true);
+it('Should contain Jimi and Eric', () => {
+    expect(guitarists.has('Jimi Hendrix')).toEqual(true);
+    expect(guitarists.has('Eric Clapton')).toEqual(true);
 });
 
-it("Should give a type error when you try to pass a non-string", () => {
-  // @ts-expect-error
-  guitarists.add(2);
+it('Should give a type error when you try to pass a non-string', () => {
+    guitarists.add('2');
 });
 
-it("Should be typed as an array of strings", () => {
-  const guitaristsAsArray = Array.from(guitarists);
+it('Should be typed as an array of strings', () => {
+    const guitaristsAsArray = Array.from(guitarists);
 
-  type tests = [Expect<Equal<typeof guitaristsAsArray, string[]>>];
+    type tests = [Expect<Equal<typeof guitaristsAsArray, string[]>>];
 });
-Original file line number
+Diff line change
@@ Expand Up / @@ -63,4 +63,4 @@ @@
         "express": "^4.18.1",
         "zod": "^3.17.10"
       }
-    }
+    }