todo.list

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { type Todo, type TodoDraft, validateDraft } from "./todo_item.ts";  ← from todo.item ^1.0.0 · built alongside by fune
import { trimSpace } from "./todo_item_validate_draft.ts";
import { isUtcTimestamp } from "./todo_item_validate_todo.ts";
import { normaliseTags } from "./todo_normalise_tags.ts";  ← from todo.normalise-tags ^1.0.0 · built alongside by fune

/** Refuse a clock reading that would not compare as a string with the stored ones. */
export function requireUtcNow(now: string): void {
  if (!isUtcTimestamp(now)) throw new RangeError("now must be a UTC timestamp like 2026-09-28T09:30:00Z");
}

/**
 * The draft as it will be stored: title and notes trimmed (ASCII only, as
 * todo.item does), blank notes as null, tags in normal form. Then checked with
 * validateDraft; the first field in field order that fails is the error, so
 * the message names what to fix first.
 */
export function checkedDraft(draft: TodoDraft): TodoDraft {
  const notes = draft.notes === null || draft.notes === undefined ? "" : trimSpace(draft.notes);
  const clean: TodoDraft = {
    title: trimSpace(draft.title),
    notes: notes === "" ? null : notes,
    priority: draft.priority,
    due: draft.due ?? null,
    tags: normaliseTags(draft.tags),
    recurrence: draft.recurrence ?? null,
  };
  const verdict = validateDraft(clean);
  const first = Object.entries(verdict.errors)[0];
  if (first !== undefined) throw new RangeError(`invalid todo: ${first[0]}: ${first[1]}`);
  return clean;
}

/**
 * Add a todo from the add form. The id and the time are the app's: a pure
 * function cannot mint either. The new todo is open, created now, last in
 * manual order (one past the highest order in the list), and appended.
 * Caller mistakes (id, clock) are reported before form mistakes (the draft).
 */
