fix list

Author: hate

apps/web/src/app/App.styles.ts

@@ -6,10 +6,10 @@ export const appStyles = {
   main: "relative w-full max-w-5xl",
   glow: "pointer-events-none absolute inset-0 -z-10 rounded-[32px] bg-gradient-radial from-blue-500/5 via-transparent to-transparent blur-3xl",
   window:
-    `relative z-10 flex w-full min-h-0 flex-col overflow-hidden rounded-2xl ${uiTokens.glassSurface} shadow-[0_40px_120px_rgba(0,0,0,0.45)] will-change-transform`,
+    `relative z-10 flex w-full min-h-[600px] flex-col overflow-hidden rounded-2xl ${uiTokens.glassSurface} shadow-[0_40px_120px_rgba(0,0,0,0.45)] will-change-transform`,
   windowFullscreen:
     `fixed inset-0 z-30 m-0 flex h-screen w-screen min-h-0 flex-col overflow-hidden rounded-none shadow-none ${uiTokens.glassSurface} text-white`,
-  windowBody: "relative flex min-h-0 flex-1 flex-col",
+  windowBody: "relative flex flex-1 flex-col",
   editorColumn: "flex flex-1 min-h-0",
   editorInner: "flex-1 min-h-0",
   explorerPane: (open: boolean) =>

apps/web/src/content/packs/algorithms.json

@@ -9,40 +9,200 @@
       "language": "rust",
       "snippet": "fn binary_search(nums: &[i32], target: i32) -> Option<usize> {\n    let mut lo = 0;\n    let mut hi = nums.len();\n    while lo < hi {\n        let mid = (lo + hi) / 2;\n        if nums[mid] == target {\n            return Some(mid);\n        } else if nums[mid] < target {\n            lo = mid + 1;\n        } else {\n            hi = mid;\n        }\n    }\n    None\n}"
     },
