${t('noTimelineEntries')}
`; + return `${rows}`; +} +function createTaskActions(task) { + const hiddenAction = HIDEABLE_STATUSES.includes(task.status) + ? `` + : ''; + return `${escapeHtml(task.description)}
` + : ''; + return `${hidden ? t(key, { count: hidden }) : t('noTasks')}
`; + applySearchFilter(document.querySelector(`#${status}Tasks`)); + if (updateCounts) updateTaskCounts(); +} +export function renderAllTasks() { + STATUSES.forEach((status) => renderColumn(status, false)); + updateTaskCounts(); + renderSortOptions(); +} diff --git a/src/js/seed-data.js b/src/js/seed-data.js new file mode 100644 index 0000000..436923f --- /dev/null +++ b/src/js/seed-data.js @@ -0,0 +1,94 @@ +export function createSeedTasks(now = new Date()) { + const createdDate = now.toISOString(); + return [ + { + id: 1, + title: '所有设备相机参数标准化', + description: '完成所有生产设备的相机参数标准化工作，确保图像采集的一致性和可靠性。', + progressNotes: '目前已完成大部分设备的参数标准化工作，仅剩DieBond贴片相机待确认参数配置。', + status: 'inProgress', + progress: 90, + assignee: '技术团队', + collaborators: [], + dueDate: '2025-02-15', + createdDate, + language: 'zh', + priority: 'high', + isPinned: false, + timeline: [], + isHidden: false, + }, + { + id: 2, + title: 'DieBond设备照明优化', + description: + '定制组合光源：同轴光+环形光，采购更窄、更亮的侧面光源，以解决支架白边问题，提升图像质量。', + progressNotes: + '配置方案已与供应商确认，技术参数符合要求。供应商承诺2025年7月4日发货，目前正在生产中。', + status: 'inProgress', + progress: 60, + assignee: '硬件团队', + collaborators: ['供应商'], + dueDate: '2025-07-04', + createdDate, + language: 'zh', + priority: 'medium', + isPinned: true, + timeline: [], + isHidden: false, + }, + { + id: 3, + title: 'DieBond和ClipBond软件界面中英文翻译更新', + description: '完成DieBond和ClipBond设备软件界面的中英文翻译工作，支持多语言操作环境。', + progressNotes: + 'SG-TATA GUI 的中英文翻译已完成。未来更新杨杰的代码后，需要重新进行翻译（任务量很少）。', + status: 'inProgress', + progress: 80, + assignee: '杨杰', + collaborators: ['翻译团队'], + dueDate: '2025-02-28', + createdDate, + language: 'zh', + priority: 'medium', + isPinned: false, + timeline: [], + isHidden: false, + }, + { + id: 4, + title: '所有设备相机手册', + description: '编写所有设备相机的操作手册，包括校准流程、位置引导方法、检测标准等技术文档。', + progressNotes: '任务刚启动，正在收集各设备的相机技术规格和操作要求。', + status: 'todo', + progress: 0, + assignee: '技术文档组', + collaborators: [], + dueDate: '2025-03-31', + createdDate, + language: 'zh', + priority: 'low', + isPinned: false, + timeline: [], + isHidden: false, + }, + { + id: 5, + title: '开发 TaTa SECS/GEM & Map 软件', + description: + '开发符合SEMI标准的SECS/GEM通信协议软件，实现设备与MES系统的标准化通信，包括Map数据管理功能。', + progressNotes: '需求分析阶段，正在梳理SECS/GEM协议规范和技术架构设计。', + status: 'todo', + progress: 0, + assignee: '软件开发组', + collaborators: ['系统架构师'], + dueDate: '2025-06-30', + createdDate, + language: 'zh', + priority: 'high', + isPinned: false, + timeline: [], + isHidden: false, + }, + ]; +} diff --git a/src/js/sort.js b/src/js/sort.js new file mode 100644 index 0000000..470ff20 --- /dev/null +++ b/src/js/sort.js @@ -0,0 +1,36 @@ +import { PRIORITY_ORDER, SORT_VALUES } from './config.js'; +import { isHiddenTask } from './utils.js'; + +const number = (task) => Number.parseInt(task.title.match(/\d+/)?.[0], 10) || 0; +const date = (value) => new Date(value).getTime() || 0; +const title = (a, b) => a.title.localeCompare(b.title); +const due = (a, b) => { + if (!a.dueDate && !b.dueDate) return 0; + if (!a.dueDate) return 1; + if (!b.dueDate) return -1; + return date(a.dueDate) - date(b.dueDate); +}; +const comparators = { + title, + number: (a, b) => number(a) - number(b) || title(a, b), + dueDate: due, + priority: (a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority], + progress: (a, b) => a.progress - b.progress, + created: (a, b) => date(a.createdDate) - date(b.createdDate), +}; +export function sortTasks(taskList, sortOrder = 'default') { + const result = [...taskList]; + const valid = SORT_VALUES.has(sortOrder) ? sortOrder : 'default'; + return result.sort((a, b) => { + if (a.isPinned !== b.isPinned) return a.isPinned ? -1 : 1; + if (isHiddenTask(a) !== isHiddenTask(b)) return isHiddenTask(a) ? 1 : -1; + if (valid === 'default') + return ( + PRIORITY_ORDER[b.priority] - PRIORITY_ORDER[a.priority] || + date(b.createdDate) - date(a.createdDate) + ); + const [key, direction] = valid.split('-'); + if (key === 'dueDate' && (!a.dueDate || !b.dueDate)) return due(a, b); + return comparators[key](a, b) * (direction === 'desc' ? -1 : 1); + }); +} diff --git a/src/js/storage.js b/src/js/storage.js new file mode 100644 index 0000000..c1eca5a --- /dev/null +++ b/src/js/storage.js @@ -0,0 +1,63 @@ +import { STORAGE_KEYS } from './config.js'; + +let writeFailed = false; +export function consumeStorageWriteFailure() { + const failed = writeFailed; + writeFailed = false; + return failed; +} +function readRaw(key) { + try { + return { value: localStorage.getItem(key), available: true }; + } catch { + return { value: null, available: false }; + } +} +function writeRaw(key, value) { + try { + localStorage.setItem(key, value); + return true; + } catch { + writeFailed = true; + return false; + } +} +function readJson(key, fallback) { + const { value, available } = readRaw(key); + if (!available || value === null) return fallback; + try { + return JSON.parse(value); + } catch { + return fallback; + } +} +function writeJson(key, value) { + return writeRaw(key, JSON.stringify(value)); +} +export function loadTasksData() { + const { value: raw, available } = readRaw(STORAGE_KEYS.tasks); + if (!available) return { tasks: [], corrupted: false, exists: false, available: false }; + if (raw === null) return { tasks: [], corrupted: false, exists: false, available: true }; + writeRaw(STORAGE_KEYS.initialized, 'true'); + try { + const tasks = JSON.parse(raw); + if (!Array.isArray(tasks)) throw new TypeError('Tasks must be an array'); + return { tasks, corrupted: false, exists: true, available: true }; + } catch { + writeRaw(STORAGE_KEYS.corruptedBackup, raw); + return { tasks: [], corrupted: true, exists: true, available: true }; + } +} +export const saveTasksData = (tasks) => writeJson(STORAGE_KEYS.tasks, tasks); +export const loadSortOrdersData = () => readJson(STORAGE_KEYS.sortOrders, {}); +export const saveSortOrdersData = (orders) => writeJson(STORAGE_KEYS.sortOrders, orders); +export const loadShowHiddenData = (status) => { + const key = STORAGE_KEYS.showHidden[status]; + return key ? readJson(key, false) === true : false; +}; +export const saveShowHiddenData = (status, value) => { + const key = STORAGE_KEYS.showHidden[status]; + return key ? writeJson(key, value) : false; +}; +export const isInitialized = () => readRaw(STORAGE_KEYS.initialized).value !== null; +export const markInitialized = () => writeRaw(STORAGE_KEYS.initialized, 'true'); diff --git a/src/js/store.js b/src/js/store.js new file mode 100644 index 0000000..7c7f4f7 --- /dev/null +++ b/src/js/store.js @@ -0,0 +1,107 @@ +import { DEFAULT_SORT_ORDERS, HIDEABLE_STATUSES, SORT_VALUES, STATUSES } from './config.js'; +import { normalizeSortOrders, normalizeTask, normalizeTasks } from './task-model.js'; +import { generateUniqueId } from './utils.js'; +import { + loadShowHiddenData, + loadSortOrdersData, + loadTasksData, + markInitialized, + saveShowHiddenData, + saveSortOrdersData, + saveTasksData, +} from './storage.js'; + +let tasks = []; +let sortOrders = { ...DEFAULT_SORT_ORDERS }; +let showHidden = Object.fromEntries(HIDEABLE_STATUSES.map((status) => [status, false])); +let corrupted = false; +const persistTasks = () => saveTasksData(tasks); +export function initializeStore(seedTasks, initialized) { + const loaded = loadTasksData(); + corrupted = loaded.corrupted; + tasks = normalizeTasks(loaded.tasks); + if (loaded.exists && !loaded.corrupted) persistTasks(); + if (!initialized && !loaded.exists) { + tasks = normalizeTasks(seedTasks); + persistTasks(); + markInitialized(); + } + sortOrders = { ...DEFAULT_SORT_ORDERS, ...normalizeSortOrders(loadSortOrdersData()) }; + showHidden = Object.fromEntries( + HIDEABLE_STATUSES.map((status) => [status, loadShowHiddenData(status)]), + ); +} +export const wasCorrupted = () => corrupted; +export const getTasks = () => tasks.map((task) => structuredClone(task)); +export const getTask = (id) => { + const task = tasks.find((item) => item.id === id); + return task ? structuredClone(task) : null; +}; +export const getSortOrders = () => ({ ...sortOrders }); +export const getShowHidden = (status) => showHidden[status] === true; +export function addTask(task) { + const normalized = normalizeTask(task); + const ids = new Set(tasks.map((item) => item.id)); + if (ids.has(normalized.id)) normalized.id = generateUniqueId(ids); + tasks.push(normalized); + persistTasks(); + return structuredClone(normalized); +} +export function updateTask(id, changes) { + const index = tasks.findIndex((task) => task.id === id); + if (index < 0) return null; + tasks[index] = normalizeTask({ ...tasks[index], ...changes, id }); + persistTasks(); + return structuredClone(tasks[index]); +} +export function removeTask(id) { + const before = tasks.length; + tasks = tasks.filter((task) => task.id !== id); + if (tasks.length !== before) persistTasks(); + return tasks.length !== before; +} +export function togglePin(id) { + const task = tasks.find((item) => item.id === id); + if (!task) return null; + task.isPinned = !task.isPinned; + persistTasks(); + return structuredClone(task); +} +export function toggleHidden(id) { + const task = tasks.find((item) => item.id === id); + if (!task) return null; + task.isHidden = !task.isHidden; + persistTasks(); + return structuredClone(task); +} +export function setSortOrder(status, value) { + if (!STATUSES.includes(status) || !SORT_VALUES.has(value)) return false; + sortOrders[status] = value; + saveSortOrdersData(sortOrders); + return true; +} +export function setShowHidden(status, value) { + if (!HIDEABLE_STATUSES.includes(status) || typeof value !== 'boolean') return false; + showHidden[status] = value; + saveShowHiddenData(status, value); + return true; +} +export function replaceTasks(value) { + tasks = normalizeTasks(value); + persistTasks(); +} +export function appendTasks(value) { + const ids = new Set(tasks.map((task) => task.id)); + const additions = normalizeTasks(value).map((task) => { + if (ids.has(task.id)) task.id = generateUniqueId(ids); + else ids.add(task.id); + return task; + }); + tasks = [...tasks, ...additions]; + persistTasks(); + return additions.map((task) => structuredClone(task)); +} +export function replaceSortOrders(value) { + sortOrders = { ...sortOrders, ...normalizeSortOrders(value) }; + saveSortOrdersData(sortOrders); +} diff --git a/src/js/task-model.js b/src/js/task-model.js new file mode 100644 index 0000000..770f76d --- /dev/null +++ b/src/js/task-model.js @@ -0,0 +1,56 @@ +import { LANGUAGES, PRIORITIES, SORT_VALUES, STATUSES } from './config.js'; +import { generateId, generateUniqueId, isValidId } from './utils.js'; + +const TIMELINE_TYPES = ['manual-entry', 'status-change', 'progress-update', 'progressNotesUpdated']; +export function normalizeTask(input) { + const task = input && typeof input === 'object' ? { ...input } : {}; + task.title = String(task.title ?? '').trim(); + task.description = String(task.description ?? ''); + task.progressNotes = String(task.progressNotes ?? ''); + task.assignee = String(task.assignee ?? ''); + task.dueDate = typeof task.dueDate === 'string' ? task.dueDate : ''; + task.createdDate = + task.createdDate && !Number.isNaN(Date.parse(task.createdDate)) + ? task.createdDate + : new Date().toISOString(); + task.status = STATUSES.includes(task.status) ? task.status : 'todo'; + task.priority = PRIORITIES.includes(task.priority) ? task.priority : 'medium'; + task.language = LANGUAGES.includes(task.language) ? task.language : 'zh'; + task.progress = Math.min(100, Math.max(0, Number.parseInt(task.progress, 10) || 0)); + task.collaborators = Array.isArray(task.collaborators) ? task.collaborators.map(String) : []; + task.isPinned = task.isPinned === true; + task.isHidden = task.isHidden === true; + task.id = isValidId(task.id) ? task.id : generateId(); + const timelineIds = new Set(); + task.timeline = (Array.isArray(task.timeline) ? task.timeline : []) + .filter((item) => item && typeof item === 'object' && !Array.isArray(item)) + .map((item) => { + let id = isValidId(item.id) ? item.id : generateId(); + while (timelineIds.has(id)) id = generateId(); + timelineIds.add(id); + return { ...item, id, type: TIMELINE_TYPES.includes(item.type) ? item.type : 'manual-entry' }; + }); + return task; +} +export function normalizeTasks(items) { + if (!Array.isArray(items)) return []; + const ids = new Set(); + return items + .filter((item) => item && typeof item === 'object') + .map((item) => { + const task = normalizeTask(item); + if (ids.has(task.id)) task.id = generateUniqueId(ids); + else ids.add(task.id); + return task; + }); +} +export function normalizeSortOrders(value) { + if (!value || typeof value !== 'object' || Array.isArray(value)) return {}; + return Object.fromEntries( + STATUSES.filter((status) => SORT_VALUES.has(value[status])).map((status) => [ + status, + value[status], + ]), + ); +} +export { isValidId } from './utils.js'; diff --git a/src/js/timeline.js b/src/js/timeline.js new file mode 100644 index 0000000..b6640d7 --- /dev/null +++ b/src/js/timeline.js @@ -0,0 +1,63 @@ +import { t } from './i18n/index.js'; +import { getTask, updateTask } from './store.js'; +import { formatLocalDate, generateUniqueId } from './utils.js'; + +export function addSystemEntries(task, changes) { + const timeline = [...task.timeline]; + const fields = [ + ['progressNotes', 'progressNotesUpdated', 'progressNotesUpdated', (a, b) => ({ value: b })], + ['status', 'status-change', 'statusChanged', (a, b) => ({ from: a, to: b })], + ['progress', 'progress-update', 'progressUpdated', (a, b) => ({ from: a, to: b })], + ['assignee', 'status-change', 'assigneeChanged', (a, b) => ({ from: a, to: b })], + ['dueDate', 'status-change', 'dueDateChanged', (a, b) => ({ from: a, to: b })], + ['priority', 'status-change', 'priorityChanged', (a, b) => ({ from: a, to: b })], + ]; + const used = new Set(timeline.map((item) => item.id)); + fields.forEach(([field, type, key, values]) => { + if (Object.hasOwn(changes, field) && task[field] !== changes[field]) + timeline.push({ + id: generateUniqueId(used), + date: formatLocalDate(), + type, + content: '', + event: { key, values: values(task[field], changes[field]) }, + userType: 'system', + }); + }); + return timeline; +} +export function addTimelineEntry(taskId, content) { + const task = getTask(taskId); + if (!task || !content.trim()) return false; + const id = generateUniqueId(new Set(task.timeline.map((item) => item.id))); + task.timeline.push({ + id, + date: formatLocalDate(), + type: 'manual-entry', + content: content.trim(), + user: task.assignee || t('defaultUser'), + }); + updateTask(taskId, { timeline: task.timeline }); + return true; +} +export function updateTimelineEntry(taskId, timelineId, content) { + const task = getTask(taskId); + const item = task?.timeline.find((entry) => entry.id === timelineId); + if (!item || !content.trim()) return false; + const wasSystem = item.userType === 'system'; + item.content = content.trim(); + item.type = 'manual-entry'; + if (wasSystem || !item.user) item.user = task.assignee || t('defaultUser'); + delete item.event; + delete item.userType; + updateTask(taskId, { timeline: task.timeline }); + return true; +} +export function deleteTimelineEntry(taskId, timelineId) { + const task = getTask(taskId); + if (!task) return false; + const timeline = task.timeline.filter((item) => item.id !== timelineId); + if (timeline.length === task.timeline.length) return false; + updateTask(taskId, { timeline }); + return true; +} diff --git a/src/js/utils.js b/src/js/utils.js new file mode 100644 index 0000000..9b6449a --- /dev/null +++ b/src/js/utils.js @@ -0,0 +1,43 @@ +import { DUE_SOON_DAYS, HIDEABLE_STATUSES } from './config.js'; + +// Only todo and completed tasks can be hidden, so the flag is inert in any other column. +export const isHiddenTask = (task) => + task.isHidden === true && HIDEABLE_STATUSES.includes(task.status); + +let idCounter = 0; +export const generateId = () => Date.now() * 1000 + (idCounter++ % 1000); +export function generateUniqueId(usedIds) { + let id = generateId(); + while (usedIds.has(id)) id = generateId(); + usedIds.add(id); + return id; +} +export const isValidId = (value) => Number.isSafeInteger(value) && value > 0; +export function escapeHtml(value) { + return String(value ?? '') + .replaceAll('&', '&') + .replaceAll('<', '<') + .replaceAll('>', '>') + .replaceAll('"', '"') + .replaceAll("'", '''); +} +export function formatLocalDate(date = new Date()) { + return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`; +} +export function parseDueDateEnd(value) { + const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value ?? ''); + if (!match) return null; + const [, y, m, d] = match.map(Number); + const date = new Date(y, m - 1, d, 23, 59, 59, 999); + return date.getFullYear() === y && date.getMonth() === m - 1 && date.getDate() === d + ? date + : null; +} +export function getDueDateState(value, now = new Date()) { + const dueEnd = parseDueDateEnd(value); + if (!dueEnd) return { isOverdue: false, isDueSoon: false }; + const soonEnd = new Date(now); + soonEnd.setDate(soonEnd.getDate() + DUE_SOON_DAYS); + soonEnd.setHours(23, 59, 59, 999); + return { isOverdue: dueEnd < now, isDueSoon: dueEnd >= now && dueEnd <= soonEnd }; +} diff --git a/task.md b/task.md new file mode 100644 index 0000000..8b3c6ad --- /dev/null +++ b/task.md @@ -0,0 +1,41 @@ + +### 待办 +- 1、打印任务功能 +- 2、任务中英文切换 +- 3、记录创建日期，用于 Completed 分类中的排序 + + +### 进行中 + +- V1.0 #1、拆分成 html、cs、js +- V1.0 #2、将Json文件 改名为backup-tasks-yyyy-mm-dd.json + + +### 已完成 + +### V1.0 + +```yaml + +``` + +### V0.3 + +```yaml +- 1、【待办事项】添加隐藏任务功能 +``` + +### V0.2 + +```yaml +- 1、数据保存到本地。Json 文件格式 +- 2、去除按钮 【检测到期按钮提醒】，保留刷新时自动检测 +- 3、已完成栏，可以隐藏任务功能 +``` + +### V0.1 + +```yaml +- 1、时间轴的内容可以编辑，修改，添加 +- 2、添加软件图标 +``` diff --git a/test/backup-tasks-v1.json b/test/backup-tasks-v1.json new file mode 100644 index 0000000..e3eb483 --- /dev/null +++ b/test/backup-tasks-v1.json @@ -0,0 +1,57 @@ +{ + "version": "1.0", + "exportDate": "2025-01-10T08:00:00.000Z", + "localDate": "2025-01-10", + "taskCount": 2, + "data": { + "tasks": [ + { + "id": 101, + "title": "Legacy todo", + "description": "Created by the pre-refactor app", + "progressNotes": "Existing progress", + "status": "todo", + "progress": 25, + "assignee": "Alice", + "collaborators": ["Bob"], + "dueDate": "2025-02-01", + "createdDate": "2025-01-01T08:00:00.000Z", + "language": "en", + "priority": "high", + "isPinned": true, + "isHidden": false, + "timeline": [ + { + "id": 1001, + "date": "2025-01-01", + "type": "manual-entry", + "content": "Legacy timeline entry", + "user": "Alice" + } + ] + }, + { + "id": 102, + "title": "Legacy completed", + "description": "", + "progressNotes": "", + "status": "completed", + "progress": 100, + "assignee": "", + "collaborators": [], + "dueDate": "", + "createdDate": "2025-01-02T08:00:00.000Z", + "language": "zh", + "priority": "low", + "isPinned": false, + "isHidden": true, + "timeline": [] + } + ], + "sortOrders": { + "todo": "priority-desc", + "inProgress": "created-asc", + "completed": "title-asc" + } + } +} diff --git a/test/core.test.js b/test/core.test.js new file mode 100644 index 0000000..bff40f0 --- /dev/null +++ b/test/core.test.js @@ -0,0 +1,505 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import legacyBackup from './backup-tasks-v1.json' with { type: 'json' }; +import { HIDEABLE_STATUSES, STATUSES } from '../src/js/config.js'; +import { t } from '../src/js/i18n/index.js'; +import { normalizeTask, normalizeTasks } from '../src/js/task-model.js'; +import { sortTasks } from '../src/js/sort.js'; +import { getDueDateState } from '../src/js/utils.js'; +import { applySearchFilter, renderColumn, updateTaskCounts } from '../src/js/render.js'; +import { addSystemEntries, addTimelineEntry, updateTimelineEntry } from '../src/js/timeline.js'; +import { + executeImport, + exportData, + mergeTasks, + readImportFile, + validateImportData, +} from '../src/js/import-export.js'; +import { + consumeStorageWriteFailure, + isInitialized, + loadShowHiddenData, + loadSortOrdersData, + loadTasksData, +} from '../src/js/storage.js'; +import { + addTask, + appendTasks, + getShowHidden, + getSortOrders, + getTasks, + initializeStore, + setShowHidden, + setSortOrder, + updateTask, +} from '../src/js/store.js'; +import { createSeedTasks } from '../src/js/seed-data.js'; + +const base = (id, title, extra = {}) => ({ + id, + title, + status: 'todo', + priority: 'medium', + progress: 20, + createdDate: `2025-01-${String(id).padStart(2, '0')}T00:00:00Z`, + dueDate: `2025-01-${String(id).padStart(2, '0')}`, + timeline: [], + ...extra, +}); + +beforeEach(() => localStorage.clear()); +afterEach(() => vi.restoreAllMocks()); + +describe('task model', () => { + it('normalizes fields and language whitelist', () => { + const task = normalizeTask({ + id: 1, + title: ' x ', + language: 'fr', + progress: 999, + status: 'bad', + }); + expect(task).toMatchObject({ title: 'x', language: 'zh', progress: 100, status: 'todo' }); + expect(normalizeTask({ id: 2, title: 'English', language: 'en' }).language).toBe('en'); + }); + it('deduplicates task and timeline ids', () => { + const tasks = normalizeTasks([ + base(1, 'a', { timeline: [{ id: 5 }, { id: 5 }] }), + base(1, 'b'), + ]); + expect(new Set(tasks.map((task) => task.id)).size).toBe(2); + expect(new Set(tasks[0].timeline.map((item) => item.id)).size).toBe(2); + }); + it('drops non-object timeline entries from legacy data', () => { + const task = normalizeTask({ + ...base(1, 'dirty timeline'), + timeline: ['oops', 42, true, null, [], { id: 7, content: 'valid' }], + }); + expect(task.timeline).toEqual([{ id: 7, content: 'valid', type: 'manual-entry' }]); + }); +}); + +describe('all 13 sorts', () => { + const tasks = [ + base(1, 'Beta 10', { + priority: 'medium', + progress: 50, + dueDate: '2025-03-02', + createdDate: '2025-01-02T00:00:00Z', + }), + base(2, 'Alpha 2', { + priority: 'high', + progress: 90, + dueDate: '2025-03-03', + createdDate: '2025-01-03T00:00:00Z', + }), + base(3, 'Gamma 1', { + priority: 'low', + progress: 10, + dueDate: '2025-03-01', + createdDate: '2025-01-01T00:00:00Z', + }), + ]; + const expected = { + default: [2, 1, 3], + 'title-asc': [2, 1, 3], + 'title-desc': [3, 1, 2], + 'number-asc': [3, 2, 1], + 'number-desc': [1, 2, 3], + 'dueDate-asc': [3, 1, 2], + 'dueDate-desc': [2, 1, 3], + 'priority-asc': [3, 1, 2], + 'priority-desc': [2, 1, 3], + 'progress-asc': [3, 1, 2], + 'progress-desc': [2, 1, 3], + 'created-asc': [3, 1, 2], + 'created-desc': [2, 1, 3], + }; + it.each(Object.entries(expected))('sorts %s in the expected order', (order, ids) => { + const copy = structuredClone(tasks); + expect(sortTasks(tasks, order).map((task) => task.id)).toEqual(ids); + expect(tasks).toEqual(copy); + }); + it('keeps pinned first for every sort', () => { + const pinned = { ...tasks[2], isPinned: true }; + Object.keys(expected).forEach((order) => + expect(sortTasks([tasks[0], tasks[1], pinned], order)[0].id).toBe(3), + ); + }); + it('keeps hidden todo tasks last but leaves hidden in-progress tasks in place', () => { + const hiddenTodo = { ...tasks[1], isHidden: true }; + expect(sortTasks([hiddenTodo, tasks[0]], 'title-asc').map((task) => task.id)).toEqual([1, 2]); + const hiddenWork = { ...tasks[1], status: 'inProgress', isHidden: true }; + expect(sortTasks([hiddenWork, tasks[0]], 'title-asc').map((task) => task.id)).toEqual([2, 1]); + }); + it('keeps tasks without due dates last in both directions', () => { + const dated = base(1, 'Dated'); + const undated = { ...base(2, 'Undated'), dueDate: '' }; + expect(sortTasks([undated, dated], 'dueDate-asc').map((task) => task.id)).toEqual([1, 2]); + expect(sortTasks([undated, dated], 'dueDate-desc').map((task) => task.id)).toEqual([1, 2]); + }); +}); + +describe('due dates', () => { + const now = new Date(2025, 0, 10, 12); + it('detects overdue and due-soon boundaries', () => { + expect(getDueDateState('2025-01-09', now)).toEqual({ isOverdue: true, isDueSoon: false }); + expect(getDueDateState('2025-01-10', now)).toEqual({ isOverdue: false, isDueSoon: true }); + expect(getDueDateState('2025-01-13', now).isDueSoon).toBe(true); + expect(getDueDateState('2025-01-14', now).isDueSoon).toBe(false); + }); + it('ignores empty and invalid dates', () => { + expect(getDueDateState('', now)).toEqual({ isOverdue: false, isDueSoon: false }); + expect(getDueDateState('2025-02-30', now)).toEqual({ isOverdue: false, isDueSoon: false }); + }); +}); + +describe('seed data', () => { + it('creates five unique tasks at the initialization time', () => { + const now = new Date('2026-07-19T02:54:00.000Z'); + const tasks = createSeedTasks(now); + expect(tasks).toHaveLength(5); + expect(new Set(tasks.map((task) => task.id)).size).toBe(5); + expect(tasks.every((task) => task.createdDate === now.toISOString())).toBe(true); + }); +}); + +describe('storage and store compatibility', () => { + it('distinguishes a missing task key from an intentionally empty task list', () => { + expect(loadTasksData()).toMatchObject({ tasks: [], corrupted: false, exists: false }); + localStorage.setItem('tasks', '[]'); + expect(loadTasksData()).toMatchObject({ tasks: [], corrupted: false, exists: true }); + }); + it('preserves corrupted raw data without replacing it with seed tasks', () => { + localStorage.setItem('tasks', '{broken'); + initializeStore([base(1, 'Seed')], false); + expect(getTasks()).toEqual([]); + expect(localStorage.getItem('tasks')).toBe('{broken'); + expect(localStorage.getItem('tasksCorruptedBackup')).toBe('{broken'); + }); + it('restores all legacy preferences and task fields', () => { + localStorage.setItem('tasks', JSON.stringify(legacyBackup.data.tasks)); + localStorage.setItem('taskSortOrders', JSON.stringify(legacyBackup.data.sortOrders)); + localStorage.setItem('showHiddenCompletedTasks', 'true'); + localStorage.setItem('showHiddenTodoTasks', 'false'); + localStorage.setItem('tasksInitialized', 'true'); + localStorage.setItem('tasksCorruptedBackup', '{historical backup'); + initializeStore([], isInitialized()); + expect(getTasks()).toMatchObject(legacyBackup.data.tasks); + expect(getSortOrders()).toEqual(legacyBackup.data.sortOrders); + expect(getShowHidden('completed')).toBe(true); + expect(getShowHidden('todo')).toBe(false); + expect(loadSortOrdersData()).toEqual(legacyBackup.data.sortOrders); + expect(loadShowHiddenData('completed')).toBe(true); + expect(localStorage.getItem('tasksCorruptedBackup')).toBe('{historical backup'); + }); + it('maintains store ids and rejects invalid preference mutations', () => { + initializeStore([], true); + const first = addTask(base(1, 'First')); + const duplicate = addTask(base(1, 'Second')); + const [appended] = appendTasks([base(first.id, 'Third')]); + expect(new Set([first.id, duplicate.id, appended.id]).size).toBe(3); + expect(setSortOrder('invalid', 'title-asc')).toBe(false); + expect(setSortOrder('todo', 'invalid')).toBe(false); + expect(setShowHidden('inProgress', true)).toBe(false); + expect(localStorage.getItem('undefined')).toBeNull(); + }); + it('degrades safely when storage access throws', () => { + const getItem = vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => { + throw new DOMException('blocked', 'SecurityError'); + }); + expect(loadTasksData()).toMatchObject({ tasks: [], exists: false, available: false }); + expect(isInitialized()).toBe(false); + getItem.mockRestore(); + vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => { + throw new DOMException('full', 'QuotaExceededError'); + }); + expect(() => initializeStore([base(1, 'Seed')], false)).not.toThrow(); + expect(consumeStorageWriteFailure()).toBe(true); + expect(consumeStorageWriteFailure()).toBe(false); + }); +}); + +describe('imports', () => { + function loadPending(data) { + const original = globalThis.FileReader; + class FakeReader { + readAsText() { + this.result = JSON.stringify(data); + this.onload(); + } + } + globalThis.FileReader = FakeReader; + readImportFile({}, vi.fn(), vi.fn(), vi.fn()); + globalThis.FileReader = original; + } + beforeEach(() => { + globalThis.bootstrap = { + Modal: { getOrCreateInstance: () => ({ hide: vi.fn(), show: vi.fn() }) }, + }; + document.body.innerHTML = ''; + initializeStore([], true); + }); + it('validates the legacy export fixture', () => { + expect(validateImportData(legacyBackup)).toBe(true); + expect(validateImportData({ version: '1.0', data: { tasks: [] } })).toBe(true); + }); + it('rejects unsupported versions, invalid task shapes, and dates', () => { + expect(validateImportData(null)).toBe(false); + expect(validateImportData({ version: '2.0', data: { tasks: [] } })).toBe(false); + expect(validateImportData({ version: '1.0', data: { tasks: 'bad' } })).toBe(false); + expect( + validateImportData({ + version: '1.0', + data: { tasks: [{ id: 1, title: '', status: 'todo' }] }, + }), + ).toBe(false); + expect( + validateImportData({ + version: '1.0', + data: { tasks: [{ ...base(1, 'Bad date'), dueDate: '2025-02-30' }] }, + }), + ).toBe(false); + }); + it('deduplicates merge key and preserves missing dates', () => { + const existing = [base(1, 'Same')]; + const result = mergeTasks(existing, [ + base(2, 'Same', { createdDate: existing[0].createdDate }), + { ...base(3, 'Same'), createdDate: undefined }, + ]); + expect(result.skipped).toBe(1); + expect(result.tasks).toHaveLength(2); + expect(new Set(result.tasks.map((task) => task.id)).size).toBe(2); + }); + it('executes replacement import with legacy tasks and sort orders', () => { + addTask(base(1, 'Existing')); + loadPending(legacyBackup); + expect(executeImport('replace')).toBe(0); + expect(getTasks()).toMatchObject(legacyBackup.data.tasks); + expect(getSortOrders()).toEqual(legacyBackup.data.sortOrders); + }); + it('executes merge import and reports duplicates', () => { + const existing = legacyBackup.data.tasks[0]; + addTask(existing); + loadPending(legacyBackup); + expect(executeImport('merge')).toBe(1); + expect(getTasks()).toHaveLength(2); + }); + it('rejects an invalid import mode', () => { + loadPending(legacyBackup); + expect(() => executeImport('unexpected')).toThrow(TypeError); + }); + it('clears a previous pending import when a newly selected file is invalid', () => { + loadPending(legacyBackup); + loadPending({ version: '1.0', data: { tasks: 'invalid' } }); + expect(() => executeImport('replace')).toThrow('No import pending'); + }); +}); + +describe('timeline entries', () => { + beforeEach(() => initializeStore([], true)); + + it('ignores fields that the change set omits', () => { + const task = addTask(base(1, 'Untouched', { assignee: 'Ada', dueDate: '2025-01-01' })); + expect(addSystemEntries(task, { progress: task.progress })).toEqual([]); + }); + + it('records only the fields that actually changed', () => { + const task = addTask(base(1, 'Changed')); + const timeline = addSystemEntries(task, { progress: 80, status: task.status }); + expect(timeline).toHaveLength(1); + expect(timeline[0].event).toEqual({ key: 'progressUpdated', values: { from: 20, to: 80 } }); + }); + + it('turns an edited system entry into a manual entry owned by the assignee', () => { + const task = addTask(base(1, 'Edited', { assignee: 'Ada' })); + const timeline = addSystemEntries(task, { progress: 80 }); + updateTask(task.id, { timeline }); + expect(updateTimelineEntry(task.id, timeline[0].id, ' my own words ')).toBe(true); + const [stored] = getTasks(); + expect(stored.timeline[0]).toMatchObject({ + type: 'manual-entry', + content: 'my own words', + user: 'Ada', + }); + expect(stored.timeline[0].userType).toBeUndefined(); + expect(stored.timeline[0].event).toBeUndefined(); + }); + + it('keeps the original author when an existing manual entry is edited', () => { + const task = addTask(base(1, 'Reassigned', { assignee: 'Ada' })); + updateTask(task.id, { + timeline: [ + { id: 11, date: '2025-01-01', content: 'by bob', type: 'manual-entry', user: 'Bob' }, + ], + }); + expect(updateTimelineEntry(task.id, 11, ' typo fixed ')).toBe(true); + expect(getTasks()[0].timeline[0]).toMatchObject({ user: 'Bob', content: 'typo fixed' }); + }); +}); + +describe('board rendering', () => { + const fixture = () => + '