This commit is contained in:
Julien Froidefond
2025-08-20 15:43:24 +02:00
commit 09d2c5cbe1
100 changed files with 12494 additions and 0 deletions

176
hooks/use-evaluation.ts Normal file
View File

@@ -0,0 +1,176 @@
"use client";
import { useState, useEffect } from "react";
import {
UserEvaluation,
SkillCategory,
Team,
CategoryEvaluation,
UserProfile,
SkillLevel,
} from "@/lib/types";
import {
loadUserEvaluation,
saveUserEvaluation,
createEmptyEvaluation,
} from "@/lib/evaluation-utils";
import { loadSkillCategories, loadTeams } from "@/lib/data-loader";
export function useEvaluation() {
const [userEvaluation, setUserEvaluation] = useState<UserEvaluation | null>(
null
);
const [skillCategories, setSkillCategories] = useState<SkillCategory[]>([]);
const [teams, setTeams] = useState<Team[]>([]);
const [loading, setLoading] = useState(true);
// Load initial data
useEffect(() => {
async function initializeData() {
try {
const [categories, teamsData] = await Promise.all([
loadSkillCategories(),
loadTeams(),
]);
setSkillCategories(categories);
setTeams(teamsData);
// Try to load existing evaluation
const saved = loadUserEvaluation();
if (saved) {
setUserEvaluation(saved);
}
} catch (error) {
console.error("Failed to initialize data:", error);
} finally {
setLoading(false);
}
}
initializeData();
}, []);
const updateProfile = (profile: UserProfile) => {
const evaluations =
userEvaluation?.evaluations || createEmptyEvaluation(skillCategories);
const newEvaluation: UserEvaluation = {
profile,
evaluations,
lastUpdated: new Date().toISOString(),
};
setUserEvaluation(newEvaluation);
saveUserEvaluation(newEvaluation);
};
const updateSkillLevel = (
category: string,
skillId: string,
level: SkillLevel
) => {
if (!userEvaluation) return;
const updatedEvaluations = userEvaluation.evaluations.map((catEval) => {
if (catEval.category === category) {
const existingSkill = catEval.skills.find((s) => s.skillId === skillId);
const updatedSkills = existingSkill
? catEval.skills.map((skill) =>
skill.skillId === skillId ? { ...skill, level } : skill
)
: [...catEval.skills, { skillId, level }];
return {
...catEval,
skills: updatedSkills,
};
}
return catEval;
});
const newEvaluation: UserEvaluation = {
...userEvaluation,
evaluations: updatedEvaluations,
lastUpdated: new Date().toISOString(),
};
setUserEvaluation(newEvaluation);
saveUserEvaluation(newEvaluation);
};
const addSkillToEvaluation = (category: string, skillId: string) => {
if (!userEvaluation) return;
const updatedEvaluations = userEvaluation.evaluations.map((catEval) => {
if (catEval.category === category) {
if (!catEval.selectedSkillIds.includes(skillId)) {
return {
...catEval,
selectedSkillIds: [...catEval.selectedSkillIds, skillId],
skills: [...catEval.skills, { skillId, level: null }],
};
}
}
return catEval;
});
const newEvaluation: UserEvaluation = {
...userEvaluation,
evaluations: updatedEvaluations,
lastUpdated: new Date().toISOString(),
};
setUserEvaluation(newEvaluation);
saveUserEvaluation(newEvaluation);
};
const removeSkillFromEvaluation = (category: string, skillId: string) => {
if (!userEvaluation) return;
const updatedEvaluations = userEvaluation.evaluations.map((catEval) => {
if (catEval.category === category) {
return {
...catEval,
selectedSkillIds: catEval.selectedSkillIds.filter(
(id) => id !== skillId
),
skills: catEval.skills.filter((skill) => skill.skillId !== skillId),
};
}
return catEval;
});
const newEvaluation: UserEvaluation = {
...userEvaluation,
evaluations: updatedEvaluations,
lastUpdated: new Date().toISOString(),
};
setUserEvaluation(newEvaluation);
saveUserEvaluation(newEvaluation);
};
const initializeEmptyEvaluation = (profile: UserProfile) => {
const evaluations = createEmptyEvaluation(skillCategories);
const newEvaluation: UserEvaluation = {
profile,
evaluations,
lastUpdated: new Date().toISOString(),
};
setUserEvaluation(newEvaluation);
saveUserEvaluation(newEvaluation);
};
return {
userEvaluation,
skillCategories,
teams,
loading,
updateProfile,
updateSkillLevel,
addSkillToEvaluation,
removeSkillFromEvaluation,
initializeEmptyEvaluation,
};
}

19
hooks/use-mobile.ts Normal file
View File