+    {
+      "id": "factorial",
+      "language": "rust",
+      "snippet": "fn factorial(n: u64) -> u64 {\n    match n {\n        0 | 1 => 1,\n        _ => n * factorial(n - 1),\n    }\n}"
+    },
+    {
+      "id": "is_palindrome",
+      "language": "rust",
+      "snippet": "fn is_palindrome(s: &str) -> bool {\n    let cleaned: Vec<char> = s\n        .chars()\n        .filter(|c| c.is_alphanumeric())\n        .map(|c| c.to_ascii_lowercase())\n        .collect();\n    let mut left = 0;\n    let mut right = cleaned.len().saturating_sub(1);\n    while left < right {\n        if cleaned[left] != cleaned[right] {\n            return false;\n        }\n        left += 1;\n        right -= 1;\n    }\n    true\n}"
+    },
+    {
+      "id": "reverse_string",
+      "language": "rust",
+      "snippet": "fn reverse_string(s: &str) -> String {\n    s.chars().rev().collect()\n}"
+    },
+    {
+      "id": "find_max",
+      "language": "rust",
+      "snippet": "fn find_max(nums: &[i32]) -> Option<i32> {\n    nums.iter().max().copied()\n}"
+    },
+    {
+      "id": "fizzbuzz",
+      "language": "rust",
+      "snippet": "fn fizzbuzz(n: u32) -> Vec<String> {\n    (1..=n)\n        .map(|i| match (i % 3, i % 5) {\n            (0, 0) => \"FizzBuzz\".to_string(),\n            (0, _) => \"Fizz\".to_string(),\n            (_, 0) => \"Buzz\".to_string(),\n            _ => i.to_string(),\n        })\n        .collect()\n}"
+    },
+    {
+      "id": "gcd",
+      "language": "rust",
+      "snippet": "fn gcd(mut a: u64, mut b: u64) -> u64 {\n    while b != 0 {\n        let temp = b;\n        b = a % b;\n        a = temp;\n    }\n    a\n}"
+    },
+    {
+      "id": "is_prime",
+      "language": "rust",
+      "snippet": "fn is_prime(n: u64) -> bool {\n    if n < 2 {\n        return false;\n    }\n    for i in 2..=(n as f64).sqrt() as u64 {\n        if n % i == 0 {\n            return false;\n        }\n    }\n    true\n}"
+    },
+    {
+      "id": "count_vowels",
+      "language": "rust",
+      "snippet": "fn count_vowels(s: &str) -> usize {\n    s.chars()\n        .filter(|&c| matches!(c.to_ascii_lowercase(), 'a' | 'e' | 'i' | 'o' | 'u'))\n        .count()\n}"
+    },
+    {
+      "id": "sum_array",
+      "language": "rust",
+      "snippet": "fn sum_array(nums: &[i32]) -> i32 {\n    nums.iter().sum()\n}"
+    },
     {
       "id": "two_sum",
       "language": "typescript",
       "snippet": "export function twoSum(nums: number[], target: number): [number, number] | null {\n  const seen = new Map<number, number>();\n  for (let i = 0; i < nums.length; i += 1) {\n    const complement = target - nums[i];\n    const match = seen.get(complement);\n    if (match != null) {\n      return [match, i];\n    }\n    seen.set(nums[i], i);\n  }\n  return null;\n}"
     },
     {
-      "id": "merge_sort",
-      "language": "python",
-      "snippet": "def merge_sort(values: list[int]) -> list[int]:\n    if len(values) <= 1:\n        return values\n    mid = len(values) // 2\n    left = merge_sort(values[:mid])\n    right = merge_sort(values[mid:])\n    return merge(left, right)\n\n\ndef merge(left: list[int], right: list[int]) -> list[int]:\n    result: list[int] = []\n    i = j = 0\n    while i < len(left) and j < len(right):\n        if left[i] <= right[j]:\n            result.append(left[i])\n            i += 1\n        else:\n            result.append(right[j])\n            j += 1\n    result.extend(left[i:])\n    result.extend(right[j:])\n    return result"
+      "id": "fibonacci",
+      "language": "typescript",
+      "snippet": "export function fibonacci(n: number): number {\n  if (n <= 1) {\n    return n;\n  }\n  let a = 0;\n  let b = 1;\n  for (let i = 2; i <= n; i += 1) {\n    const temp = a + b;\n    a = b;\n    b = temp;\n  }\n  return b;\n}"
     },
     {
-      "id": "dijkstra",
-      "language": "go",
-      "snippet": "func Dijkstra(graph map[string]map[string]int, source string) map[string]int {\n    dist := make(map[string]int)\n    visited := make(map[string]bool)\n    for node := range graph {\n        dist[node] = math.MaxInt\n    }\n    dist[source] = 0\n    pq := &priorityQueue{}\n    heap.Init(pq)\n    heap.Push(pq, &item{node: source, cost: 0})\n\n    for pq.Len() > 0 {\n        current := heap.Pop(pq).(*item)\n        if visited[current.node] {\n            continue\n        }\n        visited[current.node] = true\n        for neighbor, weight := range graph[current.node] {\n            newDist := dist[current.node] + weight\n            if newDist < dist[neighbor] {\n                dist[neighbor] = newDist\n                heap.Push(pq, &item{node: neighbor, cost: newDist})\n            }\n        }\n    }\n    return dist\n}"
+      "id": "valid_parens",
+      "language": "typescript",
+      "snippet": "export function isValidParens(s: string): boolean {\n  const stack: string[] = [];\n  const pairs: Record<string, string> = { ')': '(', '}': '{', ']': '[' };\n  for (const char of s) {\n    if (char === '(' || char === '{' || char === '[') {\n      stack.push(char);\n    } else if (char in pairs) {\n      if (stack.pop() !== pairs[char]) {\n        return false;\n      }\n    }\n  }\n  return stack.length === 0;\n}"
     },
     {
-      "id": "factorial",
-      "language": "rust",
-      "snippet": "fn factorial(n: u64) -> u64 {\n    match n {\n        0 | 1 => 1,\n        _ => n * factorial(n - 1),\n    }\n}"
+      "id": "capitalize_words",
+      "language": "typescript",
+      "snippet": "export function capitalizeWords(s: string): string {\n  return s\n    .split(' ')\n    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())\n    .join(' ');\n}"
     },
     {
-      "id": "is_palindrome",
+      "id": "is_anagram",
       "language": "typescript",
-      "snippet": "export function isPalindrome(s: string): boolean {\n  const cleaned = s.toLowerCase().replace(/[^a-z0-9]/g, '');\n  let left = 0;\n  let right = cleaned.length - 1;\n  while (left < right) {\n    if (cleaned[left] !== cleaned[right]) {\n      return false;\n    }\n    left += 1;\n    right -= 1;\n  }\n  return true;\n}"
+      "snippet": "export function isAnagram(s1: string, s2: string): boolean {\n  if (s1.length !== s2.length) {\n    return false;\n  }\n  const sorted1 = s1.split('').sort().join('');\n  const sorted2 = s2.split('').sort().join('');\n  return sorted1 === sorted2;\n}"
     },
     {
-      "id": "fibonacci",
+      "id": "chunk_array",
+      "language": "typescript",
+      "snippet": "export function chunkArray<T>(arr: T[], size: number): T[][] {\n  const result: T[][] = [];\n  for (let i = 0; i < arr.length; i += size) {\n    result.push(arr.slice(i, i + size));\n  }\n  return result;\n}"
+    },
+    {
+      "id": "flatten_array",
+      "language": "typescript",
+      "snippet": "export function flattenArray<T>(arr: (T | T[])[]): T[] {\n  return arr.reduce<T[]>((acc, val) => {\n    return acc.concat(Array.isArray(val) ? flattenArray(val) : val);\n  }, []);\n}"
+    },
+    {
+      "id": "unique_elements",
+      "language": "typescript",
+      "snippet": "export function uniqueElements<T>(arr: T[]): T[] {\n  return Array.from(new Set(arr));\n}"
+    },
+    {
+      "id": "merge_arrays",
+      "language": "typescript",
+      "snippet": "export function mergeSortedArrays(arr1: number[], arr2: number[]): number[] {\n  const result: number[] = [];\n  let i = 0;\n  let j = 0;\n  while (i < arr1.length && j < arr2.length) {\n    if (arr1[i] <= arr2[j]) {\n      result.push(arr1[i]);\n      i += 1;\n    } else {\n      result.push(arr2[j]);\n      j += 1;\n    }\n  }\n  return result.concat(arr1.slice(i)).concat(arr2.slice(j));\n}"
+    },
+    {
+      "id": "range",
+      "language": "typescript",
+      "snippet": "export function range(start: number, end: number, step = 1): number[] {\n  const result: number[] = [];\n  for (let i = start; i < end; i += step) {\n    result.push(i);\n  }\n  return result;\n}"
+    },
+    {
+      "id": "quick_select",
       "language": "python",
-      "snippet": "def fibonacci(n: int) -> int:\n    if n <= 1:\n        return n\n    a, b = 0, 1\n    for _ in range(2, n + 1):\n        a, b = b, a + b\n    return b"
+      "snippet": "def quick_select(nums: list[int], k: int) -> int:\n    pivot = nums[len(nums) // 2]\n    left = [x for x in nums if x < pivot]\n    mid = [x for x in nums if x == pivot]\n    right = [x for x in nums if x > pivot]\n    if k < len(left):\n        return quick_select(left, k)\n    elif k < len(left) + len(mid):\n        return mid[0]\n    else:\n        return quick_select(right, k - len(left) - len(mid))"
     },
     {
-      "id": "valid_parens",
+      "id": "bubble_sort",
+      "language": "python",
+      "snippet": "def bubble_sort(nums: list[int]) -> list[int]:\n    n = len(nums)\n    for i in range(n):\n        for j in range(0, n - i - 1):\n            if nums[j] > nums[j + 1]:\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n    return nums"
+    },
+    {
+      "id": "longest_common_prefix",
+      "language": "python",
+      "snippet": "def longest_common_prefix(strs: list[str]) -> str:\n    if not strs:\n        return ''\n    prefix = strs[0]\n    for s in strs[1:]:\n        while not s.startswith(prefix):\n            prefix = prefix[:-1]\n            if not prefix:\n                return ''\n    return prefix"
+    },
+    {
+      "id": "remove_duplicates",
+      "language": "python",
+      "snippet": "def remove_duplicates(nums: list[int]) -> int:\n    if not nums:\n        return 0\n    i = 0\n    for j in range(1, len(nums)):\n        if nums[j] != nums[i]:\n            i += 1\n            nums[i] = nums[j]\n    return i + 1"
+    },
+    {
+      "id": "rotate_array",
+      "language": "python",
+      "snippet": "def rotate_array(nums: list[int], k: int) -> None:\n    k = k % len(nums)\n    nums[:] = nums[-k:] + nums[:-k]"
+    },
+    {
+      "id": "missing_number",
+      "language": "python",
+      "snippet": "def missing_number(nums: list[int]) -> int:\n    n = len(nums)\n    expected_sum = n * (n + 1) // 2\n    actual_sum = sum(nums)\n    return expected_sum - actual_sum"
+    },
+    {
+      "id": "power",
+      "language": "python",
+      "snippet": "def power(x: float, n: int) -> float:\n    if n == 0:\n        return 1.0\n    if n < 0:\n        x = 1 / x\n        n = -n\n    half = power(x, n // 2)\n    if n % 2 == 0:\n        return half * half\n    else:\n        return half * half * x"
+    },
+    {
+      "id": "digit_sum",
+      "language": "python",
+      "snippet": "def digit_sum(n: int) -> int:\n    return sum(int(digit) for digit in str(abs(n)))"
+    },
+    {
+      "id": "is_perfect_square",
+      "language": "python",
+      "snippet": "def is_perfect_square(n: int) -> bool:\n    if n < 0:\n        return False\n    left, right = 0, n\n    while left <= right:\n        mid = (left + right) // 2\n        sq = mid * mid\n        if sq == n:\n            return True\n        elif sq < n:\n            left = mid + 1\n        else:\n            right = mid - 1\n    return False"
+    },
+    {
+      "id": "string_compression",
+      "language": "python",
+      "snippet": "def compress_string(s: str) -> str:\n    if not s:\n        return s\n    result = []\n    count = 1\n    for i in range(1, len(s)):\n        if s[i] == s[i - 1]:\n            count += 1\n        else:\n            result.append(s[i - 1] + str(count))\n            count = 1\n    result.append(s[-1] + str(count))\n    compressed = ''.join(result)\n    return compressed if len(compressed) < len(s) else s"
+    },
+    {
+      "id": "insertion_sort",
+      "language": "go",
+      "snippet": "func InsertionSort(nums []int) {\n    for i := 1; i < len(nums); i++ {\n        key := nums[i]\n        j := i - 1\n        for j >= 0 && nums[j] > key {\n            nums[j+1] = nums[j]\n            j--\n        }\n        nums[j+1] = key\n    }\n}"
+    },
+    {
+      "id": "contains_duplicate",
+      "language": "go",
+      "snippet": "func ContainsDuplicate(nums []int) bool {\n    seen := make(map[int]bool)\n    for _, num := range nums {\n        if seen[num] {\n            return true\n        }\n        seen[num] = true\n    }\n    return false\n}"
+    },
+    {
+      "id": "reverse_words",
+      "language": "go",
+      "snippet": "func ReverseWords(s string) string {\n    words := strings.Fields(s)\n    for i, j := 0, len(words)-1; i < j; i, j = i+1, j-1 {\n        words[i], words[j] = words[j], words[i]\n    }\n    return strings.Join(words, \" \")\n}"
+    },
+    {
+      "id": "max_subarray_sum",
+      "language": "go",
+      "snippet": "func MaxSubarraySum(nums []int) int {\n    maxSum := nums[0]\n    currentSum := nums[0]\n    for i := 1; i < len(nums); i++ {\n        currentSum = max(nums[i], currentSum+nums[i])\n        maxSum = max(maxSum, currentSum)\n    }\n    return maxSum\n}"
+    },
+    {
+      "id": "product_except_self",
+      "language": "go",
+      "snippet": "func ProductExceptSelf(nums []int) []int {\n    n := len(nums)\n    result := make([]int, n)\n    result[0] = 1\n    for i := 1; i < n; i++ {\n        result[i] = result[i-1] * nums[i-1]\n    }\n    right := 1\n    for i := n - 1; i >= 0; i-- {\n        result[i] *= right\n        right *= nums[i]\n    }\n    return result\n}"
+    },
+    {
+      "id": "move_zeros",
+      "language": "go",
+      "snippet": "func MoveZeros(nums []int) {\n    pos := 0\n    for i := 0; i < len(nums); i++ {\n        if nums[i] != 0 {\n            nums[pos], nums[i] = nums[i], nums[pos]\n            pos++\n        }\n    }\n}"
+    },
+    {
+      "id": "single_number",
+      "language": "go",
+      "snippet": "func SingleNumber(nums []int) int {\n    result := 0\n    for _, num := range nums {\n        result ^= num\n    }\n    return result\n}"
+    },
+    {
+      "id": "plus_one",
+      "language": "go",
+      "snippet": "func PlusOne(digits []int) []int {\n    for i := len(digits) - 1; i >= 0; i-- {\n        if digits[i] < 9 {\n            digits[i]++\n            return digits\n        }\n        digits[i] = 0\n    }\n    return append([]int{1}, digits...)\n}"
+    },
+    {
+      "id": "sqrt_binary",
+      "language": "go",
+      "snippet": "func Sqrt(x int) int {\n    if x < 2 {\n        return x\n    }\n    left, right := 1, x/2\n    for left <= right {\n        mid := (left + right) / 2\n        if mid*mid == x {\n            return mid\n        } else if mid*mid < x {\n            left = mid + 1\n        } else {\n            right = mid - 1\n        }\n    }\n    return right\n}"
+    },
+    {
+      "id": "hamming_distance",
       "language": "go",
-      "snippet": "func IsValidParens(s string) bool {\n    stack := []rune{}\n    pairs := map[rune]rune{')': '(', '}': '{', ']': '['}\n    for _, char := range s {\n        if char == '(' || char == '{' || char == '[' {\n            stack = append(stack, char)\n        } else if open, ok := pairs[char]; ok {\n            if len(stack) == 0 || stack[len(stack)-1] != open {\n                return false\n            }\n            stack = stack[:len(stack)-1]\n        }\n    }\n    return len(stack) == 0\n}"
+      "snippet": "func HammingDistance(x, y int) int {\n    xor := x ^ y\n    count := 0\n    for xor != 0 {\n        count += xor & 1\n        xor >>= 1\n    }\n    return count\n}"
     }
   ]
 }

