@taskmark/ui 0.2.0 → 0.2.2

package/dist/standalone/lib/format-date.ts

@@ -1,75 +0,0 @@
-import { format, isValid, parseISO } from "date-fns"
-
-const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/
-const EMPTY = new Set(["", "null", "—", "-", "n/a", "N/A"])
-
-/**
- * Parse Taskmark frontmatter / log date strings.
- * Date-only values (YYYY-MM-DD) are treated as local calendar days to avoid
- * UTC midnight shifting the displayed day.
- */
-export function parseTaskmarkDate(
-  value: string | null | undefined
-): Date | null {
-  const raw = value?.trim() ?? ""
-  if (!raw || EMPTY.has(raw)) return null
-
-  if (DATE_ONLY.test(raw)) {
-    const [y, m, d] = raw.split("-").map(Number)
-    const local = new Date(y, m - 1, d)
-    return isValid(local) ? local : null
-  }
-
-  try {
-    const parsed = parseISO(raw)
-    return isValid(parsed) ? parsed : null
-  } catch {
-    return null
-  }
-}
-
-function hasTimeComponent(raw: string): boolean {
-  return raw.includes("T") || /\d{2}:\d{2}/.test(raw)
-}
-
-/**
- * Format any Taskmark date for display.
- * - Date-only → `Jul 23, 2026`
- * - Datetime → `Jul 23, 2026, 09:44`
- * - Missing/invalid → `—`
- */
-export function formatTaskmarkDate(
-  value: string | null | undefined
-): string {
-  const raw = value?.trim() ?? ""
-  if (!raw || EMPTY.has(raw)) return "—"
-
-  const date = parseTaskmarkDate(raw)
-  if (!date) return raw
-
-  if (hasTimeComponent(raw)) {
-    return format(date, "MMM d, yyyy, HH:mm")
-  }
-  return format(date, "MMM d, yyyy")
-}
-
-/** Always include time when a valid datetime parses; otherwise date-only style. */
-export function formatTaskmarkDateTime(
-  value: string | null | undefined
-): string {
-  const raw = value?.trim() ?? ""
-  if (!raw || EMPTY.has(raw)) return "—"
-
-  const date = parseTaskmarkDate(raw)
-  if (!date) return raw
-
-  if (hasTimeComponent(raw)) {
-    return format(date, "MMM d, yyyy, HH:mm")
-  }
-  return format(date, "MMM d, yyyy")
-}
-
-/** @deprecated Prefer {@link formatTaskmarkDate}. */
-export function formatListDate(value: string | null | undefined): string {
-  return formatTaskmarkDate(value)
-}

package/dist/standalone/lib/format-duration.ts

@@ -1,72 +0,0 @@
-/**
- * Format estimate minutes as a compact human duration.
- * Examples: `45m`, `2h`, `2h 30m`, `1d`, `1d 4h`
- */
-export function formatDurationMinutes(value: number | null | undefined): string {
-  if (value === null || value === undefined || !Number.isFinite(value)) {
-    return "—"
-  }
-
-  const total = Math.max(0, Math.round(value))
-  if (total === 0) return "0m"
-
-  return formatDurationMs(total * 60_000)
-}
-
-/**
- * Format billable Actual from milliseconds.
- * Uses ms / fractional seconds only when useful; otherwise compact m/h/d.
- *
- * Examples: `0ms`, `250ms`, `1.5s`, `45s`, `2m 3s`, `2h 30m`, `1d 4h`
- */
-export function formatDurationMs(value: number | null | undefined): string {
-  if (value === null || value === undefined || !Number.isFinite(value)) {
-    return "—"
-  }
-
-  const ms = Math.max(0, Math.round(value))
-  if (ms === 0) return "0ms"
-
-  if (ms < 1000) {
-    return `${ms}ms`
-  }
-
-  if (ms < 60_000) {
-    const seconds = ms / 1000
-    if (Number.isInteger(seconds) || ms % 1000 === 0) {
-      return `${Math.round(seconds)}s`
-    }
-    const rounded = Math.round(seconds * 100) / 100
-    return `${rounded}s`
-  }
-
-  const totalSeconds = Math.floor(ms / 1000)
-  const days = Math.floor(totalSeconds / (60 * 60 * 8)) // 1 day ≈ 8h workday
-  let rem = totalSeconds % (60 * 60 * 8)
-  const hours = Math.floor(rem / 3600)
-  rem = rem % 3600
-  const minutes = Math.floor(rem / 60)
-  const seconds = rem % 60
-
-  const parts: string[] = []
-  if (days > 0) parts.push(`${days}d`)
-  if (hours > 0) parts.push(`${hours}h`)
-  if (minutes > 0) parts.push(`${minutes}m`)
-  // Show leftover seconds when under an hour and there is a seconds remainder
-  if (seconds > 0 && days === 0 && hours === 0) {
-    parts.push(`${seconds}s`)
-  }
-
-  return parts.length > 0 ? parts.join(" ") : "0ms"
-}
-
-/** Prefer precise actual_ms; fall back to actual_minutes × 60_000. */
-export function formatActualDuration(
-  actualMs: number | null | undefined,
-  actualMinutes: number | null | undefined
-): string {
-  if (actualMs != null && Number.isFinite(actualMs)) {
-    return formatDurationMs(actualMs)
-  }
-  return formatDurationMinutes(actualMinutes)
-}

