@jjlmoya/utils-books 1.7.0 → 1.8.0

package/src/tool/book-reading-time-deadline-planner/component.astro

@@ -0,0 +1,91 @@
+---
+import { calculateReadingPlan, getDefaultInputs } from './logic';
+import { createTimelineMarkup } from './dom-views';
+import type { BookReadingUI } from './ui';
+
+interface Props {
+  ui: BookReadingUI;
+}
+
+const { ui } = Astro.props as Props;
+const initialInputs = getDefaultInputs();
+const initialCalculation = calculateReadingPlan(initialInputs);
+
+function formatInitialDuration(minutes: number): string {
+  const hours = Math.floor(minutes / 60);
+  const remaining = Math.round(minutes % 60);
+  if (hours === 0) return `${remaining} ${ui.minuteShortLabel}`;
+  if (remaining === 0) return `${hours} ${ui.hourShortLabel}`;
+  return `${hours} ${ui.hourShortLabel} ${remaining} ${ui.minuteShortLabel}`;
+}
+
+function formatInitialDate(value: string): string {
+  return new Intl.DateTimeFormat('en-US', { month: 'short', day: 'numeric' }).format(new Date(`${value}T00:00:00Z`));
+}
+
+const initialPace = `${initialCalculation.dailyPace} ${ui.pagesModeLabel}`;
+const initialSession = `${initialCalculation.sessionTarget} ${ui.pagesModeLabel}`;
+const initialBuffer = `${initialCalculation.catchUpSessions} ${ui.bufferExtraLabel}`;
+const initialEstimatedWords = `${initialCalculation.estimatedWords?.toLocaleString('en-US') || 0} ${ui.wordsShortLabel}`;
+---
+
+<div class="n-tool" data-tool="book-reading-time-deadline-planner">
+  <script is:inline type="application/json" data-ui set:html={JSON.stringify(ui)}></script>
+  <div class="n-setup">
+    <div class="n-setup-head"><span class="n-eyebrow">{ui.setupLabel}</span><span class="n-bookmark" aria-hidden="true">+</span></div>
+    <div class="n-field-grid">
+      <div class="n-field n-select n-field-wide" data-select="mode" data-open="false">
+        <span>{ui.modeLabel}</span>
+        <button class="n-select-trigger" type="button" data-select-trigger aria-haspopup="listbox">{ui.pagesModeLabel}</button>
+        <div class="n-select-menu" data-select-menu role="listbox" hidden>
+          <button type="button" data-select-option data-value="pages" role="option">{ui.pagesModeLabel}</button>
+          <button type="button" data-select-option data-value="words" role="option">{ui.wordsModeLabel}</button>
+        </div>
+      </div>
+      <label class="n-field n-field-wide"><span>{ui.amountLabel} <small data-amount-label>{ui.pagesModeLabel}</small></span><input data-field="amount" type="number" inputmode="numeric" min="1" max="10000000" step="1" value={initialInputs.amount} /></label>
+      <label class="n-field"><span>{ui.speedLabel}</span><input data-field="speed" type="number" inputmode="decimal" min="1" max="5000" step="1" value={initialInputs.speed} /><small data-speed-label>{ui.pagesPerHourLabel}</small></label>
+      <label class="n-field"><span>{ui.difficultyLabel}</span><select data-field="difficultyFactor"><option value="1.2">{ui.difficultyLightLabel}</option><option value="1" selected>{ui.difficultyStandardLabel}</option><option value="0.8">{ui.difficultyDenseLabel}</option></select></label>
+      <label class="n-field" data-pages-only><span>{ui.wordsPerPageLabel}</span><input data-field="wordsPerPage" type="number" inputmode="numeric" min="100" max="500" step="25" value={initialInputs.wordsPerPage} /><small>{ui.wordsPerPageHint}</small></label>
+      <label class="n-field"><span>{ui.sessionMinutesLabel}</span><input data-field="sessionMinutes" type="number" inputmode="numeric" min="5" max="240" step="5" value={initialInputs.sessionMinutes} /><small>{ui.minutesRangeLabel}</small></label>
+      <label class="n-field"><span>{ui.sessionsPerDayLabel}</span><input data-field="sessionsPerDay" type="number" inputmode="numeric" min="1" max="8" step="1" value={initialInputs.sessionsPerDay} /></label>
+      <label class="n-field"><span>{ui.daysPerWeekLabel}</span><input data-field="daysPerWeek" type="number" inputmode="numeric" min="1" max="7" step="1" value={initialInputs.daysPerWeek} /></label>
+      <label class="n-field"><span>{ui.startDateLabel}</span><input data-field="startDate" type="date" value={initialInputs.startDate} /></label>
+      <label class="n-field"><span>{ui.deadlineLabel}</span><input data-field="deadline" type="date" value={initialInputs.deadline} /></label>
+    </div>
+    <div class="n-speed-test">
+      <div class="n-panel-label"><span>{ui.speedTestLabel}</span><span>{ui.speedTestHint}</span></div>
+      <label class="n-field"><span>{ui.speedTestPromptLabel}</span><textarea data-speed-test-text rows="3" placeholder={ui.speedTestPlaceholder}></textarea></label>
+      <div class="n-speed-test-actions"><button type="button" data-speed-test-action>{ui.speedTestStartLabel}</button></div>
+      <p class="n-speed-test-status" data-speed-test-status aria-live="polite">{ui.speedTestIdle}</p>
+      <div class="n-speed-test-result"><span>{ui.speedTestElapsedLabel}</span><strong data-speed-test-elapsed>0.0 {ui.speedTestSecondsLabel}</strong><span>{ui.speedTestRateLabel}</span><strong data-speed-test-rate>-</strong><button type="button" data-speed-test-use hidden>{ui.speedTestUseLabel}</button></div>
+    </div>
+    <div class="n-presets"><span>{ui.presetLabel}</span><div><button type="button" data-preset="steady">{ui.presetSteadyLabel}</button><button type="button" data-preset="weekend">{ui.presetWeekendLabel}</button><button type="button" data-preset="academic">{ui.presetAcademicLabel}</button></div></div>
+  </div>
+  <div class="n-plan" aria-label={ui.planLabel} aria-live="polite">
+    <div class="n-status" data-status="tight"><span class="n-status-dot" aria-hidden="true"></span><div><strong data-status-title>{ui.statusTight}</strong><p data-status-detail>{ui.statusTightDetail}</p></div></div>
+    <div class="n-output-grid">
+      <div class="n-output-card"><span>{ui.timeNeededLabel}</span><strong data-output="time">{formatInitialDuration(initialCalculation.minutesNeeded)}</strong></div>
+      <div class="n-output-card"><span>{ui.readingDaysLabel}</span><strong data-output="days">{initialCalculation.readingDaysNeeded}</strong></div>
+      <div class="n-output-card"><span>{ui.capacityLabel}</span><strong data-output="capacity">{initialCalculation.availableReadingDays}</strong></div>
+      <div class="n-output-card"><span>{ui.dailyPaceLabel}</span><strong data-output="pace">{initialPace}</strong></div>
+      <div class="n-output-card" data-pages-output><span>{ui.estimatedWordsLabel}</span><strong data-output="estimatedWords">{initialEstimatedWords}</strong></div>
+      <div class="n-output-card"><span>{ui.sessionTargetLabel}</span><strong data-output="session">{initialSession}</strong></div>
+      <div class="n-output-card"><span>{ui.catchUpLabel}</span><strong data-output="catchUp">{initialBuffer}</strong></div>
+      <div class="n-output-card n-output-wide"><span>{ui.finishDateLabel}</span><strong data-output="finish">{formatInitialDate(initialCalculation.finishDate)}</strong></div>
+    </div>
+    <div class="n-timeline-panel"><div class="n-panel-label"><span>{ui.milestoneLabel}</span><span>{ui.timelineLabel}</span></div><div data-timeline set:html={createTimelineMarkup(initialCalculation, ui)}></div><p>{ui.calendarHint}</p><button class="n-export-calendar" type="button" data-export-ics>{ui.exportCalendarLabel}</button></div>
+    <p class="n-source">{ui.sourceLabel}</p>
+  </div>
+</div>
+
+<script>
+  import { initBookReadingPlanner } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-tool="book-reading-time-deadline-planner"]');
+  const data = root?.querySelector<HTMLScriptElement>('[data-ui]');
+  if (root && data) initBookReadingPlanner(root, JSON.parse(data.textContent || '{}'));
+</script>
+
+<style>
+  @import url('./book-reading-time-deadline-planner.css');
+</style>