apps/web/src/features/explorer/components/ExplorerSidebar.styles.ts

@@ -3,20 +3,18 @@ import { uiTokens } from "../../../shared/styles/tokens";
 export const explorerStyles = {
   root: "w-60 shrink-0 h-full overflow-y-auto border-l border-white/10 bg-[#1e1e1e]/90 backdrop-blur-2xl backdrop-saturate-150 p-2",
   header: "px-2 pb-1 text-[0.65rem] uppercase tracking-wider text-white/40",
-  list: "space-y-1",
+  list: "space-y-1 pb-4",
   languageButton: (active: boolean) =>
-    `flex w-full items-center gap-2 rounded-md px-2 py-1 text-left text-[0.75rem] transition-colors ${
-      active ? "bg-white/[0.06] text-white" : "text-white/80 hover:bg-white/[0.06]"
+    `flex w-full items-center gap-2 rounded-md px-2 py-1 text-left text-[0.75rem] transition-colors ${active ? "bg-white/[0.06] text-white" : "text-white/80 hover:bg-white/[0.06]"
     }`,
   folderOpenIcon: "h-3.5 w-3.5 text-white/70",
   folderClosedIcon: "h-3.5 w-3.5 text-white/60",
   languageLabel: "font-medium",
   promptList: "mt-1 ml-5 space-y-0.5",
   promptButton: (selected: boolean) =>
-    `flex w-full items-center gap-2 rounded-md px-2 py-1 font-mono text-[0.7rem] transition-colors ${uiTokens.monoFont} ${
-      selected
-        ? "bg-white/[0.12] text-white"
-        : "text-white/70 hover:bg-white/[0.08] hover:text-white"
+    `flex w-full items-center gap-2 rounded-md px-2 py-1 font-mono text-[0.7rem] transition-colors ${uiTokens.monoFont} ${selected
+      ? "bg-white/[0.12] text-white"
+      : "text-white/70 hover:bg-white/[0.08] hover:text-white"
     }`,
   promptIcon: "text-white/50",
 };

apps/web/src/features/stats/components/BottomStatsPanel.styles.ts

@@ -10,15 +10,15 @@ export const bottomStatsStyles = {
   collapsedMetrics: "flex items-center gap-6",
   collapseIcon: "text-white/60",
   content: (open: boolean) =>
-    `transition-[max-height,opacity] duration-300 ease-out ${
-      open ? "max-h-[460px] opacity-100" : "max-h-0 opacity-0"
+    `transition-all duration-300 ease-out overflow-hidden ${open
+      ? "max-h-[460px] opacity-100 translate-y-0"
+      : "max-h-0 opacity-0 translate-y-4"
     }`,
   inner: "px-5 py-4",
   tabsRow: "mb-3 flex items-center justify-between gap-3",
   tabsGroup: "flex items-center gap-3",
   tabButton: (active: boolean) =>
-    `text-xs rounded-md px-2.5 py-1.5 transition-colors ${
-      active ? "bg-white/10 text-white" : "text-white/70 hover:bg-white/5"
+    `text-xs rounded-md px-2.5 py-1.5 transition-colors ${active ? "bg-white/10 text-white" : "text-white/70 hover:bg-white/5"
     }`,
   collapseButton:
     "rounded-md p-3 text-white/70 transition hover:bg-white/5 hover:text-white",