export function addTodo(todos: readonly Todo[], draft: TodoDraft, id: string, now: string): readonly Todo[] {
  if (trimSpace(id).length === 0) throw new RangeError("a todo needs an id");
  if (todos.some((t) => t.id === id)) throw new RangeError(`a todo with id "${id}" already exists`);
  requireUtcNow(now);
  const clean = checkedDraft(draft);
  let order = 0;
  for (const t of todos) if (t.order + 1 > order) order = t.order + 1;
  const todo: Todo = {
    id,
    title: clean.title,
    notes: clean.notes,
    done: false,
    priority: clean.priority,
    due: clean.due,
    tags: clean.tags,
    recurrence: clean.recurrence,
    createdAt: now,
    completedAt: null,
    order,
  };
  return [...todos, todo];
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { type Todo, type TodoDraft } from "./todo_item.ts";  ← from todo.item ^1.0.0 · built alongside by fune
import { checkedDraft } from "./todo_list_add_todo.ts";  ← addTodo, another function of this group · built into the same file, even by a slim install

/** The position of the todo with this id, or the unknown-id error every list operation shares. */
export function indexOfTodo(todos: readonly Todo[], id: string): number {
  const at = todos.findIndex((t) => t.id === id);
  if (at < 0) throw new RangeError(`no todo with id "${id}"`);
  return at;
}

/**
 * Save the edit form: the draft's fields replace the todo's, normalised and
 * checked exactly as addTodo does. The todo keeps its id, done state,
 * timestamps, order and place in the list.
 */
export function updateTodo(todos: readonly Todo[], id: string, draft: TodoDraft): readonly Todo[] {
  const at = indexOfTodo(todos, id);
  const clean = checkedDraft(draft);
  return todos.map((t, i) =>
    i !== at
      ? t
      : {
          ...t,
          title: clean.title,
          notes: clean.notes,
          priority: clean.priority,
          due: clean.due,
          tags: clean.tags,
          recurrence: clean.recurrence,
        },
  );
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { type Todo } from "./todo_item.ts";  ← from todo.item ^1.0.0 · built alongside by fune
import { isIsoDate } from "./todo_item_validate_draft.ts";
import { nextOccurrence } from "./todo_next_occurrence.ts";  ← from todo.next-occurrence ^1.0.0 · built alongside by fune
import { requireUtcNow } from "./todo_list_add_todo.ts";  ← addTodo, another function of this group · built into the same file, even by a slim install
import { indexOfTodo } from "./todo_list_update_todo.ts";  ← updateTodo, another function of this group · built into the same file, even by a slim install

/** Refuse a today that is not a real YYYY-MM-DD date, whether or not a repeat needs it. */
export function requireToday(today: string): void {
  if (!isIsoDate(today)) throw new RangeError("today must be a date like 2026-09-28");
}

/**
 * Complete one open todo. A one-off is done at `now`. A repeating one stays
 * open and rolls forward to its next occurrence after both its due date and
 * today (todo.next-occurrence), the way Todoist completes a recurring task:
 * no second id to mint, and no duplicate series if a copy were reopened.
 */
export function completeTodo(todo: Todo, now: string, today: string): Todo {
  const rule = todo.recurrence ?? null;
  if (rule === null) return { ...todo, done: true, completedAt: now };
  if (todo.due === null || todo.due === undefined) {
    throw new RangeError(`repeating todo "${todo.id}" has no due date`);
  }
  return { ...todo, done: false, completedAt: null, due: nextOccurrence(rule, todo.due, today) };
}

/** Tick or untick one todo. Reopening clears the completion time. */
export function toggleTodo(todos: readonly Todo[], id: string, now: string, today: string): readonly Todo[] {
  const at = indexOfTodo(todos, id);
  requireUtcNow(now);
  requireToday(today);
  return todos.map((t, i) => {
    if (i !== at) return t;
    return t.done ? { ...t, done: false, completedAt: null } : completeTodo(t, now, today);
  });
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { type Todo } from "./todo_item.ts";  ← from todo.item ^1.0.0 · built alongside by fune
import { indexOfTodo } from "./todo_list_update_todo.ts";  ← updateTodo, another function of this group · built into the same file, even by a slim install

/**
 * Delete one todo. The others keep their order values: a gap is harmless,
 * because manual order sorts by order rather than counting positions.
 */
export function removeTodo(todos: readonly Todo[], id: string): readonly Todo[] {
  const at = indexOfTodo(todos, id);
  return todos.filter((_, i) => i !== at);
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { type Todo } from "./todo_item.ts";  ← from todo.item ^1.0.0 · built alongside by fune

/** The "Clear completed" button: every done todo removed, the rest untouched and in order. */
export function clearCompleted(todos: readonly Todo[]): readonly Todo[] {
  return todos.filter((t) => !t.done);
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { type Todo } from "./todo_item.ts";  ← from todo.item ^1.0.0 · built alongside by fune
import { requireUtcNow } from "./todo_list_add_todo.ts";  ← addTodo, another function of this group · built into the same file, even by a slim install
import { completeTodo, requireToday } from "./todo_list_toggle_todo.ts";  ← toggleTodo, another function of this group · built into the same file, even by a slim install

/**
 * The "mark all" checkbox. While anything is open it completes every open
 * todo exactly as toggleTodo would (repeating ones roll forward and stay
 * open); once everything is done it reopens everything.
 */
export function toggleAll(todos: readonly Todo[], now: string, today: string): readonly Todo[] {
  requireUtcNow(now);
  requireToday(today);
  if (todos.some((t) => !t.done)) {
    return todos.map((t) => (t.done ? t : completeTodo(t, now, today)));
  }
  return todos.map((t) => ({ ...t, done: false, completedAt: null }));
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { type Todo } from "./todo_item.ts";  ← from todo.item ^1.0.0 · built alongside by fune
import { indexOfTodo } from "./todo_list_update_todo.ts";  ← updateTodo, another function of this group · built into the same file, even by a slim install

/**
 * Drag and drop. The list is put in manual order (order ascending, ties by
 * position in the array, which need not already be sorted), the todo is
 * taken out and put back so it ends up at toIndex, and every order is
 * renumbered 0 to n-1. The result is returned in that manual order.
 */
export function moveTodo(todos: readonly Todo[], id: string, toIndex: number): readonly Todo[] {
  const from = indexOfTodo(todos, id);
  const last = todos.length - 1;
  if (!Number.isInteger(toIndex) || toIndex < 0 || toIndex > last) {
    throw new RangeError(`toIndex must be between 0 and ${last}, received ${toIndex}`);
  }
  const positions = todos.map((_, i) => i).sort((a, b) => todos[a].order - todos[b].order || a - b);
  const rest = positions.filter((i) => i !== from);
  rest.splice(toIndex, 0, from);
  return rest.map((i, order) => ({ ...todos[i], order }));
}