@@ -0,0 +1,19 @@
import * as React from "react"
const MOBILE_BREAKPOINT = 768
export function useIsMobile() {
const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)
React.useEffect(() => {
const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
const onChange = () => {
setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
}
mql.addEventListener("change", onChange)
setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
return () => mql.removeEventListener("change", onChange)
}, [])
return !!isMobile
}

194
hooks/use-toast.ts Normal file
View File

@@ -0,0 +1,194 @@
"use client"
// Inspired by react-hot-toast library
import * as React from "react"
import type {
ToastActionElement,
ToastProps,
} from "@/components/ui/toast"
const TOAST_LIMIT = 1
const TOAST_REMOVE_DELAY = 1000000
type ToasterToast = ToastProps & {
id: string
title?: React.ReactNode
description?: React.ReactNode
action?: ToastActionElement
}
const actionTypes = {
ADD_TOAST: "ADD_TOAST",
UPDATE_TOAST: "UPDATE_TOAST",
DISMISS_TOAST: "DISMISS_TOAST",
REMOVE_TOAST: "REMOVE_TOAST",
} as const
let count = 0
function genId() {
count = (count + 1) % Number.MAX_SAFE_INTEGER
return count.toString()
}
type ActionType = typeof actionTypes
type Action =
| {
type: ActionType["ADD_TOAST"]
toast: ToasterToast
}
| {
type: ActionType["UPDATE_TOAST"]
toast: Partial<ToasterToast>
}
| {
type: ActionType["DISMISS_TOAST"]
toastId?: ToasterToast["id"]
}
| {
type: ActionType["REMOVE_TOAST"]
toastId?: ToasterToast["id"]
}
interface State {
toasts: ToasterToast[]
}
const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
const addToRemoveQueue = (toastId: string) => {
if (toastTimeouts.has(toastId)) {
return
}
const timeout = setTimeout(() => {
toastTimeouts.delete(toastId)
dispatch({
type: "REMOVE_TOAST",
toastId: toastId,
})
}, TOAST_REMOVE_DELAY)
toastTimeouts.set(toastId, timeout)
}
export const reducer = (state: State, action: Action): State => {
switch (action.type) {
case "ADD_TOAST":
return {
...state,
toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
}
case "UPDATE_TOAST":
return {
...state,
toasts: state.toasts.map((t) =>
t.id === action.toast.id ? { ...t, ...action.toast } : t
),
}
case "DISMISS_TOAST": {
const { toastId } = action
// ! Side effects ! - This could be extracted into a dismissToast() action,
// but I'll keep it here for simplicity
if (toastId) {
addToRemoveQueue(toastId)
} else {
state.toasts.forEach((toast) => {
addToRemoveQueue(toast.id)
})
}
return {
...state,
toasts: state.toasts.map((t) =>
t.id === toastId || toastId === undefined
? {
...t,
open: false,
}
: t
),
}
}
case "REMOVE_TOAST":
if (action.toastId === undefined) {
return {
...state,
toasts: [],
}
}
return {
...state,
toasts: state.toasts.filter((t) => t.id !== action.toastId),
}
}
}
const listeners: Array<(state: State) => void> = []
let memoryState: State = { toasts: [] }
function dispatch(action: Action) {
memoryState = reducer(memoryState, action)
listeners.forEach((listener) => {
listener(memoryState)
})
}
type Toast = Omit<ToasterToast, "id">
function toast({ ...props }: Toast) {
const id = genId()
const update = (props: ToasterToast) =>
dispatch({
type: "UPDATE_TOAST",
toast: { ...props, id },
})
const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })
dispatch({
type: "ADD_TOAST",
toast: {
...props,
id,
open: true,
onOpenChange: (open) => {
if (!open) dismiss()
},
},
})
return {
id: id,
dismiss,
update,
}
}
function useToast() {
const [state, setState] = React.useState<State>(memoryState)
React.useEffect(() => {
listeners.push(setState)
return () => {
const index = listeners.indexOf(setState)
if (index > -1) {
listeners.splice(index, 1)
}
}
}, [state])
return {
...state,
toast,
dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
}
}
export { useToast, toast }

View File

@@ -0,0 +1,34 @@
"use client";
import { createContext, useContext, useState, ReactNode } from "react";
interface UserInfo {
firstName: string;
lastName: string;
teamName: string;
}
interface UserContextType {
userInfo: UserInfo | null;
setUserInfo: (userInfo: UserInfo | null) => void;
}
const UserContext = createContext<UserContextType | undefined>(undefined);
export function UserProvider({ children }: { children: ReactNode }) {
const [userInfo, setUserInfo] = useState<UserInfo | null>(null);
return (
<UserContext.Provider value={{ userInfo, setUserInfo }}>
{children}
</UserContext.Provider>
);
}
export function useUser() {
const context = useContext(UserContext);
if (context === undefined) {
throw new Error("useUser must be used within a UserProvider");
}
return context;
}