@jjlmoya/utils-books 1.7.0 → 1.8.0

package/src/tool/book-reading-time-deadline-planner/i18n/ru.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: 'Составьте план чтения', modeLabel: 'Считать по', pagesModeLabel: 'Страницам', wordsModeLabel: 'Словам', amountLabel: 'Всего прочитать', speedLabel: 'Ваша скорость чтения', difficultyLabel: 'Сложность текста', difficultyLightLabel: 'Легкий · 1.2x', difficultyStandardLabel: 'Стандартный · 1.0x', difficultyDenseLabel: 'Плотный · 0.8x', wordsPerPageLabel: 'Примерное число слов на странице', wordsPerPageHint: 'Обычно: от 100 до 500', pagesPerHourLabel: 'страниц в час', wordsPerMinuteLabel: 'слов в минуту', startDateLabel: 'Дата начала', deadlineLabel: 'Срок', daysPerWeekLabel: 'Дней чтения в неделю', sessionsPerDayLabel: 'Сеансов в день чтения', sessionMinutesLabel: 'Минут на сеанс', minutesRangeLabel: 'От 5 до 240 минут', hourShortLabel: 'ч', minuteShortLabel: 'мин', bufferShortLabel: 'не хватает', bufferExtraLabel: 'запас', speedTestLabel: 'Измерьте скорость чтения', speedTestHint: 'Возьмите короткий показательный фрагмент', speedTestPromptLabel: 'Текст для чтения', speedTestPlaceholder: 'Вставьте или введите предложение или короткий фрагмент...', speedTestStartLabel: 'Запустить таймер', speedTestFinishLabel: 'Я закончил', speedTestElapsedLabel: 'Прошло', speedTestRateLabel: 'Расчетный темп', speedTestSecondsLabel: 'с', speedTestWpmLabel: 'СЛМ', speedTestUseLabel: 'Использовать этот темп в режиме Слова', speedTestIdle: 'Введите фрагмент и запустите таймер, когда будете готовы.', speedTestRunning: 'Таймер запущен. Читайте в естественном темпе.', speedTestFinished: 'Тест завершен. Это первая оценка, а не постоянная норма.', speedTestNeedsText: 'Добавьте текст перед запуском таймера.', speedTestNoWords: 'Слова не измерены', presetLabel: 'Быстрый ритм', presetSteadyLabel: 'Ровная неделя', presetWeekendLabel: 'Чтение на выходных', presetAcademicLabel: 'Учебный ритм', planLabel: 'Карта чтения', timeNeededLabel: 'Нужно времени', readingDaysLabel: 'Нужно дней чтения', capacityLabel: 'Доступно дней чтения', dailyPaceLabel: 'Темп до срока', estimatedWordsLabel: 'Примерное число слов', wordsShortLabel: 'слов', sessionTargetLabel: 'Цель на сеанс', catchUpLabel: 'Запас для наверстывания', finishDateLabel: 'Ожидаемая дата окончания', milestoneLabel: 'Этапы', timelineLabel: 'Шкала этапов чтения', calendarHint: 'Этапы служат ориентирами для плана. Перенесите срок или измените ритм, если реальные дела прервут чтение.', exportCalendarLabel: 'Скачать этапы (.ics)', exportCalendarTitle: 'Этапы чтения', milestoneStart: 'Начало', milestoneQuarter: '25%', milestoneHalf: 'Половина', milestoneThreeQuarter: '75%', milestoneFinish: 'Конец', statusOnTrack: 'Есть запас', statusTight: 'Впритык', statusLate: 'После срока', statusInvalid: 'Проверьте даты', statusOnTrackDetail: 'Доступные сеансы оставляют запас на пропущенные дни или медленную главу.', statusTightDetail: 'План помещается, но запас небольшой. Оставьте один гибкий сеанс для наверстывания.', statusLateDetail: 'При текущем ритме цель не помещается до срока. Добавьте сеансы, продлите период или уменьшите цель.', statusInvalidDetail: 'Выберите правильную дату начала и срок не раньше нее.', sourceLabel: 'Это оценка темпа, а не гарантия понимания и не фиксированная скорость чтения. Измерьте свой темп на показательном фрагменте.',
+};
+
+const faq = [
+  { question: 'Как выбрать скорость чтения?', answer: 'Засеките время на показательный фрагмент, посчитайте страницы или слова и используйте полученный темп. Плотные, технические, незнакомые или хорошо аннотированные книги обычно требуют больше времени.' },
+  { question: 'Гарантирует ли план понимание книги?', answer: 'Нет. Он превращает ваш темп и расписание в оценку по календарю. Беглость чтения и понимание не одно и то же, поэтому замедляйтесь там, где нужен подробный разбор.' },
+  { question: 'Что означает запас для наверстывания?', answer: 'Это число сеансов, оставшихся после размещения расчетного времени до срока. Отрицательное значение означает, что текущего ритма недостаточно.' },
+  { question: 'Зачем планировать по страницам или словам?', answer: 'Страницы удобны для печатной книги, а слова проще сравнивать в цифровом тексте или задании. Выберите единицу, которую сможете регулярно отслеживать.' },
+];
+
+const howTo = [
+  { name: 'Выберите единицу чтения', text: 'Посчитайте книгу в страницах или словах и введите общий объем.' },
+  { name: 'Измерьте свой темп', text: 'Используйте измеренную личную скорость, а не общее обещание быстрого чтения.' },
+  { name: 'Настройте недельный ритм', text: 'Задайте минуты на сеанс, число сеансов за день чтения и дни чтения в неделю.' },
+  { name: 'Проверьте срок', text: 'Посмотрите дату окончания, дневной темп и этапы, оставив запас на реальные перерывы.' },
+];
+
+const seo: ToolLocaleContent<BookReadingUI>['seo'] = [
+  { type: 'title', text: 'Спланируйте темп чтения и срок окончания книги', level: 2 },
+  { type: 'paragraph', html: 'Превратите цель в страницах или словах в реалистичный календарь чтения. Укажите объем, измеренную скорость, длительность и частоту сеансов и желаемую дату окончания.' },
+  { type: 'title', text: 'Используйте собственный темп чтения', level: 2 },
+  { type: 'paragraph', html: 'Личная проверка по времени полезнее универсального обещания быстрого чтения. Измерьте показательный фрагмент и снизьте темп, если книга плотная, незнакомая или требует внимательного изучения.' },
+  { type: 'list', items: ['Выберите Страницы для печатной книги или Слова для цифрового текста и задания.', 'Измерьте показательный фрагмент и используйте темп, который сохраняет нужное понимание.', 'Задайте длительность сеансов, число сеансов в день и дни чтения в неделю.', 'Оставьте запас на пропущенные дни, а не превращайте каждый сеанс в обязательство.', 'После первых сеансов сравните план с реальным прогрессом.'] },
+  { type: 'title', text: 'Как читать карту срока', level: 2 },
+  { type: 'paragraph', html: 'Нужное время показывает расчетные усилия при выбранном темпе. Нужные дни чтения переводят их в сеансы. Доступные дни чтения оценивают вместимость между началом и сроком по числу дней чтения в неделю.' },
+  { type: 'table', headers: ['Результат', 'Что он означает'], rows: [['Темп до срока', 'Объем для каждого доступного дня чтения'], ['Цель на сеанс', 'Объем для одного запланированного сеанса'], ['Запас для наверстывания', 'Оставшиеся сеансы после распределения усилий'], ['Ожидаемая дата окончания', 'Дата конца при сохранении недельного ритма']] },
+  { type: 'tip', title: 'Календарь не измеряет понимание', html: 'План не измеряет понимание, сложность, усталость, перечитывание или перерывы. Используйте его как первое обязательство и обновляйте по реальному темпу.' },
+  { type: 'title', text: 'Если план слишком плотный или опаздывает', level: 2 },
+  { type: 'paragraph', html: 'Запас есть, когда расчетные сеансы помещаются с резервом. Для плотного плана оставьте один гибкий сеанс. Если окончание выходит за срок, продлите период, добавьте сеансы или уменьшите цель.' },
+  { type: 'tip', title: 'Сначала измерьте, потом улучшайте', html: 'Через два или три сеанса сравните ожидаемый и реальный прогресс. Если разница сохраняется, измените скорость, а не пытайтесь удержать слишком оптимистичный календарь.' },
+];
+
+const schemas: [WithContext<SoftwareApplication>, WithContext<FAQPage>, WithContext<HowTo>] = [
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Спланируйте темп чтения и срок окончания книги', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'RUB' } },
+  { '@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: 'Спланировать срок чтения', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+];
+
+export const content: ToolLocaleContent<BookReadingUI> = { slug: 'planirovshchik-vremeni-chteniya-i-sroka-knigi', title: 'Спланируйте темп чтения и срок окончания книги', description: 'Рассчитайте реалистичный темп чтения, ритм сеансов и дату окончания по количеству страниц или слов.', ui, seo, faq, bibliography, howTo, schemas: schemas as unknown as Record<string, unknown>[] };

package/src/tool/book-reading-time-deadline-planner/i18n/sv.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: 'Skapa din läsplan', modeLabel: 'Räkna i', pagesModeLabel: 'Sidor', wordsModeLabel: 'Ord', amountLabel: 'Totalt att läsa', speedLabel: 'Din läshastighet', difficultyLabel: 'Textens svårighetsgrad', difficultyLightLabel: 'Lätt · 1.2x', difficultyStandardLabel: 'Standard · 1.0x', difficultyDenseLabel: 'Tät · 0.8x', wordsPerPageLabel: 'Uppskattade ord per sida', wordsPerPageHint: 'Vanligt intervall: 100 till 500', pagesPerHourLabel: 'sidor per timme', wordsPerMinuteLabel: 'ord per minut', startDateLabel: 'Startdatum', deadlineLabel: 'Deadline', daysPerWeekLabel: 'Läsdagar per vecka', sessionsPerDayLabel: 'Sessioner per läsdag', sessionMinutesLabel: 'Minuter per session', minutesRangeLabel: '5 till 240 min', hourShortLabel: 'tim', minuteShortLabel: 'min', bufferShortLabel: 'korta', bufferExtraLabel: 'extra', speedTestLabel: 'Mät din läshastighet', speedTestHint: 'Använd ett kort och representativt stycke', speedTestPromptLabel: 'Text att läsa', speedTestPlaceholder: 'Klistra in eller skriv en mening eller ett kort stycke här...', speedTestStartLabel: 'Starta timer', speedTestFinishLabel: 'Jag är klar', speedTestElapsedLabel: 'Förfluten tid', speedTestRateLabel: 'Uppskattat tempo', speedTestSecondsLabel: 'sek', speedTestWpmLabel: 'OPM', speedTestUseLabel: 'Använd detta OPM i läget Ord', speedTestIdle: 'Skriv in ett stycke och starta när du är redo.', speedTestRunning: 'Timern körs. Läs i ditt naturliga tempo.', speedTestFinished: 'Testet är klart. Detta är en första uppskattning, inte en fast norm.', speedTestNeedsText: 'Lägg till text innan du startar timern.', speedTestNoWords: 'Inga ord mättes', presetLabel: 'Snabb rytm', presetSteadyLabel: 'Jämn vecka', presetWeekendLabel: 'Helgfokus', presetAcademicLabel: 'Studietempo', planLabel: 'Din läskarta', timeNeededLabel: 'Tid som behövs', readingDaysLabel: 'Nödvändiga läsdagar', capacityLabel: 'Tillgängliga läsdagar', dailyPaceLabel: 'Tempo till deadline', estimatedWordsLabel: 'Uppskattade ord', wordsShortLabel: 'ord', sessionTargetLabel: 'Mål per session', catchUpLabel: 'Utrymme för att komma ikapp', finishDateLabel: 'Beräknat slut', milestoneLabel: 'Milstolpar', timelineLabel: 'Tidslinje för läsmilstolpar', calendarHint: 'Milstolparna är planeringspunkter. Flytta deadlinen eller ändra rytmen när verkligheten avbryter planen.', exportCalendarLabel: 'Ladda ner milstolpar (.ics)', exportCalendarTitle: 'Läsmilstolpar', milestoneStart: 'Start', milestoneQuarter: '25%', milestoneHalf: 'Halvvägs', milestoneThreeQuarter: '75%', milestoneFinish: 'Slut', statusOnTrack: 'Det finns marginal', statusTight: 'Precis lagom', statusLate: 'Efter deadline', statusInvalid: 'Kontrollera datumen', statusOnTrackDetail: 'Dina tillgängliga sessioner lämnar marginal för missade dagar eller ett långsammare kapitel.', statusTightDetail: 'Planen går ihop, men marginalen är liten. Spara en flexibel session för att komma ikapp.', statusLateDetail: 'Den nuvarande rytmen räcker inte före deadlinen. Lägg till sessioner, förläng perioden eller minska målet.', statusInvalidDetail: 'Välj ett giltigt startdatum och en deadline på eller efter startdatumet.', sourceLabel: 'Detta är en uppskattning av tempo, inte ett löfte om förståelse eller en fast läshastighet. Mät ditt eget tempo med ett representativt stycke.',
+};
+
+const faq = [
+  { question: 'Hur väljer jag min läshastighet?', answer: 'Ta tiden på ett representativt stycke, räkna sidor eller ord och använd det uppmätta tempot. Täta, tekniska, obekanta eller hårt kommenterade böcker kräver ofta mer tid.' },
+  { question: 'Garanterar planen att jag förstår boken?', answer: 'Nej. Den omvandlar ditt tempo och ditt schema till en kalenderuppskattning. Läsflyt och förståelse är inte samma sak, så sänk tempot när texten kräver noggrann läsning.' },
+  { question: 'Vad betyder utrymme för att komma ikapp?', answer: 'Det är antalet sessioner som återstår när den uppskattade lästiden har placerats före deadlinen. Ett negativt värde betyder att den nuvarande rytmen inte räcker.' },
+  { question: 'Varför kan jag planera i sidor eller ord?', answer: 'Sidor är praktiskt för tryckta böcker, medan ord är lättare att jämföra i digital text eller uppgifter. Välj den enhet du kan följa konsekvent.' },
+];
+
+const howTo = [
+  { name: 'Välj läsenhet', text: 'Räkna boken i sidor eller ord och skriv in totalen.' },
+  { name: 'Mät ditt tempo', text: 'Använd ett personligt uppmätt tempo i stället för ett generellt löfte om snabbläsning.' },
+  { name: 'Ställ in veckorytmen', text: 'Ange minuter per session, sessioner per läsdag och läsdagar per vecka.' },
+  { name: 'Kontrollera deadlinen', text: 'Se det beräknade slutet, dagstempot och milstolparna och spara marginal för verkliga avbrott.' },
+];
+
+const seo: ToolLocaleContent<BookReadingUI>['seo'] = [
+  { type: 'title', text: 'Planera lästempo och deadline för en bok', level: 2 },
+  { type: 'paragraph', html: 'Förvandla ett mål i sidor eller ord till en realistisk läskalender. Ange mängden, din uppmätta hastighet, sessionernas längd och frekvens samt datumet då du vill vara klar.' },
+  { type: 'title', text: 'Använd din egen läshastighet', level: 2 },
+  { type: 'paragraph', html: 'Ett personligt tidstest är mer användbart än ett allmänt löfte om snabbläsning. Testa ett representativt stycke och sänk tempot när boken är tät, obekant eller kräver noggrann läsning.' },
+  { type: 'list', items: ['Välj Sidor för en tryckt bok eller Ord för digital text och uppgifter.', 'Ta tiden på ett representativt stycke och använd ett tempo som du kan hålla med önskad förståelse.', 'Ställ in sessionernas längd, sessioner per dag och läsdagar per vecka.', 'Använd marginalen för missade dagar i stället för att göra varje session obligatorisk.', 'Jämför planen med dina faktiska framsteg efter de första sessionerna.'] },
+  { type: 'title', text: 'Läs deadlinekartan', level: 2 },
+  { type: 'paragraph', html: 'Tid som behövs är den uppskattade arbetsmängden i ditt valda tempo. Nödvändiga läsdagar omvandlar den till sessioner. Tillgängliga läsdagar uppskattar kapaciteten mellan start och deadline utifrån läsdagar per vecka.' },
+  { type: 'table', headers: ['Resultat', 'Vad det visar'], rows: [['Tempo till deadline', 'Mängd för varje tillgänglig läsdag'], ['Mål per session', 'Mängd att sikta på i en planerad session'], ['Utrymme för att komma ikapp', 'Sessioner som återstår efter planeringen'], ['Beräknat slut', 'Slutdatum om veckorytmen förblir konstant']] },
+  { type: 'tip', title: 'En kalender mäter inte förståelse', html: 'Planen mäter inte förståelse, svårighet, trötthet, omläsning eller avbrott. Använd den som ett första åtagande och uppdatera den med ditt verkliga tempo.' },
+  { type: 'title', text: 'När planen är knapp eller för sen', level: 2 },
+  { type: 'paragraph', html: 'Det finns marginal när de uppskattade sessionerna ryms med reserv. En knapp plan behöver en flexibel ikappsession. Om slutet hamnar efter deadlinen kan du förlänga perioden, lägga till sessioner eller minska målet.' },
+  { type: 'tip', title: 'Mät innan du optimerar', html: 'Efter två eller tre sessioner jämför du planerade och faktiska framsteg. Om skillnaden består, ändra hastigheten i stället för att tvinga fram en alltför optimistisk kalender.' },
+];
+
+const schemas: [WithContext<SoftwareApplication>, WithContext<FAQPage>, WithContext<HowTo>] = [
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Planera lästempo och deadline för en bok', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'SEK' } },
+  { '@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: 'Planera en läsdeadline', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+];
+
+export const content: ToolLocaleContent<BookReadingUI> = { slug: 'planerare-for-lasningstid-och-bokdeadline', title: 'Planera lästempo och deadline för en bok', description: 'Planera ett realistiskt lästempo, ett sessionschema och ett slutdatum utifrån ditt mål i sidor eller ord.', ui, seo, faq, bibliography, howTo, schemas: schemas as unknown as Record<string, unknown>[] };

package/src/tool/book-reading-time-deadline-planner/i18n/tr.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: 'Okuma planını oluştur', modeLabel: 'Sayım türü', pagesModeLabel: 'Sayfa', wordsModeLabel: 'Kelime', amountLabel: 'Okunacak toplam', speedLabel: 'Okuma hızınız', difficultyLabel: 'Metin zorluğu', difficultyLightLabel: 'Kolay · 1.2x', difficultyStandardLabel: 'Standart · 1.0x', difficultyDenseLabel: 'Yoğun · 0.8x', wordsPerPageLabel: 'Sayfa başına tahmini kelime', wordsPerPageHint: 'Yaygın aralık: 100 ile 500', pagesPerHourLabel: 'sayfa/saat', wordsPerMinuteLabel: 'kelime/dakika', startDateLabel: 'Başlangıç tarihi', deadlineLabel: 'Son tarih', daysPerWeekLabel: 'Haftalık okuma günü', sessionsPerDayLabel: 'Okuma günü başına oturum', sessionMinutesLabel: 'Oturum süresi', minutesRangeLabel: '5 ile 240 dakika', hourShortLabel: 'sa', minuteShortLabel: 'dk', bufferShortLabel: 'eksik', bufferExtraLabel: 'ekstra', speedTestLabel: 'Okuma hızınızı ölçün', speedTestHint: 'Kısa ve temsilî bir metin kullanın', speedTestPromptLabel: 'Okunacak metin', speedTestPlaceholder: 'Buraya bir cümle veya kısa bir metin yapıştırın ya da yazın...', speedTestStartLabel: 'Sayacı başlat', speedTestFinishLabel: 'Bitirdim', speedTestElapsedLabel: 'Geçen süre', speedTestRateLabel: 'Tahmini tempo', speedTestSecondsLabel: 'sn', speedTestWpmLabel: 'KDM', speedTestUseLabel: 'Bu KDM değerini Kelime modunda kullan', speedTestIdle: 'Bir metin girin ve hazır olduğunuzda başlayın.', speedTestRunning: 'Sayaç çalışıyor. Doğal temponuzda okuyun.', speedTestFinished: 'Test tamamlandı. Bu ilk tahmindir, sabit bir ölçüt değildir.', speedTestNeedsText: 'Sayacı başlatmadan önce bir metin ekleyin.', speedTestNoWords: 'Kelime ölçülmedi', presetLabel: 'Hızlı ritim', presetSteadyLabel: 'Düzenli hafta', presetWeekendLabel: 'Hafta sonu odağı', presetAcademicLabel: 'Çalışma temposu', planLabel: 'Okuma haritanız', timeNeededLabel: 'Gereken süre', readingDaysLabel: 'Gereken okuma günü', capacityLabel: 'Kullanılabilir okuma günü', dailyPaceLabel: 'Son tarihe kadar tempo', estimatedWordsLabel: 'Tahmini kelime', wordsShortLabel: 'kelime', sessionTargetLabel: 'Oturum hedefi', catchUpLabel: 'Telafi payı', finishDateLabel: 'Tahmini bitiş', milestoneLabel: 'Kilometre taşları', timelineLabel: 'Okuma kilometre taşları zaman çizelgesi', calendarHint: 'Kilometre taşları planlama işaretleridir. Gerçek hayat planı böldüğünde son tarihi değiştirin veya temponuzu ayarlayın.', exportCalendarLabel: 'Kilometre taşlarını indir (.ics)', exportCalendarTitle: 'Okuma kilometre taşları', milestoneStart: 'Başlangıç', milestoneQuarter: '25%', milestoneHalf: 'Yarı', milestoneThreeQuarter: '75%', milestoneFinish: 'Bitiş', statusOnTrack: 'Pay var', statusTight: 'Sınırda', statusLate: 'Son tarihten sonra', statusInvalid: 'Tarihleri kontrol edin', statusOnTrackDetail: 'Kullanılabilir oturumlarınız kaçırılan günler veya daha yavaş bir bölüm için pay bırakıyor.', statusTightDetail: 'Plan sığıyor ancak yedek pay az. Telafi için bir oturumu esnek bırakın.', statusLateDetail: 'Mevcut tempo son tarihe kadar yetmiyor. Oturum ekleyin, süreyi uzatın veya hedefi azaltın.', statusInvalidDetail: 'Geçerli bir başlangıç tarihi ve başlangıçtan sonraki bir son tarih seçin.', sourceLabel: 'Bu bir tempo tahminidir; anlama garantisi veya sabit bir okuma hızı değildir. Kendi temponuzu temsilî bir metinle ölçün.',
+};
+
+const faq = [
+  { question: 'Okuma hızımı nasıl seçmeliyim?', answer: 'Temsilî bir metni okuma sürenizi ölçün, sayfa veya kelime sayısını hesaplayın ve gözlenen tempoyu kullanın. Yoğun, teknik, bilinmeyen veya çok açıklamalı kitaplar genellikle daha fazla zaman ister.' },
+  { question: 'Plan kitabı anlayacağımı garanti eder mi?', answer: 'Hayır. Kendi temponuzu ve takviminizi bir tarih tahminine dönüştürür. Akıcı okumak anlamakla aynı değildir; ayrıntılı çalışma gereken yerlerde yavaşlayın.' },
+  { question: 'Telafi payı ne anlama gelir?', answer: 'Tahmini okuma süresini son tarihe yerleştirdikten sonra kalan oturum sayısıdır. Negatif değer, mevcut ritmin yeterli kapasite sunmadığını gösterir.' },
+  { question: 'Neden sayfa veya kelimeyle plan yapabilirim?', answer: 'Basılı kitaplarda sayfalar pratiktir; dijital metinlerde veya ödevlerde kelime sayısı daha kolay karşılaştırılır. Düzenli takip edebileceğiniz birimi seçin.' },
+];
+
+const howTo = [
+  { name: 'Okuma birimini seçin', text: 'Kitabı sayfa veya kelime olarak sayıp toplamı girin.' },
+  { name: 'Kendi temponuzu ölçün', text: 'Genel bir hızlı okuma iddiası yerine ölçtüğünüz kişisel hızı kullanın.' },
+  { name: 'Haftalık ritmi belirleyin', text: 'Oturum süresini, okuma günü başına oturum sayısını ve haftalık okuma günlerini ayarlayın.' },
+  { name: 'Son tarihi inceleyin', text: 'Tahmini bitişi, günlük tempoyu ve kilometre taşlarını kontrol edip gerçek kesintiler için pay bırakın.' },
+];
+
+const seo: ToolLocaleContent<BookReadingUI>['seo'] = [
+  { type: 'title', text: 'Okuma temponuzu ve kitap son tarihinizi planlayın', level: 2 },
+  { type: 'paragraph', html: 'Sayfa veya kelime hedefinizi gerçekçi bir okuma takvimine dönüştürün. Miktarı, ölçtüğünüz okuma hızını, oturumların süresini ve sıklığını ve bitirmek istediğiniz tarihi girin.' },
+  { type: 'title', text: 'Kendi okuma hızınızı kullanın', level: 2 },
+  { type: 'paragraph', html: 'Kişisel bir süre ölçümü, genel hızlı okuma iddialarından daha kullanışlıdır. Temsilî bir metni test edin; kitap yoğunsa, bilinmiyorsa veya dikkatli okuma gerektiriyorsa temponuzu düşürün.' },
+  { type: 'list', items: ['Basılı kitap için Sayfa, dijital metin veya ödev için Kelime seçin.', 'Temsilî bir bölümü ölçün ve gereken anlama düzeyini koruyabildiğiniz tempoyu kullanın.', 'Oturum süresini, günlük oturum sayısını ve haftalık okuma günlerini ayarlayın.', 'Her oturumu zorunlu saymak yerine kaçırılan günler için telafi payını kullanın.', 'İlk birkaç oturumdan sonra planı gerçek ilerlemenizle karşılaştırın.'] },
+  { type: 'title', text: 'Son tarih haritasını okuyun', level: 2 },
+  { type: 'paragraph', html: 'Gereken süre, seçtiğiniz tempodaki tahmini çalışmadır. Gereken günler bunu oturumlara çevirir. Kullanılabilir günler, haftalık okuma günü sayısına göre başlangıç ve son tarih arasındaki kapasiteyi tahmin eder.' },
+  { type: 'table', headers: ['Sonuç', 'Ne anlatır'], rows: [['Son tarihe kadar tempo', 'Her kullanılabilir okuma gününde tamamlanacak miktar'], ['Oturum hedefi', 'Tek bir planlı oturumda ulaşılacak miktar'], ['Telafi payı', 'Tahmini çalışma yerleştirildikten sonra kalan oturumlar'], ['Tahmini bitiş', 'Haftalık ritim korunursa bitiş tarihi']] },
+  { type: 'tip', title: 'Takvim anlama düzeyini ölçmez', html: 'Plan anlama, zorluk, yorgunluk, yeniden okuma veya kesintileri ölçmez. İlk taahhüt olarak kullanın ve gerçek temponuzla güncelleyin.' },
+  { type: 'title', text: 'Plan sıkışık veya gecikmişse', level: 2 },
+  { type: 'paragraph', html: 'Tahmini oturumlar yedek kapasiteyle sığıyorsa pay vardır. Sınırdaki plan için esnek bir telafi oturumu bırakın. Bitiş son tarihten sonraysa süreyi uzatın, oturum ekleyin veya hedefi azaltın.' },
+  { type: 'tip', title: 'İyileştirmeden önce ölçün', html: 'İki veya üç oturumdan sonra planlanan ilerlemeyi gerçek ilerlemeyle karşılaştırın. Fark sürerse aşırı iyimser bir takvimi zorlamak yerine hızı değiştirin.' },
+];
+
+const schemas: [WithContext<SoftwareApplication>, WithContext<FAQPage>, WithContext<HowTo>] = [
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Okuma temponuzu ve kitap son tarihinizi planlayın', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'TRY' } },
+  { '@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: 'Okuma son tarihi planlamak', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+];
+
+export const content: ToolLocaleContent<BookReadingUI> = { slug: 'kitap-okuma-suresi-ve-son-tarih-planlayici', title: 'Okuma temponuzu ve kitap son tarihinizi planlayın', description: 'Sayfa veya kelime hedefinize göre gerçekçi bir okuma temposu, oturum ritmi ve bitiş tarihi planlayın.', ui, seo, faq, bibliography, howTo, schemas: schemas as unknown as Record<string, unknown>[] };

package/src/tool/book-reading-time-deadline-planner/i18n/zh.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: '制定阅读计划', modeLabel: '计数方式', pagesModeLabel: '页数', wordsModeLabel: '字数', amountLabel: '阅读总量', speedLabel: '你的阅读速度', difficultyLabel: '文本难度', difficultyLightLabel: '轻松 · 1.2x', difficultyStandardLabel: '标准 · 1.0x', difficultyDenseLabel: '密集 · 0.8x', wordsPerPageLabel: '每页估计字数', wordsPerPageHint: '常见范围: 100 到 500', pagesPerHourLabel: '页/小时', wordsPerMinuteLabel: '字/分钟', startDateLabel: '开始日期', deadlineLabel: '截止日期', daysPerWeekLabel: '每周阅读天数', sessionsPerDayLabel: '每天阅读场次', sessionMinutesLabel: '每场分钟数', minutesRangeLabel: '5 到 240 分钟', hourShortLabel: '小时', minuteShortLabel: '分钟', bufferShortLabel: '不足', bufferExtraLabel: '余量', speedTestLabel: '测量你的阅读速度', speedTestHint: '使用一段简短且有代表性的文字', speedTestPromptLabel: '要阅读的文字', speedTestPlaceholder: '在这里粘贴或输入一个句子或短段落...', speedTestStartLabel: '开始计时', speedTestFinishLabel: '我读完了', speedTestElapsedLabel: '已用时间', speedTestRateLabel: '估计速度', speedTestSecondsLabel: '秒', speedTestWpmLabel: '字/分钟', speedTestUseLabel: '在字数模式中使用这个速度', speedTestIdle: '输入一段文字，准备好后开始计时。', speedTestRunning: '计时进行中。请按自然速度阅读。', speedTestFinished: '测试完成。这是第一次估计，不是固定标准。', speedTestNeedsText: '开始计时前请先添加文字。', speedTestNoWords: '没有测量到字数', presetLabel: '快速节奏', presetSteadyLabel: '稳定一周', presetWeekendLabel: '周末集中', presetAcademicLabel: '学习节奏', planLabel: '你的阅读地图', timeNeededLabel: '所需时间', readingDaysLabel: '所需阅读天数', capacityLabel: '可用阅读天数', dailyPaceLabel: '截止日前的进度', estimatedWordsLabel: '估计字数', wordsShortLabel: '字', sessionTargetLabel: '每场目标', catchUpLabel: '补进度余量', finishDateLabel: '预计完成日期', milestoneLabel: '里程碑', timelineLabel: '阅读里程碑时间线', calendarHint: '里程碑是计划参考点。如果现实安排打断了计划，可以调整截止日期或阅读节奏。', exportCalendarLabel: '下载里程碑 (.ics)', exportCalendarTitle: '阅读里程碑', milestoneStart: '开始', milestoneQuarter: '25%', milestoneHalf: '一半', milestoneThreeQuarter: '75%', milestoneFinish: '完成', statusOnTrack: '有余量', statusTight: '刚好够用', statusLate: '超过截止日期', statusInvalid: '检查日期', statusOnTrackDetail: '可用场次为漏读的日期或较慢的章节留下了余量。', statusTightDetail: '计划可以完成，但余量很少。留出一场用于补进度。', statusLateDetail: '按当前节奏无法在截止日期前完成。请增加场次、延长期限或减少目标。', statusInvalidDetail: '请选择有效的开始日期，以及不早于开始日期的截止日期。', sourceLabel: '这是阅读节奏的估计，不保证理解程度，也不是固定阅读速度。请用有代表性的文字测量自己的速度。',
+};
+
+const faq = [
+  { question: '如何选择阅读速度？', answer: '先测量阅读一段有代表性文字所需的时间，再数出页数或字数，使用实际测得的速度。密集、技术性强、不熟悉或注释很多的书通常需要更多时间。' },
+  { question: '这个计划能保证我理解书的内容吗？', answer: '不能。它只是把你的阅读速度和时间安排转换成日历估计。阅读流畅度不等于理解程度，遇到需要精读的内容时应当放慢速度。' },
+  { question: '补进度余量是什么意思？', answer: '这是把估计阅读时间安排在截止日期前之后剩余的场次数。如果数值为负，说明当前节奏的容量不足。' },
+  { question: '为什么可以按页数或字数计划？', answer: '纸质书按页数更方便，数字文本或阅读作业按字数更容易比较。请选择你能持续记录的单位。' },
+];
+
+const howTo = [
+  { name: '选择阅读单位', text: '按页数或字数计算书籍，并输入总量。' },
+  { name: '测量自己的速度', text: '使用实际测得的个人速度，而不是笼统的快速阅读承诺。' },
+  { name: '设置每周节奏', text: '设置每场时长、每天场次和每周阅读天数。' },
+  { name: '检查截止日期', text: '查看预计完成日期、每日进度和里程碑，并为现实中的中断留出余量。' },
+];
+
+const seo: ToolLocaleContent<BookReadingUI>['seo'] = [
+  { type: 'title', text: '规划阅读速度和书籍截止日期', level: 2 },
+  { type: 'paragraph', html: '把页数或字数目标转换成现实的阅读日程。输入阅读总量、测得的速度、场次时长和频率，以及希望完成阅读的日期。' },
+  { type: 'title', text: '使用自己的阅读速度', level: 2 },
+  { type: 'paragraph', html: '个人计时结果比笼统的快速阅读说法更有参考价值。请用有代表性的文字测试；如果书籍密集、不熟悉或需要精读，就应当降低速度。' },
+  { type: 'list', items: ['纸质书选择页数，数字文本或作业选择字数。', '测量有代表性的文字，并使用能保持所需理解程度的速度。', '设置场次时长、每天场次和每周阅读天数。', '使用余量应对漏读日期，不要把每场都当成必须完成的任务。', '完成几场阅读后，把计划与实际进度进行比较。'] },
+  { type: 'title', text: '如何阅读截止日期地图', level: 2 },
+  { type: 'paragraph', html: '所需时间是按所选速度估计的阅读工作量。所需阅读天数会把它转换成场次。可用阅读天数则根据每周阅读天数，估算开始日期到截止日期之间的容量。' },
+  { type: 'table', headers: ['结果', '含义'], rows: [['截止日前的进度', '每个可用阅读日需要完成的量'], ['每场目标', '一场计划阅读需要完成的量'], ['补进度余量', '安排估计工作量后剩余的场次'], ['预计完成日期', '保持每周节奏时的完成日期']] },
+  { type: 'tip', title: '日历不能衡量理解程度', html: '计划不会测量理解、难度、疲劳、重读或中断。请把它当作第一次承诺，再根据实际速度更新。' },
+  { type: 'title', text: '计划太紧或会延迟时', level: 2 },
+  { type: 'paragraph', html: '如果估计场次安排后仍有备用容量，就说明有余量。刚好够用的计划最好保留一场用于补进度。如果完成日期超过截止日期，可以延长期限、增加场次、增加阅读天数或减少目标。' },
+  { type: 'tip', title: '先测量，再优化', html: '完成两到三场后，比较计划进度和实际进度。如果差距持续存在，请调整速度，而不是强行遵守过于乐观的日历。' },
+];
+
+const schemas: [WithContext<SoftwareApplication>, WithContext<FAQPage>, WithContext<HowTo>] = [
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: '规划阅读速度和书籍截止日期', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'CNY' } },
+  { '@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: '规划阅读截止日期', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+];
+
+export const content: ToolLocaleContent<BookReadingUI> = { slug: 'book-reading-time-deadline-planner', title: '规划阅读速度和书籍截止日期', description: '根据页数或字数目标，规划现实的阅读速度、阅读场次和完成日期。', ui, seo, faq, bibliography, howTo, schemas: schemas as unknown as Record<string, unknown>[] };

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

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from '../../types';
+import { bookReadingTimeDeadlinePlanner } from './entry';
+
+export * from './entry';
+
+export const BOOK_READING_TIME_DEADLINE_PLANNER_TOOL: ToolDefinition = {
+  entry: bookReadingTimeDeadlinePlanner,
+  Component: () => import('./component.astro'),
+  SEOComponent: () => import('./seo.astro'),
+  BibliographyComponent: () => import('./bibliography.astro'),
+};

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

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { calculateReadingPlan, DEFAULT_INPUTS, normalizeInputs } from './logic';
+
+describe('book reading time deadline planner', () => {
+  it('calculates a page plan from reading speed and sessions', () => {
+    const result = calculateReadingPlan(DEFAULT_INPUTS);
+    expect(result.minutesNeeded).toBeCloseTo(548.57, 1);
+    expect(result.sessionsNeeded).toBe(19);
+    expect(result.readingDaysNeeded).toBe(19);
+    expect(result.finishDate).toBe('2026-01-27');
+  });
+
+  it('calculates words per minute plans without treating words as pages', () => {
+    const result = calculateReadingPlan({ ...DEFAULT_INPUTS, mode: 'words', amount: 30000, speed: 250, daysPerWeek: 7 });
+    expect(result.minutesNeeded).toBe(120);
+    expect(result.sessionsNeeded).toBe(4);
+    expect(result.dailyPace).toBe(968);
+    expect(result.estimatedWords).toBeNull();
+  });
+
+  it('applies the difficulty factor to the observed speed', () => {
+    const standard = calculateReadingPlan(DEFAULT_INPUTS);
+    const dense = calculateReadingPlan({ ...DEFAULT_INPUTS, difficultyFactor: 0.8 });
+    expect(dense.minutesNeeded).toBeCloseTo(standard.minutesNeeded / 0.8, 1);
+    expect(dense.readingDaysNeeded).toBeGreaterThan(standard.readingDaysNeeded);
+  });
+
+  it('estimates words from pages using the configured words-per-page value', () => {
+    const result = calculateReadingPlan({ ...DEFAULT_INPUTS, amount: 320, wordsPerPage: 300 });
+    expect(result.estimatedWords).toBe(96000);
+  });
+
+  it('shows the catch-up buffer when capacity exceeds the plan', () => {
+    const result = calculateReadingPlan({ ...DEFAULT_INPUTS, amount: 100, sessionMinutes: 60, daysPerWeek: 7, deadline: '2026-01-10' });
+    expect(result.catchUpSessions).toBeGreaterThan(0);
+    expect(result.sessionsShort).toBe(0);
+    expect(result.status).toBe('on-track');
+  });
+
+  it('marks a plan late when the deadline cannot hold the required sessions', () => {
+    const result = calculateReadingPlan({ ...DEFAULT_INPUTS, amount: 1000, deadline: '2026-01-03' });
+    expect(result.sessionsShort).toBeGreaterThan(0);
+    expect(result.status).toBe('late');
+  });
+
+  it('handles invalid dates without producing a false on-track result', () => {
+    const result = calculateReadingPlan({ ...DEFAULT_INPUTS, startDate: '2026-02-01', deadline: '2026-01-01' });
+    expect(result.invalidInput).toBe(true);
+    expect(result.status).toBe('invalid');
+  });
+
+  it('clamps numeric input to safe planning ranges', () => {
+    const result = normalizeInputs({ ...DEFAULT_INPUTS, amount: 0, speed: Number.NaN, difficultyFactor: 2, wordsPerPage: 99, sessionsPerDay: 99, daysPerWeek: 0 });
+    expect(result.amount).toBe(1);
+    expect(result.speed).toBe(35);
+    expect(result.sessionsPerDay).toBe(8);
+    expect(result.daysPerWeek).toBe(1);
+    expect(result.difficultyFactor).toBe(1.2);
+    expect(result.wordsPerPage).toBe(100);
+  });
+});

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

@@ -0,0 +1,129 @@
+export type ReadingMode = 'pages' | 'words';
+
+export interface BookReadingInputs {
+  mode: ReadingMode;
+  amount: number;
+  speed: number;
+  difficultyFactor: number;
+  wordsPerPage: number;
+  sessionMinutes: number;
+  sessionsPerDay: number;
+  daysPerWeek: number;
+  startDate: string;
+  deadline: string;
+}
+
+export type ReadingStatus = 'on-track' | 'tight' | 'late' | 'invalid';
+
+export interface BookReadingCalculation {
+  mode: ReadingMode;
+  amount: number;
+  speed: number;
+  difficultyFactor: number;
+  estimatedWords: number | null;
+  minutesNeeded: number;
+  sessionsNeeded: number;
+  readingDaysNeeded: number;
+  availableReadingDays: number;
+  capacitySessions: number;
+  dailyPace: number;
+  sessionTarget: number;
+  catchUpSessions: number;
+  sessionsShort: number;
+  finishDate: string;
+  milestoneDates: string[];
+  startDate: string;
+  deadline: string;
+  calendarDays: number;
+  status: ReadingStatus;
+  invalidInput: boolean;
+}
+
+export const DEFAULT_INPUTS: BookReadingInputs = getDefaultInputs(new Date('2026-01-01T00:00:00Z'));
+
+export function getDefaultInputs(referenceDate = new Date()): BookReadingInputs {
+  const startDate = toIsoDate(referenceDate);
+  return {
+    mode: 'pages', amount: 320, speed: 35, difficultyFactor: 1, wordsPerPage: 275, sessionMinutes: 30, sessionsPerDay: 1, daysPerWeek: 5,
+    startDate, deadline: addDays(startDate, 30),
+  };
+}
+
+export function normalizeInputs(inputs: BookReadingInputs): BookReadingInputs {
+  return {
+    mode: inputs.mode === 'words' ? 'words' : 'pages',
+    amount: clampNumber(inputs.amount, 1, 10000000, 320),
+    speed: clampNumber(inputs.speed, 1, 5000, inputs.mode === 'words' ? 250 : 35),
+    difficultyFactor: clampNumber(inputs.difficultyFactor, 0.8, 1.2, 1),
+    wordsPerPage: clampInteger(inputs.wordsPerPage, 100, 500, 275),
+    sessionMinutes: clampNumber(inputs.sessionMinutes, 5, 240, 30),
+    sessionsPerDay: clampInteger(inputs.sessionsPerDay, 1, 8, 1),
+    daysPerWeek: clampInteger(inputs.daysPerWeek, 1, 7, 5),
+    startDate: isIsoDate(inputs.startDate) ? inputs.startDate : DEFAULT_INPUTS.startDate,
+    deadline: isIsoDate(inputs.deadline) ? inputs.deadline : DEFAULT_INPUTS.deadline,
+  };
+}
+
+export function calculateReadingPlan(inputs: BookReadingInputs): BookReadingCalculation {
+  const invalidInput = !isIsoDate(inputs.startDate) || !isIsoDate(inputs.deadline) || inputs.deadline < inputs.startDate;
+  const normalized = normalizeInputs(inputs);
+  const effectiveSpeed = normalized.speed * normalized.difficultyFactor;
+  const minutesNeeded = normalized.mode === 'pages' ? (normalized.amount / effectiveSpeed) * 60 : normalized.amount / effectiveSpeed;
+  const sessionsNeeded = Math.ceil(minutesNeeded / normalized.sessionMinutes);
+  const readingDaysNeeded = Math.ceil(sessionsNeeded / normalized.sessionsPerDay);
+  const calendarDays = invalidInput ? 0 : daysBetweenInclusive(normalized.startDate, normalized.deadline);
+  const availableReadingDays = invalidInput ? 0 : Math.max(1, Math.ceil((calendarDays * normalized.daysPerWeek) / 7));
+  const capacitySessions = availableReadingDays * normalized.sessionsPerDay;
+  const dailyPace = Math.ceil(normalized.amount / Math.max(1, availableReadingDays));
+  const sessionTarget = Math.ceil(normalized.amount / Math.max(1, capacitySessions));
+  const catchUpSessions = Math.max(0, capacitySessions - sessionsNeeded);
+  const sessionsShort = Math.max(0, sessionsNeeded - capacitySessions);
+  const finishDate = addDays(normalized.startDate, Math.max(0, Math.ceil((readingDaysNeeded * 7) / normalized.daysPerWeek) - 1));
+  const milestoneDates = [0, 0.25, 0.5, 0.75, 1].map((fraction) => milestoneDate(normalized, sessionsNeeded, fraction));
+  const status = getStatus({ invalidInput, sessionsShort, catchUpSessions, capacitySessions });
+  const estimatedWords = normalized.mode === 'pages' ? normalized.amount * normalized.wordsPerPage : null;
+  return { mode: normalized.mode, amount: normalized.amount, speed: normalized.speed, difficultyFactor: normalized.difficultyFactor, estimatedWords, minutesNeeded, sessionsNeeded, readingDaysNeeded, availableReadingDays, capacitySessions, dailyPace, sessionTarget, catchUpSessions, sessionsShort, finishDate, milestoneDates, startDate: normalized.startDate, deadline: normalized.deadline, calendarDays, status, invalidInput };
+}
+
+function getStatus(values: { invalidInput: boolean; sessionsShort: number; catchUpSessions: number; capacitySessions: number }): ReadingStatus {
+  if (values.invalidInput || values.capacitySessions === 0) return 'invalid';
+  if (values.sessionsShort > 0) return 'late';
+  if (values.catchUpSessions <= Math.max(1, Math.ceil(values.capacitySessions * 0.15))) return 'tight';
+  return 'on-track';
+}
+
+function milestoneDate(inputs: BookReadingInputs, sessionsNeeded: number, fraction: number): string {
+  if (fraction === 0) return inputs.startDate;
+  const sessionIndex = Math.max(1, Math.ceil(sessionsNeeded * fraction));
+  const readingDay = Math.max(1, Math.ceil(sessionIndex / inputs.sessionsPerDay));
+  return addDays(inputs.startDate, Math.max(0, Math.ceil((readingDay * 7) / inputs.daysPerWeek) - 1));
+}
+
+function clampNumber(value: number, min: number, max: number, fallback: number): number {
+  const safeValue = Number.isFinite(value) ? value : fallback;
+  return Math.min(max, Math.max(min, safeValue));
+}
+
+function clampInteger(value: number, min: number, max: number, fallback: number): number {
+  return Math.round(clampNumber(value, min, max, fallback));
+}
+
+function isIsoDate(value: string): boolean {
+  return /^\d{4}-\d{2}-\d{2}$/.test(value) && !Number.isNaN(new Date(`${value}T00:00:00Z`).getTime());
+}
+
+function toIsoDate(date: Date): string {
+  return date.toISOString().slice(0, 10);
+}
+
+function addDays(date: string, amount: number): string {
+  const result = new Date(`${date}T00:00:00Z`);
+  result.setUTCDate(result.getUTCDate() + amount);
+  return toIsoDate(result);
+}
+
+function daysBetweenInclusive(startDate: string, endDate: string): number {
+  const start = new Date(`${startDate}T00:00:00Z`).getTime();
+  const end = new Date(`${endDate}T00:00:00Z`).getTime();
+  return Math.floor((end - start) / 86400000) + 1;
+}

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

@@ -0,0 +1,15 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { bookReadingTimeDeadlinePlanner } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props as Props;
+const loader = bookReadingTimeDeadlinePlanner.i18n[locale] || bookReadingTimeDeadlinePlanner.i18n.en;
+const content = await loader?.();
+---
+
+{content ? <SEORenderer content={{ locale, sections: content.seo }} /> : null}

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

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { calculateWordsPerMinute, countReadingWords } from './speed-test';
+
+describe('reading speed test', () => {
+  it('counts words across repeated whitespace', () => {
+    expect(countReadingWords('Read   a short passage.')).toBe(4);
+    expect(countReadingWords('')).toBe(0);
+  });
+
+  it('converts elapsed reading time into rounded words per minute', () => {
+    expect(calculateWordsPerMinute(200, 60)).toBe(200);
+    expect(calculateWordsPerMinute(0, 60)).toBe(0);
+    expect(calculateWordsPerMinute(200, 0)).toBe(0);
+  });
+});

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

@@ -0,0 +1,9 @@
+export function countReadingWords(text: string): number {
+  const trimmed = text.trim();
+  return trimmed ? trimmed.split(/\s+/).length : 0;
+}
+
+export function calculateWordsPerMinute(wordCount: number, elapsedSeconds: number): number {
+  if (!Number.isFinite(wordCount) || !Number.isFinite(elapsedSeconds) || wordCount <= 0 || elapsedSeconds <= 0) return 0;
+  return Math.round((wordCount * 60) / elapsedSeconds);
+}

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

@@ -0,0 +1,24 @@
+import type { BookReadingInputs } from './logic';
+
+const STORAGE_KEY = 'book-reading-time-deadline-planner-state';
+
+export interface StoredBookReadingState {
+  inputs: BookReadingInputs;
+}
+
+export function loadBookReadingState(fallback: StoredBookReadingState): StoredBookReadingState {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return fallback;
+    const stored = JSON.parse(raw) as Partial<StoredBookReadingState>;
+    return { ...fallback, ...stored, inputs: { ...fallback.inputs, ...stored.inputs } };
+  } catch {
+    return fallback;
+  }
+}
+
+export function saveBookReadingState(state: StoredBookReadingState): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+  } catch {}
+}

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