package/src/tool/book-reading-time-deadline-planner/controller.ts

@@ -0,0 +1,253 @@
+import { calculateReadingPlan, getDefaultInputs, type BookReadingInputs, type ReadingMode } from './logic';
+import { createMilestoneIcs } from './calendar';
+import { renderReadingPlan } from './dom-views';
+import { loadBookReadingState, saveBookReadingState } from './storage';
+import { calculateWordsPerMinute, countReadingWords } from './speed-test';
+import type { BookReadingUI } from './ui';
+
+interface ReadingState {
+  inputs: BookReadingInputs;
+}
+
+export function initBookReadingPlanner(root: HTMLElement, ui: BookReadingUI): void {
+  const defaultInputs = getDefaultInputs();
+  const stored = loadBookReadingState({ inputs: defaultInputs });
+  const state: ReadingState = { inputs: { ...defaultInputs, ...stored.inputs } };
+  bindModeSelect(root, state, ui);
+  bindInputs(root, state, ui);
+  bindPresets(root, state, ui);
+  bindSpeedTest(root, state, ui);
+  bindCalendarExport(root, state, ui);
+  updateView(root, state, ui);
+}
+
+function bindInputs(root: HTMLElement, state: ReadingState, ui: BookReadingUI): void {
+  root.querySelectorAll<HTMLInputElement | HTMLSelectElement>('[data-field]').forEach((input) => {
+    const eventName = input instanceof HTMLSelectElement ? 'change' : 'input';
+    input.addEventListener(eventName, () => {
+      const field = input.dataset.field as keyof BookReadingInputs;
+      const isNumeric = input instanceof HTMLSelectElement || input.type === 'number';
+      state.inputs[field] = (isNumeric ? Number(input.value) : input.value) as never;
+      updateView(root, state, ui);
+    });
+  });
+}
+
+function bindModeSelect(root: HTMLElement, state: ReadingState, ui: BookReadingUI): void {
+  const select = root.querySelector<HTMLElement>('[data-select="mode"]');
+  const trigger = select?.querySelector<HTMLButtonElement>('[data-select-trigger]');
+  const menu = select?.querySelector<HTMLElement>('[data-select-menu]');
+  if (!select || !trigger || !menu) return;
+  trigger.addEventListener('click', () => {
+    const isOpen = select.dataset.open === 'true';
+    closeModeSelect(select, menu);
+    if (!isOpen) {
+      select.dataset.open = 'true';
+      menu.hidden = false;
+    }
+  });
+  select.querySelectorAll<HTMLButtonElement>('[data-select-option]').forEach((option) => {
+    option.addEventListener('click', () => {
+      const nextMode = option.dataset.value as ReadingMode;
+      adaptModeDefaults(state.inputs, nextMode);
+      closeModeSelect(select, menu);
+      updateView(root, state, ui);
+    });
+  });
+  document.addEventListener('click', (event) => {
+    if (!(event.target instanceof Node) || !root.contains(event.target)) closeModeSelect(select, menu);
+  });
+}
+
+function adaptModeDefaults(inputs: BookReadingInputs, nextMode: ReadingMode): void {
+  if (inputs.mode === nextMode) return;
+  const previousDefaults = inputs.mode === 'pages' ? { amount: 320, speed: 35 } : { amount: 60000, speed: 250 };
+  const nextDefaults = nextMode === 'pages' ? { amount: 320, speed: 35 } : { amount: 60000, speed: 250 };
+  if (inputs.amount === previousDefaults.amount) inputs.amount = nextDefaults.amount;
+  if (inputs.speed === previousDefaults.speed) inputs.speed = nextDefaults.speed;
+  inputs.mode = nextMode;
+}
+
+function bindPresets(root: HTMLElement, state: ReadingState, ui: BookReadingUI): void {
+  const presets: Record<string, { inputs: Partial<BookReadingInputs> }> = {
+    steady: { inputs: { sessionMinutes: 30, sessionsPerDay: 1, daysPerWeek: 5 } },
+    weekend: { inputs: { sessionMinutes: 45, sessionsPerDay: 2, daysPerWeek: 2 } },
+    academic: { inputs: { mode: 'words', amount: 60000, speed: 250, sessionMinutes: 45, sessionsPerDay: 2, daysPerWeek: 6 } },
+  };
+  root.querySelectorAll<HTMLButtonElement>('[data-preset]').forEach((button) => {
+    button.addEventListener('click', () => {
+      const preset = presets[button.dataset.preset || ''];
+      if (!preset) return;
+      state.inputs = { ...state.inputs, ...preset.inputs };
+      updateView(root, state, ui);
+    });
+  });
+}
+
+function bindSpeedTest(root: HTMLElement, state: ReadingState, ui: BookReadingUI): void {
+  const elements = getSpeedTestElements(root);
+  if (!elements) return;
+  const speedState: SpeedTestState = { startedAt: 0, timer: undefined, measuredRate: 0 };
+  elements.action.addEventListener('click', () => {
+    if (speedState.startedAt) finishSpeedTest(elements, speedState, ui);
+    else startSpeedTest(elements, speedState, ui);
+  });
+  elements.useResult.addEventListener('click', () => applySpeedTest({ elements, speedState, state, root, ui }));
+}
+
+function bindCalendarExport(root: HTMLElement, state: ReadingState, ui: BookReadingUI): void {
+  const button = root.querySelector<HTMLButtonElement>('[data-export-ics]');
+  if (!button) return;
+  button.addEventListener('click', () => downloadMilestones(state, ui));
+}
+
+function downloadMilestones(state: ReadingState, ui: BookReadingUI): void {
+  clampNumericInputs(state.inputs);
+  const calculation = calculateReadingPlan(state.inputs);
+  const ics = createMilestoneIcs(calculation, ui.exportCalendarTitle, {
+    start: ui.milestoneStart,
+    quarter: ui.milestoneQuarter,
+    half: ui.milestoneHalf,
+    threeQuarter: ui.milestoneThreeQuarter,
+    finish: ui.milestoneFinish,
+  });
+  const link = document.createElement('a');
+  const url = URL.createObjectURL(new Blob([ics], { type: 'text/calendar;charset=utf-8' }));
+  link.href = url;
+  link.download = `reading-milestones-${calculation.startDate}.ics`;
+  document.body.append(link);
+  link.click();
+  link.remove();
+  window.setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+
+interface SpeedTestElements {
+  text: HTMLTextAreaElement;
+  action: HTMLButtonElement;
+  useResult: HTMLButtonElement;
+  status: HTMLElement;
+  elapsed: HTMLElement;
+  rate: HTMLElement;
+}
+
+interface SpeedTestState {
+  startedAt: number;
+  timer: ReturnType<typeof setInterval> | undefined;
+  measuredRate: number;
+}
+
+function getSpeedTestElements(root: HTMLElement): SpeedTestElements | null {
+  const elements = {
+    text: root.querySelector<HTMLTextAreaElement>('[data-speed-test-text]'),
+    action: root.querySelector<HTMLButtonElement>('[data-speed-test-action]'),
+    useResult: root.querySelector<HTMLButtonElement>('[data-speed-test-use]'),
+    status: root.querySelector<HTMLElement>('[data-speed-test-status]'),
+    elapsed: root.querySelector<HTMLElement>('[data-speed-test-elapsed]'),
+    rate: root.querySelector<HTMLElement>('[data-speed-test-rate]'),
+  };
+  if (Object.values(elements).some((element) => !element)) return null;
+  return elements as SpeedTestElements;
+}
+
+function startSpeedTest(elements: SpeedTestElements, speedState: SpeedTestState, ui: BookReadingUI): void {
+  if (!countReadingWords(elements.text.value)) {
+    elements.status.textContent = ui.speedTestNeedsText;
+    elements.text.focus();
+    return;
+  }
+  speedState.startedAt = Date.now();
+  speedState.measuredRate = 0;
+  elements.elapsed.textContent = formatSeconds(0, ui);
+  elements.rate.textContent = '-';
+  elements.useResult.hidden = true;
+  elements.action.textContent = ui.speedTestFinishLabel;
+  elements.action.classList.add('is-running');
+  elements.status.textContent = ui.speedTestRunning;
+  speedState.timer = setInterval(() => updateSpeedTestElapsed(elements, speedState, ui), 250);
+}
+
+function updateSpeedTestElapsed(elements: SpeedTestElements, speedState: SpeedTestState, ui: BookReadingUI): void {
+  if (speedState.startedAt) {
+    elements.elapsed.textContent = formatSeconds((Date.now() - speedState.startedAt) / 1000, ui);
+  }
+}
+
+function finishSpeedTest(elements: SpeedTestElements, speedState: SpeedTestState, ui: BookReadingUI): void {
+  if (!speedState.startedAt) return;
+  const seconds = Math.max(0.1, (Date.now() - speedState.startedAt) / 1000);
+  speedState.measuredRate = calculateWordsPerMinute(countReadingWords(elements.text.value), seconds);
+  elements.elapsed.textContent = formatSeconds(seconds, ui);
+  elements.rate.textContent = speedState.measuredRate ? `${speedState.measuredRate} ${ui.speedTestWpmLabel}` : ui.speedTestNoWords;
+  elements.status.textContent = ui.speedTestFinished;
+  elements.useResult.hidden = !speedState.measuredRate;
+  elements.action.textContent = ui.speedTestStartLabel;
+  elements.action.classList.remove('is-running');
+  clearInterval(speedState.timer);
+  speedState.timer = undefined;
+  speedState.startedAt = 0;
+}
+
+interface SpeedTestContext {
+  elements: SpeedTestElements;
+  speedState: SpeedTestState;
+  state: ReadingState;
+  root: HTMLElement;
+  ui: BookReadingUI;
+}
+
+function applySpeedTest(context: SpeedTestContext): void {
+  context.state.inputs.mode = 'words';
+  context.state.inputs.speed = context.speedState.measuredRate;
+  updateView(context.root, context.state, context.ui);
+  context.elements.status.textContent = context.ui.speedTestFinished;
+}
+
+function updateView(root: HTMLElement, state: ReadingState, ui: BookReadingUI): void {
+  clampNumericInputs(state.inputs);
+  const calculation = calculateReadingPlan(state.inputs);
+  updateInputs(root, state.inputs);
+  updateMode(root, state.inputs.mode, ui);
+  renderReadingPlan(root, calculation, ui);
+  saveBookReadingState({ inputs: state.inputs });
+}
+
+function clampNumericInputs(inputs: BookReadingInputs): void {
+  inputs.amount = Math.min(10000000, Math.max(1, Number.isFinite(inputs.amount) ? inputs.amount : 1));
+  const defaultSpeed = inputs.mode === 'words' ? 250 : 35;
+  inputs.speed = Math.min(5000, Math.max(1, Number.isFinite(inputs.speed) ? inputs.speed : defaultSpeed));
+  inputs.sessionMinutes = Math.min(240, Math.max(5, Number.isFinite(inputs.sessionMinutes) ? inputs.sessionMinutes : 30));
+  inputs.sessionsPerDay = Math.min(8, Math.max(1, Math.round(Number.isFinite(inputs.sessionsPerDay) ? inputs.sessionsPerDay : 1)));
+  inputs.daysPerWeek = Math.min(7, Math.max(1, Math.round(Number.isFinite(inputs.daysPerWeek) ? inputs.daysPerWeek : 5)));
+}
+
+function updateInputs(root: HTMLElement, inputs: BookReadingInputs): void {
+  root.querySelectorAll<HTMLInputElement | HTMLSelectElement>('[data-field]').forEach((input) => {
+    const field = input.dataset.field as keyof BookReadingInputs;
+    input.value = String(inputs[field]);
+  });
+}
+
+function updateMode(root: HTMLElement, mode: ReadingMode, ui: BookReadingUI): void {
+  const labels: Record<ReadingMode, string> = { pages: ui.pagesModeLabel, words: ui.wordsModeLabel };
+  const select = root.querySelector<HTMLElement>('[data-select="mode"]');
+  const trigger = select?.querySelector('[data-select-trigger]');
+  if (trigger) trigger.textContent = labels[mode];
+  root.querySelectorAll<HTMLElement>('[data-speed-label]').forEach((label) => {
+    label.textContent = mode === 'pages' ? ui.pagesPerHourLabel : ui.wordsPerMinuteLabel;
+  });
+  root.querySelectorAll<HTMLElement>('[data-amount-label]').forEach((label) => {
+    label.textContent = mode === 'pages' ? ui.pagesModeLabel : ui.wordsModeLabel;
+  });
+  root.querySelectorAll<HTMLElement>('[data-pages-only], [data-pages-output]').forEach((element) => {
+    element.hidden = mode !== 'pages';
+  });
+}
+
+function closeModeSelect(select: HTMLElement, menu: HTMLElement): void {
+  select.dataset.open = 'false';
+  menu.hidden = true;
+}
+
+function formatSeconds(seconds: number, ui: BookReadingUI): string {
+  return `${seconds.toFixed(1)} ${ui.speedTestSecondsLabel}`;
+}

package/src/tool/book-reading-time-deadline-planner/dom-views.ts

@@ -0,0 +1,60 @@
+import type { BookReadingCalculation } from './logic';
+import type { BookReadingUI } from './ui';
+import { evaluateReadingPlan } from './evaluator';
+
+export function createTimelineMarkup(calculation: BookReadingCalculation, ui: BookReadingUI): string {
+  const evaluation = evaluateReadingPlan(calculation);
+  const labels = [ui.milestoneStart, ui.milestoneQuarter, ui.milestoneHalf, ui.milestoneThreeQuarter, ui.milestoneFinish];
+  const points = calculation.milestoneDates.map((date, index) => {
+    const x = 22 + index * 69;
+    return `<g class="n-milestone"><circle cx="${x}" cy="72" r="7" /><text x="${x}" y="52" text-anchor="middle">${labels[index]}</text><text x="${x}" y="101" text-anchor="middle">${formatDate(date)}</text></g>`;
+  }).join('');
+  return `<svg class="n-timeline-svg" viewBox="0 0 320 118" role="img" aria-label="${ui.timelineLabel}"><path class="n-timeline-track" d="M22 72 H298" /><path class="n-timeline-fill n-timeline-fill-${evaluation.status}" d="M22 72 H${calculation.status === 'late' ? 160 : 298}" />${points}</svg>`;
+}
+
+export function renderReadingPlan(root: HTMLElement, calculation: BookReadingCalculation, ui: BookReadingUI): void {
+  const evaluation = evaluateReadingPlan(calculation);
+  root.dataset.status = evaluation.status;
+  const status = root.querySelector<HTMLElement>('.n-status');
+  if (status) status.dataset.status = evaluation.status;
+  const values: Record<string, string> = {
+    time: formatDuration(calculation.minutesNeeded, ui),
+    days: String(calculation.readingDaysNeeded),
+    capacity: String(calculation.availableReadingDays),
+    pace: `${formatNumber(calculation.dailyPace)} ${getModeLabel(calculation.mode, ui)}`,
+    estimatedWords: calculation.estimatedWords === null ? '-' : `${formatNumber(calculation.estimatedWords)} ${ui.wordsShortLabel}`,
+    session: `${formatNumber(calculation.sessionTarget)} ${getModeLabel(calculation.mode, ui)}`,
+    catchUp: calculation.sessionsShort > 0 ? `${calculation.sessionsShort} ${ui.bufferShortLabel}` : `${calculation.catchUpSessions} ${ui.bufferExtraLabel}`,
+    finish: formatDate(calculation.finishDate),
+  };
+  Object.entries(values).forEach(([key, value]) => {
+    const target = root.querySelector(`[data-output="${key}"]`);
+    if (target) target.textContent = value;
+  });
+  const statusTitle = root.querySelector('[data-status-title]');
+  const statusDetail = root.querySelector('[data-status-detail]');
+  if (statusTitle) statusTitle.textContent = ui[evaluation.messageKey];
+  if (statusDetail) statusDetail.textContent = ui[evaluation.detailKey];
+  const timeline = root.querySelector('[data-timeline]');
+  if (timeline) timeline.innerHTML = createTimelineMarkup(calculation, ui);
+}
+
+function formatNumber(value: number): string {
+  return new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 }).format(value);
+}
+
+function formatDuration(minutes: number, ui: BookReadingUI): string {
+  const hours = Math.floor(minutes / 60);
+  const remaining = Math.round(minutes % 60);
+  if (hours === 0) return `${remaining} ${ui.minuteShortLabel}`;
+  if (remaining === 0) return `${hours} ${ui.hourShortLabel}`;
+  return `${hours} ${ui.hourShortLabel} ${remaining} ${ui.minuteShortLabel}`;
+}
+
+function getModeLabel(mode: BookReadingCalculation['mode'], ui: BookReadingUI): string {
+  return mode === 'pages' ? ui.pagesModeLabel : ui.wordsModeLabel;
+}
+
+function formatDate(value: string): string {
+  return new Intl.DateTimeFormat('en-US', { month: 'short', day: 'numeric' }).format(new Date(`${value}T00:00:00Z`));
+}

