@taskmark/ui 0.2.1 → 0.2.2

package/dist/standalone/lib/taskmark/list-filters.ts

@@ -1,327 +0,0 @@
-/** Pure helpers for board list search and filters (client-side). */
-
-import {
-  DEFAULT_TIMEFRAME_FILTER,
-  passesTimeframeFilter,
-  timeframeResetKey,
-  type TimeframeFilterState,
-} from "@/lib/taskmark/timeframe-filters"
-
-export type WorkItemSearchFields = {
-  id: string
-  title: string
-}
-
-export type ListSearchQuery = string
-
-export type ParentFilterKind = "epic" | "story"
-
-export type ParentFilterValue = {
-  kind: ParentFilterKind
-  id: string
-  title: string
-}
-
-/** Stable key for parent filter selection (e.g. `epic:E-010`). */
-export function parentFilterKey(parent: ParentFilterValue): string {
-  return `${parent.kind}:${parent.id}`
-}
-
-export function parseParentFilterKey(
-  key: string | null | undefined
-): { kind: ParentFilterKind; id: string } | null {
-  if (!key) return null
-  const colon = key.indexOf(":")
-  if (colon <= 0) return null
-  const kind = key.slice(0, colon)
-  const id = key.slice(colon + 1)
-  if ((kind !== "epic" && kind !== "story") || !id) return null
-  return { kind, id }
-}
-
-export type ListFilterState = {
-  query: ListSearchQuery
-  hideCompleted: boolean
-  /** Selected parent keys (`epic:…` / `story:…`); empty = no parent filter. */
-  parentKeys: string[]
-  /** Empty = no tag filter; otherwise match any selected tag. */
-  selectedTags: string[]
-  timeframe: TimeframeFilterState
-}
-
-export const DEFAULT_LIST_FILTER_STATE: ListFilterState = {
-  query: "",
-  hideCompleted: false,
-  parentKeys: [],
-  selectedTags: [],
-  timeframe: DEFAULT_TIMEFRAME_FILTER,
-}
-
-export type { TimeframeFilterState }
-export {
-  DEFAULT_TIMEFRAME_FILTER,
-  isTimeframeActive,
-  isWeekRangeSelection,
-  recentWeekRange,
-  timeframeResetKey,
-} from "@/lib/taskmark/timeframe-filters"
-
-export function normalizeSearchQuery(query: string): string {
-  return query.trim().toLowerCase()
-}
-
-/**
- * Empty / whitespace query matches everything.
- * Otherwise case-insensitive substring match on id or title.
- */
-export function matchesWorkItemSearch(
-  query: string,
-  fields: WorkItemSearchFields
-): boolean {
-  const q = normalizeSearchQuery(query)
-  if (!q) return true
-  return (
-    fields.id.toLowerCase().includes(q) ||
-    fields.title.toLowerCase().includes(q)
-  )
-}
-
-export function isCompletedStatus(status: string): boolean {
-  return status.trim().toLowerCase() === "done"
-}
-
-/** True when every child is done (and there is at least one child). */
-export function isChildProgressComplete(
-  done?: number,
-  total?: number
-): boolean {
-  if (total == null || done == null) return false
-  return total > 0 && done >= total
-}
-
-/**
- * When hideCompleted is on, drop completed rows.
- *
- * Prefer child progress when totals are present: a parent with open children
- * stays visible even if frontmatter status is still `done` (e.g. epic-direct
- * backlog under a previously completed epic). Otherwise fall back to status.
- */
-export function passesHideCompleted(
-  hideCompleted: boolean,
-  status: string,
-  progress?: { done?: number; total?: number }
-): boolean {
-  if (!hideCompleted) return true
-  const total = progress?.total
-  const done = progress?.done
-  if (total != null && total > 0 && done != null) {
-    return !isChildProgressComplete(done, total)
-  }
-  return !isCompletedStatus(status)
-}
-
-/** Keep row if it includes any of the selected tags. Empty selection = pass. */
-export function matchesAnySelectedTag(
-  selectedTags: readonly string[],
-  rowTags: readonly string[] | undefined
-): boolean {
-  if (selectedTags.length === 0) return true
-  if (!rowTags || rowTags.length === 0) return false
-  const set = new Set(rowTags.map((t) => t.toLowerCase()))
-  return selectedTags.some((t) => set.has(t.toLowerCase()))
-}
-
-export type ParentFilterableRow = {
-  id: string
-  kind?: string
-  epicId: string
-}
-
-/**
- * Empty selection → pass.
- * Otherwise match **any** selected parent:
- * - epic → rows under that epic
- * - story → that story row (Work items has no story-child tasks)
- */
-export function matchesAnyParentFilter(
-  parentKeys: readonly string[],
-  row: ParentFilterableRow
-): boolean {
-  if (parentKeys.length === 0) return true
-  return parentKeys.some((key) => {
-    const parsed = parseParentFilterKey(key)
-    if (!parsed) return false
-    if (parsed.kind === "epic") return row.epicId === parsed.id
-    return row.kind === "story" && row.id === parsed.id
-  })
-}
-
-/** @deprecated Use matchesAnyParentFilter with a single-key array. */
-export function matchesParentFilter(
-  parentKey: string | null,
-  row: ParentFilterableRow
-): boolean {
-  if (!parentKey) return true
-  return matchesAnyParentFilter([parentKey], row)
-}
-
-export function collectUniqueTags(
-  rows: readonly { tags?: readonly string[] }[]
-): string[] {
-  const set = new Set<string>()
-  for (const row of rows) {
-    for (const tag of row.tags ?? []) {
-      const t = tag.trim()
-      if (t) set.add(t)
-    }
-  }
-  return [...set].sort((a, b) => a.localeCompare(b))
-}
-
-export type ParentFilterOption = ParentFilterValue & {
-  key: string
-  /** Full label for the dropdown. */
-  label: string
-  /** Short label for chips (id). */
-  chipLabel: string
-}
-
-/** Build epic + story options from Work items rows. */
-export function buildParentFilterOptions(
-  rows: readonly {
-    id: string
-    title: string
-    kind: string
-    epicId: string
-    epicTitle: string
-  }[]
-): ParentFilterOption[] {
-  const epics = new Map<string, ParentFilterOption>()
-  const stories = new Map<string, ParentFilterOption>()
-
-  for (const row of rows) {
-    if (row.epicId && !epics.has(row.epicId)) {
-      const value: ParentFilterValue = {
-        kind: "epic",
-        id: row.epicId,
-        title: row.epicTitle,
-      }
-      epics.set(row.epicId, {
-        ...value,
-        key: parentFilterKey(value),
-        label: `Epic ${row.epicId}: ${row.epicTitle}`,
-        chipLabel: row.epicId,
-      })
-    }
-    if (row.kind === "story" && !stories.has(row.id)) {
-      const value: ParentFilterValue = {
-        kind: "story",
-        id: row.id,
-        title: row.title,
-      }
-      stories.set(row.id, {
-        ...value,
-        key: parentFilterKey(value),
-        label: `Story ${row.id}: ${row.title}`,
-        chipLabel: row.id,
-      })
-    }
-  }
-
-  return [
-    ...[...epics.values()].sort((a, b) => a.id.localeCompare(b.id)),
-    ...[...stories.values()].sort((a, b) => a.id.localeCompare(b.id)),
-  ]
-}
-
-export type FilterableListRow = WorkItemSearchFields & {
-  status: string
-  tags?: readonly string[]
-  kind?: string
-  epicId?: string
-  /** Solved date (`completed_at`); required for timeframe filtering. */
-  completedAt?: string
-  /** When set with doneWorkItemCount, used for hide-completed on progress rows. */
-  workItemCount?: number
-  doneWorkItemCount?: number
-}
-
-export function filterListRows<T extends FilterableListRow>(
-  rows: readonly T[],
-  state: Pick<
-    ListFilterState,
-    "query" | "hideCompleted" | "selectedTags"
-  > & {
-    parentKeys?: readonly string[]
-    /** @deprecated Prefer parentKeys. */
-    parentKey?: string | null
-    timeframe?: TimeframeFilterState
-  }
-): T[] {
-  const parentKeys =
-    state.parentKeys ??
-    (state.parentKey ? [state.parentKey] : [])
-  const timeframe = state.timeframe ?? DEFAULT_TIMEFRAME_FILTER
-  return rows.filter((row) => {
-    if (!matchesWorkItemSearch(state.query, row)) return false
-    if (
-      !passesHideCompleted(state.hideCompleted, row.status, {
-        done: row.doneWorkItemCount,
-        total: row.workItemCount,
-      })
-    ) {
-      return false
-    }
-    if (!matchesAnySelectedTag(state.selectedTags, row.tags)) return false
-    if (parentKeys.length > 0) {
-      if (!row.epicId) return false
-      if (
-        !matchesAnyParentFilter(parentKeys, {
-          id: row.id,
-          kind: row.kind,
-          epicId: row.epicId,
-        })
-      ) {
-        return false
-      }
-    }
-    if (!passesTimeframeFilter(timeframe, row.completedAt)) return false
-    return true
-  })
-}
-
-/** Compact reset key fragment for pagination when filters change. */
-export function listFilterResetKey(
-  base: string,
-  state: Pick<
-    ListFilterState,
-    "query" | "hideCompleted" | "selectedTags"
-  > & {
-    parentKeys?: readonly string[]
-    /** @deprecated Prefer parentKeys. */
-    parentKey?: string | null
-    timeframe?: TimeframeFilterState
-  }
-): string {
-  const parentKeys =
-    state.parentKeys ??
-    (state.parentKey ? [state.parentKey] : [])
-  const tags = [...state.selectedTags].sort().join(",")
-  const parents = [...parentKeys].sort().join(",")
-  const timeframe = state.timeframe ?? DEFAULT_TIMEFRAME_FILTER
-  return [
-    base,
-    normalizeSearchQuery(state.query),
-    state.hideCompleted ? "1" : "0",
-    parents,
-    tags,
-    timeframeResetKey(timeframe),
-  ].join("|")
-}
-
-/**
- * Shared shell classes matching ComboboxChips so search and multiselect
- * filters look the same.
- */
-export const FILTER_CHIPS_FIELD_CLASS =
-  "flex min-h-8 flex-wrap items-center gap-1 rounded border-2 bg-input bg-clip-padding px-2.5 py-1 text-sm shadow-sm transition-colors focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-primary"