package/dist/standalone/lib/format-list-date.ts

@@ -1,2 +0,0 @@
-/** @deprecated Import from `@/lib/format-date` instead. */
-export { formatListDate, formatTaskmarkDate } from "@/lib/format-date"

package/dist/standalone/lib/site.ts

@@ -1,8 +0,0 @@
-/** Public origin for absolute OG/Twitter URLs (no trailing slash). */
-export const SITE = {
-  url: (
-    process.env.NEXT_PUBLIC_SITE_URL ||
-    (process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : null) ||
-    "https://taskmark.dev"
-  ).replace(/\/$/, ""),
-} as const

package/dist/standalone/lib/taskmark/active-project.ts

@@ -1,16 +0,0 @@
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-
-/** Resolve which discovered project is active; fall back to the first. */
-export function resolveActiveProject(
-  projects: DiscoveredProject[],
-  activeProjectId: string | null
-): DiscoveredProject | null {
-  if (projects.length === 0) return null
-  if (activeProjectId) {
-    const match = projects.find(
-      (p) => p.id === activeProjectId || p.boardPath === activeProjectId
-    )
-    if (match) return match
-  }
-  return projects[0] ?? null
-}

package/dist/standalone/lib/taskmark/autoconfig.ts

@@ -1,118 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import {
-  resolveBoardAtPath,
-  toDiscoveredProject,
-  discoverTaskmarkProjects,
-} from "@/lib/taskmark/discover"
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-
-export type AutoconfigSource = "env_board" | "env_master" | "cwd"
-
-export type AutoconfigWorkspace = {
-  source: AutoconfigSource
-  /** True when the project list is locked to one board (env board or cwd). */
-  singleProject: boolean
-  masters: string[]
-  projects: DiscoveredProject[]
-}
-
-function readEnvPath(name: string): string | null {
-  const raw = process.env[name]
-  if (!raw || !raw.trim()) return null
-  return path.resolve(raw.trim())
-}
-
-function workspaceFromBoard(
-  boardPath: string,
-  source: AutoconfigSource
-): AutoconfigWorkspace {
-  const project = toDiscoveredProject(boardPath)
-  return {
-    source,
-    singleProject: true,
-    masters: [project.projectPath],
-    projects: [project],
-  }
-}
-
-function workspaceFromMaster(
-  masterPath: string,
-  source: AutoconfigSource
-): AutoconfigWorkspace | null {
-  let projects: DiscoveredProject[]
-  try {
-    projects = discoverTaskmarkProjects(masterPath)
-  } catch {
-    return null
-  }
-  if (projects.length === 0) return null
-  return {
-    source,
-    singleProject: projects.length === 1,
-    masters: [path.resolve(masterPath)],
-    projects,
-  }
-}
-
-/**
- * Candidate directories for cwd-based binding.
- * Prefers TASKMARK_CWD, then npm's INIT_CWD (where the user invoked npm), then process.cwd().
- */
-export function cwdCandidates(): string[] {
-  const out: string[] = []
-  const seen = new Set<string>()
-  for (const raw of [
-    process.env.TASKMARK_CWD,
-    process.env.INIT_CWD,
-    process.cwd(),
-  ]) {
-    if (!raw || !raw.trim()) continue
-    const resolved = path.resolve(raw.trim())
-    try {
-      const key = fs.realpathSync(resolved)
-      if (seen.has(key)) continue
-      seen.add(key)
-      out.push(key)
-    } catch {
-      if (seen.has(resolved)) continue
-      seen.add(resolved)
-      out.push(resolved)
-    }
-  }
-  return out
-}
-
-/**
- * Resolve a zero-config workspace without cookies.
- *
- * Precedence: TASKMARK_BOARD → TASKMARK_MASTER → cwd layouts.
- * Returns null when nothing valid is found (caller should use cookie setup).
- */
-export function resolveAutoconfigWorkspace(): AutoconfigWorkspace | null {
-  const boardEnv = readEnvPath("TASKMARK_BOARD")
-  if (boardEnv) {
-    const board = resolveBoardAtPath(boardEnv)
-    if (board) return workspaceFromBoard(board, "env_board")
-    console.warn(
-      `[taskmark] TASKMARK_BOARD is set but is not a valid board path: ${boardEnv}`
-    )
-  }
-
-  const masterEnv = readEnvPath("TASKMARK_MASTER")
-  if (masterEnv) {
-    const fromMaster = workspaceFromMaster(masterEnv, "env_master")
-    if (fromMaster) return fromMaster
-    console.warn(
-      `[taskmark] TASKMARK_MASTER is set but no Taskmark boards were found: ${masterEnv}`
-    )
-  }
-
-  for (const candidate of cwdCandidates()) {
-    const board = resolveBoardAtPath(candidate)
-    if (board) return workspaceFromBoard(board, "cwd")
-  }
-
-  return null
-}