@@ -0,0 +1,76 @@
+export interface BookReadingUI {
+  [key: string]: string;
+  setupLabel: string;
+  modeLabel: string;
+  pagesModeLabel: string;
+  wordsModeLabel: string;
+  amountLabel: string;
+  speedLabel: string;
+  difficultyLabel: string;
+  difficultyLightLabel: string;
+  difficultyStandardLabel: string;
+  difficultyDenseLabel: string;
+  wordsPerPageLabel: string;
+  wordsPerPageHint: string;
+  pagesPerHourLabel: string;
+  wordsPerMinuteLabel: string;
+  startDateLabel: string;
+  deadlineLabel: string;
+  daysPerWeekLabel: string;
+  sessionsPerDayLabel: string;
+  sessionMinutesLabel: string;
+  minutesRangeLabel: string;
+  hourShortLabel: string;
+  minuteShortLabel: string;
+  bufferShortLabel: string;
+  bufferExtraLabel: string;
+  speedTestLabel: string;
+  speedTestHint: string;
+  speedTestPromptLabel: string;
+  speedTestPlaceholder: string;
+  speedTestStartLabel: string;
+  speedTestFinishLabel: string;
+  speedTestElapsedLabel: string;
+  speedTestRateLabel: string;
+  speedTestSecondsLabel: string;
+  speedTestWpmLabel: string;
+  speedTestUseLabel: string;
+  speedTestIdle: string;
+  speedTestRunning: string;
+  speedTestFinished: string;
+  speedTestNeedsText: string;
+  speedTestNoWords: string;
+  presetLabel: string;
+  presetSteadyLabel: string;
+  presetWeekendLabel: string;
+  presetAcademicLabel: string;
+  planLabel: string;
+  timeNeededLabel: string;
+  readingDaysLabel: string;
+  capacityLabel: string;
+  dailyPaceLabel: string;
+  sessionTargetLabel: string;
+  catchUpLabel: string;
+  finishDateLabel: string;
+  milestoneLabel: string;
+  timelineLabel: string;
+  calendarHint: string;
+  milestoneStart: string;
+  milestoneQuarter: string;
+  milestoneHalf: string;
+  milestoneThreeQuarter: string;
+  milestoneFinish: string;
+  estimatedWordsLabel: string;
+  wordsShortLabel: string;
+  exportCalendarLabel: string;
+  exportCalendarTitle: string;
+  statusOnTrack: string;
+  statusTight: string;
+  statusLate: string;
+  statusInvalid: string;
+  statusOnTrackDetail: string;
+  statusTightDetail: string;
+  statusLateDetail: string;
+  statusInvalidDetail: string;
+  sourceLabel: string;
+}

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

