chore: cleanup (#27)

* implement password score UI and functions

* update strings tests to use `test`instead of `it`

* update typing

* refactor login/register UI+Logic

* fix width on switches to properly display

* fetch and store self in store

* (WIP) unify card styles

* update labels page

* bump nuxt

* use form area

* use text area for description

* unify confirm API

* unify UI around pages

* change header background height

frontend/lib/api/user.ts

@@ -2,19 +2,13 @@ import { BaseAPI, route } from "./base";
 import { ItemsApi } from "./classes/items";
 import { LabelsApi } from "./classes/labels";
 import { LocationsApi } from "./classes/locations";
+import { UserOut } from "./types/data-contracts";
 import { Requests } from "~~/lib/requests";
 
 export type Result<T> = {
   item: T;
 };
 
-export type User = {
-  name: string;
-  email: string;
-  isSuperuser: boolean;
-  id: number;
-};
-
 export class UserApi extends BaseAPI {
   locations: LocationsApi;
   labels: LabelsApi;
@@ -30,7 +24,7 @@ export class UserApi extends BaseAPI {
   }
 
   public self() {
-    return this.http.get<Result<User>>({ url: route("/users/self") });
+    return this.http.get<Result<UserOut>>({ url: route("/users/self") });
   }
 
   public logout() {

frontend/lib/passwords/index.test.ts

@@ -0,0 +1,30 @@
+import { describe, test, expect } from "vitest";
+import { scorePassword } from ".";
+
+describe("scorePassword tests", () => {
+  test("flagged words should return negative number", () => {
+    const flaggedWords = ["password", "homebox", "admin", "qwerty", "login"];
+
+    for (const word of flaggedWords) {
+      expect(scorePassword(word)).toBe(0);
+    }
+  });
+
+  test("should return 0 for empty string", () => {
+    expect(scorePassword("")).toBe(0);
+  });
+
+  test("should return 0 for strings less than 6", () => {
+    expect(scorePassword("12345")).toBe(0);
+  });
+
+  test("should return positive number for long string", () => {
+    const result = expect(scorePassword("123456"));
+    result.toBeGreaterThan(0);
+    result.toBeLessThan(31);
+  });
+
+  test("should return max number for long string with all variations", () => {
+    expect(scorePassword("3bYWcfYOwqxljqeOmQXTLlBwkrH6HV")).toBe(100);
+  });
+});

frontend/lib/passwords/index.ts

@@ -0,0 +1,45 @@
+const flaggedWords = ["password", "homebox", "admin", "qwerty", "login"];
+
+/**
+ * scorePassword returns a score for a given password between 0 and 100.
+ * if a password contains a flagged word, it returns 0.
+ * @param pass
+ * @returns
+ */
+export function scorePassword(pass: string): number {
+  let score = 0;
+  if (!pass) return score;
+
+  if (pass.length < 6) return score;
+
+  // Check for flagged words
+  for (const word of flaggedWords) {
+    if (pass.toLowerCase().includes(word)) {
+      return 0;
+    }
+  }
+
+  // award every unique letter until 5 repetitions
+  const letters: { [key: string]: number } = {};
+
+  for (let i = 0; i < pass.length; i++) {
+    letters[pass[i]] = (letters[pass[i]] || 0) + 1;
+    score += 5.0 / letters[pass[i]];
+  }
+
+  // bonus points for mixing it up
+  const variations: { [key: string]: boolean } = {
+    digits: /\d/.test(pass),
+    lower: /[a-z]/.test(pass),
+    upper: /[A-Z]/.test(pass),
+    nonWords: /\W/.test(pass),
+  };
+
+  let variationCount = 0;
+  for (const check in variations) {
+    variationCount += variations[check] === true ? 1 : 0;
+  }
+  score += (variationCount - 1) * 10;
+
+  return Math.max(Math.min(score, 100), 0);
+}

frontend/lib/strings/index.test.ts

@@ -1,56 +1,56 @@
-import { describe, it, expect } from "vitest";
+import { describe, test, expect } from "vitest";
 import { titlecase, capitalize, truncate } from ".";
 
 describe("title case tests", () => {
-  it("should return the same string if it's already title case", () => {
+  test("should return the same string if it's already title case", () => {
     expect(titlecase("Hello World")).toBe("Hello World");
   });
 
-  it("should title case a lower case word", () => {
+  test("should title case a lower case word", () => {
     expect(titlecase("hello")).toBe("Hello");
   });
 
-  it("should title case a sentence", () => {
+  test("should title case a sentence", () => {
     expect(titlecase("hello world")).toBe("Hello World");
   });
 
-  it("should title case a sentence with multiple words", () => {
+  test("should title case a sentence with multiple words", () => {
     expect(titlecase("hello world this is a test")).toBe("Hello World This Is A Test");
   });
 });
 
 describe("capitilize tests", () => {
-  it("should return the same string if it's already capitalized", () => {
+  test("should return the same string if it's already capitalized", () => {
     expect(capitalize("Hello")).toBe("Hello");
   });
 
-  it("should capitalize a lower case word", () => {
+  test("should capitalize a lower case word", () => {
     expect(capitalize("hello")).toBe("Hello");
   });
 
-  it("should capitalize a sentence", () => {
+  test("should capitalize a sentence", () => {
     expect(capitalize("hello world")).toBe("Hello world");
   });
 
-  it("should capitalize a sentence with multiple words", () => {
+  test("should capitalize a sentence with multiple words", () => {
     expect(capitalize("hello world this is a test")).toBe("Hello world this is a test");
   });
 });
 
 describe("truncase tests", () => {
-  it("should return the same string if it's already truncated", () => {
+  test("should return the same string if it's already truncated", () => {
     expect(truncate("Hello", 5)).toBe("Hello");
   });
 
-  it("should truncate a lower case word", () => {
+  test("should truncate a lower case word", () => {
     expect(truncate("hello", 3)).toBe("hel...");
   });
 
-  it("should truncate a sentence", () => {
+  test("should truncate a sentence", () => {
     expect(truncate("hello world", 5)).toBe("hello...");
   });
 
-  it("should truncate a sentence with multiple words", () => {
+  test("should truncate a sentence with multiple words", () => {
     expect(truncate("hello world this is a test", 10)).toBe("hello worl...");
   });
 });