package/dist/standalone/lib/taskmark/build-snapshot.ts

@@ -1,198 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import { loadWorkItemDetailSync } from "@/lib/taskmark/detail-load"
-import type { WorkItemRef } from "@/lib/taskmark/detail-types"
-import { parseEpicsForProject } from "@/lib/taskmark/parse-epics"
-import { parseWorkItemsForEpic, parseWorkItemsViewForProject } from "@/lib/taskmark/parse-flat-lists"
-import { parseItemsForStory } from "@/lib/taskmark/parse-items"
-import {
-  collectCompletedLeafPointSamples,
-  collectMetricLeaves,
-  computeProjectStatusMetrics,
-} from "@/lib/taskmark/project-metrics"
-import {
-  type BoardSnapshot,
-  storyKey,
-} from "@/lib/taskmark/snapshot-types"
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import { loadWorkspace } from "@/lib/taskmark/workspace"
-import { asString, extractFrontmatter } from "@/lib/taskmark/frontmatter"
-
-function toRef(
-  meta: { id: string; title: string; type: string },
-  filePath: string
-): WorkItemRef {
-  const type = meta.type.toLowerCase()
-  if (type === "epic") {
-    return { kind: "epic", id: meta.id, title: meta.title, filePath }
-  }
-  if (type === "story") {
-    return { kind: "story", id: meta.id, title: meta.title, filePath }
-  }
-  const itemType = type === "bug" ? "bug" : "task"
-  return {
-    kind: "item",
-    id: meta.id,
-    title: meta.title,
-    filePath,
-    itemType,
-  }
-}
-
-function readMeta(
-  filePath: string
-): { id: string; title: string; type: string } | null {
-  try {
-    const raw = fs.readFileSync(filePath, "utf8")
-    const fm = extractFrontmatter(raw)
-    if (!fm) return null
-    const id = asString(fm.id)
-    const title = asString(fm.title)
-    if (!id) return null
-    return { id, title, type: asString(fm.type).toLowerCase() }
-  } catch {
-    return null
-  }
-}
-
-/** Walk one board and collect every work-item ref. */
-export function listAllWorkItemRefs(boardPath: string): WorkItemRef[] {
-  const refs: WorkItemRef[] = []
-  const epicsDir = path.join(boardPath, "epics")
-  let epicEntries: fs.Dirent[]
-  try {
-    epicEntries = fs.readdirSync(epicsDir, { withFileTypes: true })
-  } catch {
-    return refs
-  }
-
-  for (const epicEntry of epicEntries) {
-    if (!epicEntry.isDirectory() || epicEntry.name.startsWith(".")) continue
-    const epicDir = path.join(epicsDir, epicEntry.name)
-
-    const epicFile = path.join(epicDir, "epic.md")
-    if (fs.existsSync(epicFile)) {
-      const meta = readMeta(epicFile)
-      if (meta) refs.push(toRef(meta, epicFile))
-    }
-
-    const epicItemsDir = path.join(epicDir, "items")
-    try {
-      for (const name of fs.readdirSync(epicItemsDir)) {
-        if (!name.endsWith(".md") || name.startsWith(".")) continue
-        const filePath = path.join(epicItemsDir, name)
-        const meta = readMeta(filePath)
-        if (meta) refs.push(toRef(meta, filePath))
-      }
-    } catch {
-      /* no epic-direct items */
-    }
-
-    const storiesDir = path.join(epicDir, "stories")
-    let storyEntries: fs.Dirent[]
-    try {
-      storyEntries = fs.readdirSync(storiesDir, { withFileTypes: true })
-    } catch {
-      continue
-    }
-
-    for (const storyEntry of storyEntries) {
-      if (!storyEntry.isDirectory() || storyEntry.name.startsWith(".")) continue
-      const storyDir = path.join(storiesDir, storyEntry.name)
-      const storyFile = path.join(storyDir, "story.md")
-      if (fs.existsSync(storyFile)) {
-        const meta = readMeta(storyFile)
-        if (meta) refs.push(toRef(meta, storyFile))
-      }
-
-      const storyItemsDir = path.join(storyDir, "items")
-      try {
-        for (const name of fs.readdirSync(storyItemsDir)) {
-          if (!name.endsWith(".md") || name.startsWith(".")) continue
-          const filePath = path.join(storyItemsDir, name)
-          const meta = readMeta(filePath)
-          if (meta) refs.push(toRef(meta, filePath))
-        }
-      } catch {
-        /* no story items */
-      }
-    }
-  }
-
-  return refs
-}
-
-export function buildBoardSnapshot(
-  projects: DiscoveredProject[],
-  active: DiscoveredProject
-): BoardSnapshot {
-  const epics = parseEpicsForProject(active)
-  const workItemsByEpic: BoardSnapshot["workItemsByEpic"] = {}
-  const itemsByStory: BoardSnapshot["itemsByStory"] = {}
-
-  for (const epic of epics.epics) {
-    const epicList = parseWorkItemsForEpic(active, epic.id, epic.title)
-    workItemsByEpic[epic.id] = epicList
-    for (const row of epicList.rows) {
-      if (row.kind !== "story") continue
-      itemsByStory[storyKey(epic.id, row.id)] = parseItemsForStory(
-        active,
-        epic.id,
-        row.id
-      )
-    }
-  }
-
-  const refs = listAllWorkItemRefs(active.boardPath)
-  const refsById: BoardSnapshot["refsById"] = {}
-  const detailsByPath: BoardSnapshot["detailsByPath"] = {}
-
-  for (const ref of refs) {
-    refsById[ref.id] = ref
-    const hint =
-      ref.kind === "epic" ? "epic" : ref.kind === "story" ? "story" : "item"
-    const detail = loadWorkItemDetailSync(projects, ref.filePath, hint)
-    if (detail.ok) {
-      detailsByPath[ref.filePath] = detail.detail
-    }
-  }
-
-  const hideCompletedDefaults = {
-    epics: false,
-    stories: false,
-    tasks: false,
-    overallWorkItems: false,
-    workItems: false,
-  } as const
-
-  return {
-    version: 1,
-    builtAt: new Date().toISOString(),
-    project: active,
-    projects,
-    epics,
-    workItemsView: parseWorkItemsViewForProject(active),
-    workItemsByEpic,
-    itemsByStory,
-    statusMetrics: computeProjectStatusMetrics(active),
-    countableCompletions: collectCompletedLeafPointSamples(
-      collectMetricLeaves(active)
-    ),
-    hideCompletedDefaults: { ...hideCompletedDefaults },
-    detailsByPath,
-    refsById,
-  }
-}
-
-/** Build snapshot from env/cwd autoconfig (no cookies). */
-export function buildBoardSnapshotFromEnv(): BoardSnapshot {
-  const workspace = loadWorkspace([])
-  if (workspace.projects.length === 0) {
-    throw new Error(
-      "No Taskmark board found. Set TASKMARK_BOARD or run from a board / product root."
-    )
-  }
-  const active = workspace.projects[0]!
-  return buildBoardSnapshot(workspace.projects, active)
-}