@@ -0,0 +1,19 @@
+export const validationEvidence = {
+  reviewedAt: '2026-08-31',
+  reviewer: { name: 'jjlmoya-utils-books team', expertise: 'Reading pace planning and unit conversion' },
+  jurisdiction: ['INTL'],
+  methodology: 'The planner converts a word or page target into estimated reading time, adjusts observed speed with a difficulty factor, estimates page words from the configured value, and exports all-day milestone markers.',
+  version: '1.0',
+  effectiveFrom: '2026-08-31',
+  sources: [
+    { title: 'Allegheny College. College Level Reading', url: 'https://sites.allegheny.edu/academic-success/academic-resources/reading/', accessedAt: '2026-08-31', primary: true },
+    { title: 'Ministerio de Educación y Formación Profesional. Marco teórico de lectura PISA 2018', url: 'https://www.educacionfpydeportes.gob.es/dam/jcr%3A2f1081a1-c1e4-4799-8a49-9bc589724ca4/marco%20teorico%20lectura%202018_esp_ESP.pdf', accessedAt: '2026-08-31', primary: true },
+    { title: 'Rayner, Schotter, Masson, Potter and Treiman. So much to read, so little time', url: 'https://profiles.wustl.edu/en/publications/so-much-to-read-so-little-time-how-do-we-read-and-can-speed-readi/', accessedAt: '2026-08-31', primary: true },
+  ],
+  referenceCases: [
+    { name: 'Page estimate', input: { pages: 320, wordsPerPage: 275 }, expected: { words: 88000 }, tolerance: 0, sourceUrl: 'https://sites.allegheny.edu/academic-success/academic-resources/reading/' },
+    { name: 'Word timing', input: { words: 30000, wordsPerMinute: 250 }, expected: { minutes: 120 }, tolerance: 0, sourceUrl: 'https://profiles.wustl.edu/en/publications/so-much-to-read-so-little-time-how-do-we-read-and-can-speed-readi/' },
+    { name: 'Difficulty factor', input: { minutesAtStandard: 120, difficultyFactor: 0.8 }, expected: { minutes: 150 }, tolerance: 0, sourceUrl: 'https://www.educacionfpydeportes.gob.es/dam/jcr%3A2f1081a1-c1e4-4799-8a49-9bc589724ca4/marco%20teorico%20lectura%202018_esp_ESP.pdf' },
+  ],
+  limitations: ['Words per page is an editable estimate, not a measurement of the specific edition.', 'Difficulty factor is a planning adjustment, not a reading-comprehension score.', 'The calendar does not measure understanding, fatigue or interruptions.'],
+} as const;

package/src/tools.ts

@@ -2,5 +2,6 @@ export { ALL_ENTRIES } from './entries';
 import type { ToolDefinition } from './types';
 import { BOOK_PAGINATION_AND_SPINE_CALCULATOR_TOOL } from './tool/book-pagination-and-spine-calculator';
 import { BOOK_INTERIOR_MARGIN_AND_GUTTER_PLANNER_TOOL } from './tool/book-interior-margin-and-gutter-planner';
+import { BOOK_READING_TIME_DEADLINE_PLANNER_TOOL } from './tool/book-reading-time-deadline-planner';
 
-export const ALL_TOOLS: ToolDefinition[] = [BOOK_PAGINATION_AND_SPINE_CALCULATOR_TOOL, BOOK_INTERIOR_MARGIN_AND_GUTTER_PLANNER_TOOL];
+export const ALL_TOOLS: ToolDefinition[] = [BOOK_PAGINATION_AND_SPINE_CALCULATOR_TOOL, BOOK_INTERIOR_MARGIN_AND_GUTTER_PLANNER_TOOL, BOOK_READING_TIME_DEADLINE_PLANNER_TOOL];