package/src/tool/book-reading-time-deadline-planner/entry.ts

@@ -0,0 +1,27 @@
+import type { BooksToolEntry, ToolLocaleContent } from '../../types';
+import type { BookReadingUI } from './ui';
+
+export type { BookReadingUI } from './ui';
+export type BookReadingLocaleContent = ToolLocaleContent<BookReadingUI>;
+
+export const bookReadingTimeDeadlinePlanner: BooksToolEntry<BookReadingUI> = {
+  id: 'book-reading-time-deadline-planner',
+  icons: { bg: 'mdi:book-clock-outline', fg: 'mdi:calendar-check-outline' },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/book-reading-time-deadline-planner/evaluator.ts

@@ -0,0 +1,17 @@
+import type { BookReadingCalculation, ReadingStatus } from './logic';
+
+export interface ReadingEvaluation {
+  status: ReadingStatus;
+  messageKey: 'statusOnTrack' | 'statusTight' | 'statusLate' | 'statusInvalid';
+  detailKey: 'statusOnTrackDetail' | 'statusTightDetail' | 'statusLateDetail' | 'statusInvalidDetail';
+}
+
+export function evaluateReadingPlan(calculation: BookReadingCalculation): ReadingEvaluation {
+  const keys: Record<ReadingStatus, { messageKey: ReadingEvaluation['messageKey']; detailKey: ReadingEvaluation['detailKey'] }> = {
+    'on-track': { messageKey: 'statusOnTrack', detailKey: 'statusOnTrackDetail' },
+    tight: { messageKey: 'statusTight', detailKey: 'statusTightDetail' },
+    late: { messageKey: 'statusLate', detailKey: 'statusLateDetail' },
+    invalid: { messageKey: 'statusInvalid', detailKey: 'statusInvalidDetail' },
+  };
+  return { status: calculation.status, ...keys[calculation.status] };
+}

package/src/tool/book-reading-time-deadline-planner/i18n/de.ts

@@ -0,0 +1,45 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { BookReadingUI } from '../ui';
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+
+const ui: BookReadingUI = {
+  setupLabel: 'Leseplan erstellen', modeLabel: 'Zaehlen nach', pagesModeLabel: 'Seiten', wordsModeLabel: 'Woerter', amountLabel: 'Gesamtumfang', speedLabel: 'Deine Lesegeschwindigkeit', difficultyLabel: 'Textschwierigkeit', difficultyLightLabel: 'Leicht · 1.2x', difficultyStandardLabel: 'Standard · 1.0x', difficultyDenseLabel: 'Dicht · 0.8x', wordsPerPageLabel: 'Geschaetzte Woerter pro Seite', wordsPerPageHint: 'Typischer Bereich: 100 bis 500', pagesPerHourLabel: 'Seiten pro Stunde', wordsPerMinuteLabel: 'Woerter pro Minute', startDateLabel: 'Startdatum', deadlineLabel: 'Deadline', daysPerWeekLabel: 'Lesetage pro Woche', sessionsPerDayLabel: 'Sitzungen pro Lesetag', sessionMinutesLabel: 'Minuten pro Sitzung', minutesRangeLabel: '5 bis 240 Min.', hourShortLabel: 'Std.', minuteShortLabel: 'Min.', bufferShortLabel: 'zu wenig', bufferExtraLabel: 'zusaetzlich', speedTestLabel: 'Lesegeschwindigkeit messen', speedTestHint: 'Verwende einen kurzen, passenden Text', speedTestPromptLabel: 'Zu lesender Text', speedTestPlaceholder: 'Fuege hier einen Satz oder kurzen Text ein ...', speedTestStartLabel: 'Timer starten', speedTestFinishLabel: 'Fertig gelesen', speedTestElapsedLabel: 'Vergangen', speedTestRateLabel: 'Geschaetztes Tempo', speedTestSecondsLabel: 'Sek.', speedTestWpmLabel: 'WPM', speedTestUseLabel: 'Diese WPM im Woertermodus verwenden', speedTestIdle: 'Gib einen Text ein und starte den Timer, wenn du bereit bist.', speedTestRunning: 'Timer laeuft. Lies in deinem natuerlichen Tempo.', speedTestFinished: 'Test beendet. Dies ist eine erste Schaetzung, kein Richtwert.', speedTestNeedsText: 'Fuege vor dem Start einen Text ein.', speedTestNoWords: 'Keine Woerter gemessen', presetLabel: 'Schneller Rhythmus', presetSteadyLabel: 'Gleichmaessige Woche', presetWeekendLabel: 'Wochenendfokus', presetAcademicLabel: 'Lernintensiv', planLabel: 'Deine Lesekarte', timeNeededLabel: 'Benoetigte Zeit', readingDaysLabel: 'Benoetigte Lesetage', capacityLabel: 'Verfuegbare Lesetage', dailyPaceLabel: 'Tempo bis zur Deadline', estimatedWordsLabel: 'Geschaetzte Woerter', wordsShortLabel: 'Woerter', sessionTargetLabel: 'Ziel pro Sitzung', catchUpLabel: 'Aufholpuffer', finishDateLabel: 'Voraussichtliches Ende', milestoneLabel: 'Meilensteine', timelineLabel: 'Zeitplan der Lesemeilensteine', calendarHint: 'Meilensteine sind Planungsmarken. Verschiebe die Deadline oder passe deinen Rhythmus an, wenn das echte Leben dazwischenkommt.', exportCalendarLabel: 'Meilensteine herunterladen (.ics)', exportCalendarTitle: 'Lesemeilensteine', milestoneStart: 'Start', milestoneQuarter: '25 %', milestoneHalf: 'Haelfte', milestoneThreeQuarter: '75 %', milestoneFinish: 'Ende', statusOnTrack: 'Luft im Plan', statusTight: 'Knapp passend', statusLate: 'Nach der Deadline', statusInvalid: 'Daten pruefen', statusOnTrackDetail: 'Deine verfuegbaren Sitzungen lassen Puffer fuer ausgefallene Tage oder ein langsameres Kapitel.', statusTightDetail: 'Der Plan passt, hat aber wenig Reserve. Halte eine Sitzung flexibel zum Aufholen.', statusLateDetail: 'Der aktuelle Rhythmus reicht nicht bis zur Deadline. Fuege Sitzungen hinzu, verlaengere den Zeitraum oder reduziere das Ziel.', statusInvalidDetail: 'Waehle ein gueltiges Startdatum und eine Deadline am oder nach dem Startdatum.', sourceLabel: 'Dies ist eine Schaetzung des Tempos, keine Zusage fuer Verstaendnis und keine feste Lesegeschwindigkeit. Miss dein eigenes Tempo an einem passenden Text.',
+};
+
+const faq = [
+  { question: 'Wie waehle ich meine Lesegeschwindigkeit?', answer: 'Stoppe die Zeit fuer einen passenden Text, zaehle Seiten oder Woerter und verwende das beobachtete Tempo. Dichte, technische, unbekannte oder stark kommentierte Buecher brauchen meist mehr Zeit.' },
+  { question: 'Garantiert der Plan, dass ich das Buch verstehe?', answer: 'Nein. Er macht aus deinem Tempo und deinem Zeitplan eine Kalender-Schaetzung. Lesefluss und Verstaendnis sind nicht dasselbe, also lies bei anspruchsvollen Stellen langsamer.' },
+  { question: 'Was bedeutet der Aufholpuffer?', answer: 'Er zeigt die Sitzungen, die nach dem Einplanen der geschaetzten Lesezeit bis zur Deadline uebrig bleiben. Ein negativer Wert bedeutet, dass die Kapazitaet des Rhythmus nicht ausreicht.' },
+  { question: 'Warum kann ich nach Seiten oder Woertern planen?', answer: 'Seiten sind praktisch fuer gedruckte Buecher, Woerter besser vergleichbar bei digitalen Texten oder Aufgaben. Waehle die Einheit, die du konsequent verfolgen kannst.' },
+];
+
+const howTo = [
+  { name: 'Einheit waehlen', text: 'Zaehle das Buch nach Seiten oder Woertern und trage den Gesamtumfang ein.' },
+  { name: 'Eigenes Tempo messen', text: 'Verwende ein persoenlich gemessenes Tempo statt eines allgemeinen Versprechens zum Schnelllesen.' },
+  { name: 'Wochenrhythmus festlegen', text: 'Setze Minuten pro Sitzung, Sitzungen pro Lesetag und Lesetage pro Woche.' },
+  { name: 'Deadline pruefen', text: 'Sieh dir Ende, Tagestempo und Meilensteine an und reserviere den Puffer fuer echte Unterbrechungen.' },
+];
+
+const seo: ToolLocaleContent<BookReadingUI>['seo'] = [
+  { type: 'title', text: 'Lesetempo und Buchdeadline planen', level: 2 },
+  { type: 'paragraph', html: 'Verwandle ein Seiten- oder Woerterziel in einen realistischen Leseplan. Trage Umfang, gemessenes Tempo, Sitzungsdauer, Haeufigkeit und dein Wunschdatum ein.' },
+  { type: 'title', text: 'Mit dem eigenen Lesetempo planen', level: 2 },
+  { type: 'paragraph', html: 'Eine persoenliche Zeitprobe ist nuetzlicher als ein allgemeines Versprechen zum Schnelllesen. Miss einen passenden Abschnitt und senke das Tempo bei dichtem, unbekanntem oder gruendlich zu bearbeitendem Text.' },
+  { type: 'list', items: ['Waehle Seiten fuer ein gedrucktes Buch oder Woerter fuer digitale Texte.', 'Miss einen passenden Abschnitt und verwende ein Tempo, das du mit ausreichendem Verstaendnis halten kannst.', 'Lege Sitzungsdauer, Sitzungen pro Lesetag und Lesetage pro Woche fest.', 'Nutze den Aufholpuffer fuer ausgefallene Tage statt jede Sitzung als Pflicht zu behandeln.', 'Vergleiche den Plan nach den ersten Sitzungen mit deinem tatsaechlichen Fortschritt.'] },
+  { type: 'title', text: 'Die Deadline-Karte lesen', level: 2 },
+  { type: 'paragraph', html: 'Die benoetigte Zeit ist der Aufwand bei deinem gewaehlten Tempo. Benoetigte Lesetage uebersetzen ihn in Sitzungen. Verfuegbare Lesetage schaetzen die Kapazitaet zwischen Start und Deadline anhand deiner Lesetage pro Woche.' },
+  { type: 'table', headers: ['Ausgabe', 'Bedeutung'], rows: [['Tempo bis zur Deadline', 'Umfang fuer jeden verfuegbaren Lesetag'], ['Ziel pro Sitzung', 'Umfang fuer eine geplante Sitzung'], ['Aufholpuffer', 'Uebrige Sitzungen nach dem Einpassen des Aufwands'], ['Voraussichtliches Ende', 'Enddatum bei konstantem Wochenrhythmus']] },
+  { type: 'tip', title: 'Ein Kalender ist kein Verstaendnis', html: 'Der Plan misst weder Verstaendnis noch Schwierigkeit, Ermuedung, Wiederholungen oder Unterbrechungen. Nutze ihn als erste Zusage und aktualisiere ihn mit deinem echten Tempo.' },
+  { type: 'title', text: 'Wenn der Plan knapp oder zu spaet ist', level: 2 },
+  { type: 'paragraph', html: 'Luft im Plan bedeutet Reserve. Ein knapp passender Plan braucht mindestens eine flexible Aufholsitzung. Liegt das Ende nach der Deadline, verlaengere den Zeitraum, fuege Sitzungen hinzu, erhoehe die Lesetage oder reduziere den Umfang.' },
+  { type: 'tip', title: 'Vor dem Optimieren messen', html: 'Vergleiche nach zwei oder drei Sitzungen dein geplantes und dein echtes Ergebnis. Wenn der Unterschied bleibt, aendere das Tempo statt den Kalender gegen ein zu optimistisches Ziel zu zwingen.' },
+];
+
+const schemas: [WithContext<SoftwareApplication>, WithContext<FAQPage>, WithContext<HowTo>] = [
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Lesetempo und Buchdeadline planen', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Eine Lesefrist planen', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+];
+
+export const content: ToolLocaleContent<BookReadingUI> = { slug: 'buch-lesezeit-und-frist-planer', title: 'Lesetempo und Buchdeadline planen', description: 'Plane Lesetempo, Sitzungsrhythmus und Enddatum für dein Seiten- oder Wörterziel. Berücksichtige die Schwierigkeit, damit dein Kalender zu deinem echten Lesealltag passt.', ui, seo, faq, bibliography, howTo, schemas: schemas as unknown as Record<string, unknown>[] };

package/src/tool/book-reading-time-deadline-planner/i18n/en.ts

@@ -0,0 +1,51 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { BookReadingUI } from '../ui';
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+
+const ui: BookReadingUI = {
+  setupLabel: 'Build your reading plan', modeLabel: 'Count by', pagesModeLabel: 'Pages', wordsModeLabel: 'Words', amountLabel: 'Total to read', speedLabel: 'Your reading speed', difficultyLabel: 'Text difficulty', difficultyLightLabel: 'Light · 1.2×', difficultyStandardLabel: 'Standard · 1.0×', difficultyDenseLabel: 'Dense · 0.8×', wordsPerPageLabel: 'Estimated words per page', wordsPerPageHint: 'Typical range: 100 to 500', pagesPerHourLabel: 'pages per hour', wordsPerMinuteLabel: 'words per minute', startDateLabel: 'Start date', deadlineLabel: 'Deadline', daysPerWeekLabel: 'Reading days per week', sessionsPerDayLabel: 'Sessions per reading day', sessionMinutesLabel: 'Minutes per session', minutesRangeLabel: '5 to 240 min', hourShortLabel: 'h', minuteShortLabel: 'min', bufferShortLabel: 'short', bufferExtraLabel: 'extra', speedTestLabel: 'Measure your reading speed', speedTestHint: 'Use a short representative passage', speedTestPromptLabel: 'Passage to read', speedTestPlaceholder: 'Paste or type a sentence or short passage here...', speedTestStartLabel: 'Start timer', speedTestFinishLabel: 'I finished', speedTestElapsedLabel: 'Elapsed', speedTestRateLabel: 'Estimated pace', speedTestSecondsLabel: 'sec', speedTestWpmLabel: 'WPM', speedTestUseLabel: 'Use this WPM in Words mode', speedTestIdle: 'Enter a passage, then start when you are ready.', speedTestRunning: 'Timer running. Read at your natural pace.', speedTestFinished: 'Test complete. Treat this as a first estimate, not a benchmark.', speedTestNeedsText: 'Add a passage before starting the timer.', speedTestNoWords: 'No words measured', presetLabel: 'Quick rhythm', presetSteadyLabel: 'Steady week', presetWeekendLabel: 'Weekend focus', presetAcademicLabel: 'Academic sprint', planLabel: 'Your reading map', timeNeededLabel: 'Time needed', readingDaysLabel: 'Reading days needed', capacityLabel: 'Reading days available', dailyPaceLabel: 'Pace by deadline', estimatedWordsLabel: 'Estimated words', wordsShortLabel: 'words', sessionTargetLabel: 'Target per session', catchUpLabel: 'Catch-up buffer', finishDateLabel: 'Projected finish', milestoneLabel: 'Milestones', timelineLabel: 'Reading milestone timeline', calendarHint: 'Milestones are planning markers. Move the deadline or adjust your rhythm when real life interrupts.', exportCalendarLabel: 'Download milestones (.ics)', exportCalendarTitle: 'Reading milestones', milestoneStart: 'Start', milestoneQuarter: '25%', milestoneHalf: 'Half', milestoneThreeQuarter: '75%', milestoneFinish: 'Finish', statusOnTrack: 'Room to breathe', statusTight: 'A close fit', statusLate: 'Past the deadline', statusInvalid: 'Check the dates', statusOnTrackDetail: 'Your available sessions leave a useful buffer for missed days or a slower chapter.', statusTightDetail: 'The plan fits, but there is little spare capacity. Keep one session flexible for catch-up.', statusLateDetail: 'The current rhythm cannot fit before the deadline. Add sessions, extend the date, or reduce the target.', statusInvalidDetail: 'Choose a valid start date and a deadline on or after it.', sourceLabel: 'This is a pacing estimate, not a promise of comprehension or a fixed reading speed. Measure your own rate on a representative passage.',
+};
+
+const faq = [
+  { question: 'How should I choose my reading speed?', answer: 'Time yourself on a representative passage, count its pages or words, and use that observed rate. Dense, technical, unfamiliar or heavily annotated books usually take longer.' },
+  { question: 'Does the planner guarantee that I will understand the book?', answer: 'No. It turns your own pace and schedule into a calendar estimate. Reading fluency and comprehension are related but not interchangeable, so slow down when the text requires close study.' },
+  { question: 'What does the catch-up buffer mean?', answer: 'It is the number of spare sessions left after the estimated reading time is placed inside your deadline. A negative value means the current rhythm is short of the required capacity.' },
+  { question: 'Why can I plan by pages or words?', answer: 'Pages are convenient for a printed book, while words can be more comparable across digital layouts or assigned passages. Choose the measure you can track consistently.' },
+];
+
+const howTo = [
+  { name: 'Choose the reading measure', text: 'Count the book by pages or words, then enter the total amount.' },
+  { name: 'Enter your observed speed', text: 'Use a measured personal pace rather than a generic speed-reading claim.' },
+  { name: 'Shape the weekly rhythm', text: 'Set minutes per session, sessions per reading day and reading days per week.' },
+  { name: 'Set the deadline and inspect the map', text: 'Review the projected finish, pace by deadline and milestone dates, then reserve the buffer for real interruptions.' },
+];
+
+const seo: ToolLocaleContent<BookReadingUI>['seo'] = [
+  { type: 'title', text: 'Plan Your Reading Pace and Book Deadline', level: 2 },
+  { type: 'paragraph', html: 'Turn a page or word target into a realistic reading calendar. Enter the amount you want to finish, your measured reading speed, the length and frequency of sessions, and the date you want to be done.' },
+  { type: 'title', text: 'Use Your Own Reading Rate', level: 2 },
+  { type: 'paragraph', html: 'A personal timed sample is more useful than a universal reading-speed promise. Test a representative passage, keep the unit consistent, and lower the rate when the book is dense, unfamiliar or meant for close study.' },
+  { type: 'list', items: ['Choose Pages for a printed book or Words for a digital or assigned passage.', 'Time a representative sample and enter the rate you can sustain with the understanding you need.', 'Set your real session length, sessions per reading day and reading days per week.', 'Use the catch-up buffer for missed days instead of treating every planned session as mandatory.', 'Recheck the plan after the first few sessions and replace the estimate with your observed pace.'] },
+  { type: 'title', text: 'Read the Deadline Map', level: 2 },
+  { type: 'paragraph', html: 'Time needed is the estimated effort at your chosen rate. Reading days needed turns that effort into sessions at your session length. Available reading days estimates the capacity between your start and deadline from the number of reading days per week, without pretending to know which weekdays you will actually use.' },
+  { type: 'table', headers: ['Output', 'What it tells you'], rows: [['Pace by deadline', 'The amount to cover on each available reading day'], ['Target per session', 'The amount to aim for in one planned session'], ['Catch-up buffer', 'Spare sessions after the estimated work fits'], ['Projected finish', 'The finish date if your weekly rhythm stays constant']] },
+  { type: 'tip', title: 'A calendar is not comprehension', html: 'The planner does not measure understanding, difficulty, fatigue, rereading or interruptions. Use it to make a first commitment, then update it with your real pace and leave room for notes, review and difficult chapters.' },
+  { type: 'title', text: 'When the Plan Is Tight or Late', level: 2 },
+  { type: 'paragraph', html: 'Room to breathe means the estimated sessions fit with spare capacity. A close fit has a small buffer and deserves one flexible catch-up slot. Past the deadline means the configured schedule cannot hold the target, so change one of the levers: extend the deadline, add sessions, add reading days or reduce the amount.' },
+  { type: 'tip', title: 'Measure before you optimise', html: 'After two or three sessions, compare the planned pace with what you actually finished. If the difference persists, edit the speed rather than forcing the schedule to match an optimistic estimate.' },
+];
+
+const schemas: [WithContext<SoftwareApplication>, WithContext<FAQPage>, WithContext<HowTo>] = [
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Book Reading Time Deadline Planner', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } },
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Plan a reading deadline', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+];
+
+export const content: ToolLocaleContent<BookReadingUI> = {
+  slug: 'book-reading-time-deadline-planner',
+  title: 'Book Reading Time Deadline Planner',
+  description: 'Plan a realistic reading pace, session rhythm and finish date from your page or word target.',
+  ui, seo, faq, bibliography, howTo,
+  schemas: schemas as unknown as Record<string, unknown>[],
+};