package/dist/standalone/lib/taskmark/constants.ts

@@ -1,43 +0,0 @@
-export const MASTER_FOLDER_COOKIE = "taskmark_master_folder"
-
-/** JSON array of master folder absolute paths (accumulates via Add project) */
-export const MASTER_FOLDERS_COOKIE = "taskmark_master_folders"
-
-/** Active discovered project id (realpath of boardPath) */
-export const ACTIVE_PROJECT_COOKIE = "taskmark_active_project"
-
-/** Cookie lifetime: 1 year */
-export const MASTER_FOLDER_COOKIE_MAX_AGE = 60 * 60 * 24 * 365
-
-export const MASTER_FOLDERS_COOKIE_MAX_AGE = MASTER_FOLDER_COOKIE_MAX_AGE
-
-export const ACTIVE_PROJECT_COOKIE_MAX_AGE = MASTER_FOLDER_COOKIE_MAX_AGE
-
-/** Per-list Hide completed prefs (client-readable; not httpOnly) */
-export const HIDE_COMPLETED_COOKIE_MAX_AGE = MASTER_FOLDER_COOKIE_MAX_AGE
-
-export const HIDE_COMPLETED_COOKIES = {
-  epics: "taskmark_hide_completed_epics",
-  stories: "taskmark_hide_completed_stories",
-  tasks: "taskmark_hide_completed_tasks",
-  overallWorkItems: "taskmark_hide_completed_overall_work_items",
-  workItems: "taskmark_hide_completed_work_items",
-} as const
-
-export type HideCompletedCookieKey = keyof typeof HIDE_COMPLETED_COOKIES
-
-/** How deep to walk under the master folder when discovering boards */
-export const DISCOVERY_MAX_DEPTH = 3
-
-export const DISCOVERY_SKIP_DIR_NAMES = new Set([
-  "node_modules",
-  ".git",
-  ".next",
-  ".turbo",
-  ".cache",
-  "dist",
-  "build",
-  "coverage",
-  "out",
-  "vendor",
-])

