Add CV context, URL state sync, and filter utilities

CVContext provides global state (mode, hiddenTags) via React Context
and useReducer. URL state encodes to query params (?verbose=true) for
shareable links. filterData provides pure functions for tag filtering
and short/long content resolution.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: mrtysn

Mert_Yasin_CV.pdf

@@ -0,0 +1,63 @@
+import React, { createContext, useContext, useReducer, useEffect } from "react";
+import { MODES, ACTIONS } from "../constants/tags";
+import { decodeStateFromURL, encodeStateToURL } from "../utils/urlState";
+
+const initialState = {
+  mode: MODES.SHORT,
+  hiddenTags: [],
+  preset: null,
+};
+
+function cvReducer(state, action) {
+  switch (action.type) {
+    case ACTIONS.SET_MODE:
+      return { ...state, mode: action.payload, preset: null };
+
+    case ACTIONS.TOGGLE_TAG: {
+      const isHidden = state.hiddenTags.includes(action.payload);
+      return {
+        ...state,
+        hiddenTags: isHidden
+          ? state.hiddenTags.filter((t) => t !== action.payload)
+          : [...state.hiddenTags, action.payload],
+        preset: null,
+      };
+    }
+
+    case ACTIONS.APPLY_PRESET:
+      return {
+        mode: action.payload.mode,
+        hiddenTags: action.payload.hiddenTags,
+        preset: action.payload.name,
+      };
+
+    case ACTIONS.RESTORE_FROM_URL:
+      return { ...action.payload };
+
+    default:
+      return state;
+  }
+}
+
+const CVContext = createContext();
+
+export function CVProvider({ children }) {
+  const [state, dispatch] = useReducer(cvReducer, initialState, (init) => {
+    const urlState = decodeStateFromURL();
+    return urlState || init;
+  });
+
+  useEffect(() => {
+    encodeStateToURL(state);
+  }, [state]);
+
+  return (
+    <CVContext.Provider value={{ state, dispatch }}>
+      {children}
+    </CVContext.Provider>
+  );
+}
+
+export function useCVContext() {
+  return useContext(CVContext);
+}

src/context/CVContext.js

@@ -0,0 +1,60 @@
+import { MODES, TAGS } from "../constants/tags";
+
+/**
+ * Filter items by tags. An item is hidden only if ALL its tags are in hiddenTags.
+ * Items with no tags are always shown.
+ */
+export function filterByTags(items, hiddenTags) {
+  if (!hiddenTags || hiddenTags.length === 0) return items;
+
+  return items.filter((item) => {
+    if (!item.tags || item.tags.length === 0) return true;
+    return item.tags.some((tag) => !hiddenTags.includes(tag));
+  });
+}
+
+/**
+ * Resolve short/long content for an item.
+ * If mode is SHORT and item has a `short` object, merge short fields over the original.
+ * A field set to null in `short` means remove that field entirely.
+ */
+export function resolveItem(item, mode) {
+  if (mode !== MODES.SHORT || !item.short) return item;
+
+  const resolved = { ...item };
+  for (const [key, value] of Object.entries(item.short)) {
+    if (value === null) {
+      delete resolved[key];
+    } else {
+      resolved[key] = value;
+    }
+  }
+  delete resolved.short;
+  return resolved;
+}
+
+/**
+ * Combined: filter by tags, then resolve short/long for remaining items.
+ */
+export function processData(items, state) {
+  const filtered = filterByTags(items, state.hiddenTags);
+  return filtered.map((item) => resolveItem(item, state.mode));
+}
+
+/**
+ * Education-specific processing. Same as processData but also strips
+ * relevantCourses when the "coursework" tag is hidden.
+ */
+export function processEducationData(items, state) {
+  const filtered = filterByTags(items, state.hiddenTags);
+  const hideCoursework = state.hiddenTags.includes(TAGS.COURSEWORK);
+
+  return filtered.map((item) => {
+    const resolved = resolveItem(item, state.mode);
+    if (hideCoursework) {
+      const { relevantCourses, ...rest } = resolved;
+      return rest;
+    }
+    return resolved;
+  });
+}

src/utils/filterData.js

@@ -0,0 +1,36 @@
+import { MODES } from "../constants/tags";
+
+export function encodeStateToURL(state) {
+  const params = new URLSearchParams();
+
+  if (state.mode === MODES.LONG) {
+    params.set("verbose", "true");
+  }
+  if (state.hiddenTags.length > 0) {
+    params.set("hide", state.hiddenTags.join(","));
+  }
+  if (state.preset) {
+    params.set("preset", state.preset);
+  }
+
+  const query = params.toString();
+  const newURL = query
+    ? `${window.location.pathname}?${query}`
+    : window.location.pathname;
+  window.history.replaceState(null, "", newURL);
+}
+
+export function decodeStateFromURL() {
+  const params = new URLSearchParams(window.location.search);
+
+  if (!params.has("verbose") && !params.has("hide") && !params.has("preset")) {
+    return null;
+  }
+
+  const mode = params.get("verbose") === "true" ? MODES.LONG : MODES.SHORT;
+  const hide = params.get("hide");
+  const hiddenTags = hide ? hide.split(",").filter(Boolean) : [];
+  const preset = params.get("preset") || null;
+
+  return { mode, hiddenTags, preset };
+}