package/dist/standalone/lib/taskmark/list-view-mode.ts

@@ -1,137 +0,0 @@
-export const LIST_VIEW_MODES = ["overall", "workitems"] as const
-
-export type ListViewMode = (typeof LIST_VIEW_MODES)[number]
-
-export const DEFAULT_LIST_VIEW_MODE: ListViewMode = "overall"
-
-export const LIST_VIEW_LABELS: Record<ListViewMode, string> = {
-  overall: "Overall",
-  workitems: "Work items",
-}
-
-/** Legacy view query values that map to Work items. */
-const LEGACY_WORKITEMS_VIEWS = new Set(["all", "stories", "tasks", "workitems"])
-
-export function parseListViewMode(
-  value: string | string[] | undefined
-): ListViewMode {
-  const raw = typeof value === "string" ? value.trim().toLowerCase() : ""
-  if (raw === "overall") return "overall"
-  if (LEGACY_WORKITEMS_VIEWS.has(raw)) return "workitems"
-  return DEFAULT_LIST_VIEW_MODE
-}
-
-export function boardHref(opts: {
-  view?: ListViewMode
-  epic?: string | null
-  story?: string | null
-  /** Open work item detail sheet (E-/S-/T-/B- id). */
-  item?: string | null
-}): string {
-  const params = new URLSearchParams()
-  const view = opts.view ?? DEFAULT_LIST_VIEW_MODE
-  if (view !== DEFAULT_LIST_VIEW_MODE) {
-    params.set("view", view)
-  }
-  if (view === "overall") {
-    if (opts.epic) params.set("epic", opts.epic)
-    if (opts.epic && opts.story) params.set("story", opts.story)
-  }
-  if (opts.item) params.set("item", opts.item)
-  const qs = params.toString()
-  return qs ? `/board?${qs}` : "/board"
-}
-
-const STATUS_RANK: Record<string, number> = {
-  backlog: 0,
-  in_progress: 1,
-  done: 2,
-  blocked: 3,
-  cancelled: 4,
-}
-
-const PRIORITY_RANK: Record<string, number> = {
-  critical: 0,
-  high: 1,
-  medium: 2,
-  low: 3,
-}
-
-export function statusSortRank(status: string): number {
-  return STATUS_RANK[status.toLowerCase()] ?? 50
-}
-
-export function prioritySortRank(priority: string): number {
-  return PRIORITY_RANK[priority.toLowerCase()] ?? 50
-}
-
-/**
- * Primary: status (backlog → in_progress → done);
- * For open statuses: priority (highest first), then created (newest first);
- * For done/cancelled: solved date only (completedAt newest first; no priority);
- * then id.
- */
-export function compareByStatusThenPriority(
-  a: {
-    status: string
-    priority: string
-    created?: string
-    completedAt?: string
-    id: string
-  },
-  b: {
-    status: string
-    priority: string
-    created?: string
-    completedAt?: string
-    id: string
-  }
-): number {
-  const byStatus = statusSortRank(a.status) - statusSortRank(b.status)
-  if (byStatus !== 0) return byStatus
-
-  // Solved cohort: newest completed first; ignore priority.
-  if (usesCompletedDate(a.status)) {
-    return compareByDateThenId(a, b, /*preferCompleted*/ true)
-  }
-
-  const byPriority =
-    prioritySortRank(a.priority) - prioritySortRank(b.priority)
-  if (byPriority !== 0) return byPriority
-
-  return compareByDateThenId(a, b, /*preferCompleted*/ false)
-}
-
-function usesCompletedDate(status: string): boolean {
-  const s = status.trim().toLowerCase()
-  return s === "done" || s === "cancelled"
-}
-
-function compareByDateThenId(
-  a: { created?: string; completedAt?: string; id: string; status: string },
-  b: { created?: string; completedAt?: string; id: string; status: string },
-  preferCompleted: boolean
-): number {
-  const dateA = preferCompleted
-    ? completedOrCreated(a)
-    : (a.created?.trim() ?? "")
-  const dateB = preferCompleted
-    ? completedOrCreated(b)
-    : (b.created?.trim() ?? "")
-  if (dateA && dateB) {
-    const byDate = dateB.localeCompare(dateA)
-    if (byDate !== 0) return byDate
-  } else if (dateA !== dateB) {
-    return dateA ? -1 : 1
-  }
-  return a.id.localeCompare(b.id)
-}
-
-function completedOrCreated(row: {
-  created?: string
-  completedAt?: string
-}): string {
-  const done = row.completedAt?.trim() ?? ""
-  if (done) return done
-  return row.created?.trim() ?? ""
-}