package/dist/standalone/lib/taskmark/cookies.ts

@@ -1,169 +0,0 @@
-import { cookies } from "next/headers"
-
-import {
-  ACTIVE_PROJECT_COOKIE,
-  ACTIVE_PROJECT_COOKIE_MAX_AGE,
-  HIDE_COMPLETED_COOKIES,
-  MASTER_FOLDER_COOKIE,
-  MASTER_FOLDERS_COOKIE,
-  MASTER_FOLDERS_COOKIE_MAX_AGE,
-  MASTER_FOLDER_COOKIE_MAX_AGE,
-  type HideCompletedCookieKey,
-} from "@/lib/taskmark/constants"
-import { parseHideCompletedCookieValue } from "@/lib/taskmark/hide-completed-cookie"
-import { isStaticRuntime } from "@/lib/taskmark/static-mode"
-
-async function readEncodedCookie(name: string): Promise<string | null> {
-  if (isStaticRuntime()) return null
-  const store = await cookies()
-  const value = store.get(name)?.value
-  if (!value) return null
-  try {
-    return decodeURIComponent(value)
-  } catch {
-    return value
-  }
-}
-
-function encodeCookieValue(value: string): string {
-  return encodeURIComponent(value)
-}
-
-/** Legacy single master + new multi-master list. */
-export async function getMasterFoldersCookie(): Promise<string[]> {
-  const rawList = await readEncodedCookie(MASTER_FOLDERS_COOKIE)
-  if (rawList) {
-    try {
-      const parsed = JSON.parse(rawList) as unknown
-      if (Array.isArray(parsed)) {
-        return [
-          ...new Set(
-            parsed
-              .filter((v): v is string => typeof v === "string")
-              .map((v) => v.trim())
-              .filter(Boolean)
-          ),
-        ]
-      }
-    } catch {
-      // fall through to legacy
-    }
-  }
-
-  const legacy = await readEncodedCookie(MASTER_FOLDER_COOKIE)
-  if (legacy?.trim()) {
-    return [legacy.trim()]
-  }
-  return []
-}
-
-export async function setMasterFoldersCookie(masters: string[]): Promise<void> {
-  if (isStaticRuntime()) return
-  const unique = [
-    ...new Set(masters.map((m) => m.trim()).filter(Boolean)),
-  ]
-  const store = await cookies()
-  store.set(MASTER_FOLDERS_COOKIE, encodeCookieValue(JSON.stringify(unique)), {
-    path: "/",
-    maxAge: MASTER_FOLDERS_COOKIE_MAX_AGE,
-    sameSite: "lax",
-    httpOnly: true,
-  })
-  // Keep legacy cookie aligned with the latest added master for older readers.
-  if (unique.length > 0) {
-    store.set(MASTER_FOLDER_COOKIE, encodeCookieValue(unique[unique.length - 1]!), {
-      path: "/",
-      maxAge: MASTER_FOLDER_COOKIE_MAX_AGE,
-      sameSite: "lax",
-      httpOnly: true,
-    })
-  } else {
-    store.delete(MASTER_FOLDER_COOKIE)
-  }
-}
-
-export async function addMasterFolderCookie(masterPath: string): Promise<string[]> {
-  const existing = await getMasterFoldersCookie()
-  const next = [...existing]
-  if (!next.includes(masterPath)) {
-    next.push(masterPath)
-  }
-  await setMasterFoldersCookie(next)
-  return next
-}
-
-export async function clearMasterFoldersCookie(): Promise<void> {
-  if (isStaticRuntime()) return
-  const store = await cookies()
-  store.delete(MASTER_FOLDERS_COOKIE)
-  store.delete(MASTER_FOLDER_COOKIE)
-}
-
-/** @deprecated use getMasterFoldersCookie */
-export async function getMasterFolderCookie(): Promise<string | null> {
-  const masters = await getMasterFoldersCookie()
-  return masters[masters.length - 1] ?? null
-}
-
-export async function getActiveProjectCookie(): Promise<string | null> {
-  return readEncodedCookie(ACTIVE_PROJECT_COOKIE)
-}
-
-export async function setActiveProjectCookie(projectId: string): Promise<void> {
-  if (isStaticRuntime()) return
-  const store = await cookies()
-  store.set(ACTIVE_PROJECT_COOKIE, encodeCookieValue(projectId), {
-    path: "/",
-    maxAge: ACTIVE_PROJECT_COOKIE_MAX_AGE,
-    sameSite: "lax",
-    httpOnly: true,
-  })
-}
-
-export async function clearActiveProjectCookie(): Promise<void> {
-  if (isStaticRuntime()) return
-  const store = await cookies()
-  store.delete(ACTIVE_PROJECT_COOKIE)
-}
-
-export async function getHideCompletedCookie(
-  key: HideCompletedCookieKey
-): Promise<boolean> {
-  if (isStaticRuntime()) return false
-  const store = await cookies()
-  return parseHideCompletedCookieValue(
-    store.get(HIDE_COMPLETED_COOKIES[key])?.value
-  )
-}
-
-export async function getHideCompletedCookies(): Promise<
-  Record<HideCompletedCookieKey, boolean>
-> {
-  if (isStaticRuntime()) {
-    return {
-      epics: false,
-      stories: false,
-      tasks: false,
-      overallWorkItems: false,
-      workItems: false,
-    }
-  }
-  const store = await cookies()
-  return {
-    epics: parseHideCompletedCookieValue(
-      store.get(HIDE_COMPLETED_COOKIES.epics)?.value
-    ),
-    stories: parseHideCompletedCookieValue(
-      store.get(HIDE_COMPLETED_COOKIES.stories)?.value
-    ),
-    tasks: parseHideCompletedCookieValue(
-      store.get(HIDE_COMPLETED_COOKIES.tasks)?.value
-    ),
-    overallWorkItems: parseHideCompletedCookieValue(
-      store.get(HIDE_COMPLETED_COOKIES.overallWorkItems)?.value
-    ),
-    workItems: parseHideCompletedCookieValue(
-      store.get(HIDE_COMPLETED_COOKIES.workItems)?.value
-    ),
-  }
-}