package/dist/standalone/lib/taskmark/load-snapshot-server.ts

@@ -1,11 +0,0 @@
-import "server-only"
-import fs from "node:fs"
-import path from "node:path"
-
-import type { BoardSnapshot } from "@/lib/taskmark/snapshot-types"
-
-export function loadSnapshotFromPublic(): BoardSnapshot {
-  const file = path.join(process.cwd(), "public", "taskmark-snapshot.json")
-  const raw = fs.readFileSync(file, "utf8")
-  return JSON.parse(raw) as BoardSnapshot
-}

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

@@ -1,51 +0,0 @@
-/** Shared list pagination types and defaults (1-based page index). */
-
-export const PAGE_SIZE_OPTIONS = [10, 25, 50, 100] as const
-
-export type PageSize = (typeof PAGE_SIZE_OPTIONS)[number]
-
-export const DEFAULT_PAGE_SIZE: PageSize = 25
-
-export type PaginationState = {
-  /** 1-based page index. */
-  page: number
-  pageSize: PageSize
-}
-
-export type PageSliceResult<T> = {
-  pageRows: T[]
-  totalCount: number
-  /** 0 when there are no rows; otherwise ≥ 1. */
-  totalPages: number
-  /** Clamped 1-based page. */
-  page: number
-  pageSize: PageSize
-}
-
-export function isPageSize(value: number): value is PageSize {
-  return (PAGE_SIZE_OPTIONS as readonly number[]).includes(value)
-}
-
-/**
- * Slice `rows` for the given 1-based `page` and `pageSize`.
- * Empty input → totalPages 0, page 1, empty pageRows.
- */
-export function slicePage<T>(
-  rows: readonly T[],
-  page: number,
-  pageSize: number
-): PageSliceResult<T> {
-  const size: PageSize = isPageSize(pageSize) ? pageSize : DEFAULT_PAGE_SIZE
-  const totalCount = rows.length
-  const totalPages = totalCount === 0 ? 0 : Math.ceil(totalCount / size)
-  const clampedPage =
-    totalPages === 0 ? 1 : Math.min(Math.max(1, Math.trunc(page) || 1), totalPages)
-  const start = (clampedPage - 1) * size
-  return {
-    pageRows: rows.slice(start, start + size) as T[],
-    totalCount,
-    totalPages,
-    page: clampedPage,
-    pageSize: size,
-  }
-}