@jjlmoya/utils-language 1.10.1 → 1.11.0

package/src/tool/lexical-coverage-vocabulary-calculator/i18n/zh.ts

@@ -0,0 +1,13 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { LexicalCoverageUI } from '../ui';
+
+const ui: LexicalCoverageUI = { contentType: '你想理解什么内容？', conversation: '日常对话', travel: '旅行与日常生活', media: '电影与剧集', generalReading: '一般阅读', novels: '小说', business: '商务与工作', academic: '学术文本', knownWords: '你已经认识的词', knownWordsHint: '尽量使用有依据的估计，并始终统一计算词族、词元或词形中的一种单位。', targetCoverage: '目标覆盖率', coverage80: '开始理解', coverage90: '跟上脉络', coverage95: '借助支持阅读', coverage98: '独立阅读', resetButton: '重置', quickStart: '快速开始', conversationPreset: '对话', readingPreset: '小说', workPreset: '工作', resultTitle: '你的词汇地图', emptyResult: '选择内容类型并输入已知词汇，即可看到下一个实用的词汇目标。', checkInputs: '请检查输入', invalidWords: '请输入0到50,000之间的已知词数。', invalidContentType: '请选择可用的内容类型。', invalidCoverage: '请选择80%到98%之间的目标。', belowTarget: '你还没有达到选择的覆盖率。差距就是下一个词汇项目。', atTarget: '你已经达到选择的计划区间。请把主题词汇放在手边。', buffer: '对于这个内容类型，你已经有足够余量。现在用真实目标文本进行检查。', recommendedWords: '目标所需词数', vocabularyKnown: '已计入词数', estimatedCoverage: '预计覆盖率', gapWords: '距离目标还差', unknownPerHundred: '每100词中的生词', coverageRoute: '从高频词到独立阅读的路线', nextCheckpoint: '下一个检查点', noMoreCheckpoints: '你已经超过这个计划模型的最高检查点。', words: '词', wordUnit: '词', unknownWords: '生词', targetMarker: '目标', coverageNote: '覆盖率是文本中已知词汇能够识别的连续词语比例。它不等同于语言熟练度，也不代表理解了相同比例的意义。', wordFamilyNote: '研究常常计算词族，而应用可能计算词元或词形。比较时要使用相同单位。', contentTypeHelp: '不同体裁需要不同词汇量。对话会重复高频词，而小说、工作和学习材料会加入更多低频及专业词汇。', interpretationTitle: '如何使用地图', actionBelow: '从真实对话、书籍或工作文档中整理重复出现的词，并把它们放在短语中学习。', actionAt: '查看目标体裁的一页内容或文字稿，加入反复出现的生词。', actionBuffer: '不要只收集孤立单词，也要收集下一篇文本需要的短语、搭配和专业词汇。' };
+const faq = [{ question: '词汇覆盖率计算器估计什么？', answer: '它按80%、90%、95%和98%的计划覆盖率，估计理解对话、媒体、小说、工作或学术文本所需的词汇量，并显示下一个检查点。' }, { question: '为什么小说比对话需要更多词汇？', answer: '日常对话会重复高频核心词。小说和专业文本包含更多低频词、主题词和固定表达，所以相同词数覆盖的文本更少。' }, { question: '80%的覆盖率意味着理解了80%的意思吗？', answer: '不意味着。它只是表示大约有多少连续词语能够被识别。关键词、语法、背景知识、发音和语速同样影响理解。' }, { question: '应该计算词、词元还是词族？', answer: '选择一种单位并保持一致。研究常报告词族，而应用可能报告词元或词形，这些数字不能直接互换。' }, { question: '差距应该怎么使用？', answer: '从目标体裁中抽取短样本，保留反复出现的词并放在短语中学习，然后再检查相似样本。' }];
+const howTo = [{ name: '选择内容', text: '选择你接下来想理解的对话或文本类型。' }, { name: '估计词汇量', text: '输入你能识别的词、词元或词族的统一估计值。' }, { name: '设定覆盖率', text: '从开始理解到独立阅读，选择适合你的计划区间。' }, { name: '利用差距', text: '把差距和下一个目标变成来自真实内容的学习清单。' }];
+const appSchema: SoftwareApplication = { '@type': 'SoftwareApplication', name: '词汇覆盖率计算器', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', isAccessibleForFree: true, url: 'https://gamebob.dev/zh/lexical-coverage-vocabulary-calculator' };
+const howToSchema: HowTo = { '@type': 'HowTo', name: '按内容类型估计所需词汇量', step: howTo.map((item) => ({ '@type': 'HowToStep', ...item })) };
+const faqSchema: FAQPage = { '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) };
+const withContext = (schema: SoftwareApplication | HowTo | FAQPage): Record<string, unknown> => ({ '@context': 'https://schema.org', ...schema });
+
+export const content: ToolLocaleContent<LexicalCoverageUI> = { slug: 'lexical-coverage-vocabulary-calculator', title: '词汇覆盖率计算器', description: '根据覆盖率目标，估计理解对话、小说、工作、媒体和学术文本所需的词汇量。', ui, seo: [{ type: 'title', text: '按内容规划所需词汇量', level: 2 }, { type: 'paragraph', html: '少量高频词可以打开日常对话，却不能同样覆盖小说或专业文档。这款计算器把目标体裁连接到具体词数和下一个可执行的目标。' }, { type: 'title', text: '词汇覆盖率衡量什么', level: 2 }, { type: 'paragraph', html: '词汇覆盖率是样本中已知词汇能够识别的连续词语比例。80%、90%、95%和98%是规划区间，不是考试，也不保证完整理解。' }, { type: 'title', text: '为什么体裁会改变数字', level: 2 }, { type: 'table', headers: ['内容', '80%计划区间', '95%计划区间', '增加的内容'], rows: [['日常对话', '2,000词', '4,500词', '日常套路和高频表达'], ['电影与剧集', '3,000词', '6,000词', '对话、俚语和话题变化'], ['小说', '5,000词', '8,000词', '叙事、描写和体裁词汇'], ['商务与工作', '5,000词', '8,000词', '专业表达和领域术语'], ['学术文本', '6,000词', '10,000词', '抽象词和学科术语']] }, { type: 'title', text: '把差距变成学习决定', level: 2 }, { type: 'paragraph', html: '如果低于选择的区间，不要随机收集单词。从真实内容中抽取短样本，保留反复出现或阻碍理解的词，并把它们放在短语中学习。' }, { type: 'list', items: ['选择与你下一项真实任务匹配的体裁。', '每次都使用相同的计算单位。', '优先学习在多个样本中重复出现的词。', '学习后再次检查同一种内容。'] }, { type: 'tip', title: '依据与限制', html: '80%覆盖率对应2,000词的参考来自词频和文本覆盖研究。更高的书面语数值会因语料库和体裁而变化。语言、形态、专名、主题知识、语法和速度仍会影响理解。' }], faq, bibliography: [{ name: 'Paul Nation, How Large a Vocabulary Is Needed for Reading and Listening?', url: 'https://www.scienceguide.nl/wp-content/uploads/2017/11/nation-2006-vocabulary.pdf' }, { name: 'Izquierdo Gil, La selección del léxico en la enseñanza del español como lengua extranjera', url: 'https://asele.org/media/2025/03/8izquierdogilm-adelcarmenlaselecciondellexicoenlaensananza.pdf' }], howTo, schemas: [withContext(appSchema), withContext(faqSchema), withContext(howToSchema)] };

package/src/tool/lexical-coverage-vocabulary-calculator/index.ts

@@ -0,0 +1,14 @@
+import type { ToolDefinition } from '../../types';
+import { lexicalCoverageVocabularyCalculator } from './entry';
+
+export type { LexicalCoverageUI, LexicalCoverageVocabularyCalculatorLocaleContent } from './entry';
+export { lexicalCoverageVocabularyCalculator } from './entry';
+export { calculateLexicalCoverage, estimateCoverage, validateInputs, COVERAGE_TARGETS, VOCABULARY_PRESETS } from './logic';
+export type { ContentType, CoverageStatus, CoverageTarget, LexicalCoverageInputs, LexicalCoveragePlan, LexicalCoverageResult, VocabularyPreset } from './types';
+
+export const LEXICAL_COVERAGE_VOCABULARY_CALCULATOR_TOOL: ToolDefinition = {
+  entry: lexicalCoverageVocabularyCalculator,
+  Component: () => import('./component.astro'),
+  SEOComponent: () => import('./seo.astro'),
+  BibliographyComponent: () => import('./bibliography.astro'),
+};

package/src/tool/lexical-coverage-vocabulary-calculator/lexical-coverage-vocabulary-calculator.css

@@ -0,0 +1,497 @@
+:root {
+  --n-paper: #f3eee3;
+  --n-card: #fffdf8;
+  --n-white: #fff;
+  --n-ink: #202c33;
+  --n-muted: #66747a;
+  --n-line: #d8cec0;
+  --n-accent: #b7523d;
+  --n-accent-strong: #813427;
+  --n-accent-soft: #f1d8ce;
+  --n-water: #2b6870;
+  --n-water-soft: #d9ece8;
+  --n-good: #2e7051;
+  --n-shadow: rgba(44, 38, 28, 0.12);
+}
+
+.theme-dark {
+  --n-paper: #181e22;
+  --n-card: #242d32;
+  --n-white: #fff;
+  --n-ink: #f5eddf;
+  --n-muted: #bec6c5;
+  --n-line: #4d5d60;
+  --n-accent: #f09278;
+  --n-accent-strong: #ffb09a;
+  --n-accent-soft: #5a3733;
+  --n-water: #8fd0cc;
+  --n-water-soft: #29464a;
+  --n-good: #94d1a9;
+  --n-shadow: rgba(0, 0, 0, 0.3);
+}
+
+.lexical-coverage {
+  --n-paper: #f3eee3;
+  --n-card: #fffdf8;
+  --n-white: #fff;
+  --n-ink: #202c33;
+  --n-muted: #66747a;
+  --n-line: #d8cec0;
+  --n-accent: #b7523d;
+  --n-accent-strong: #813427;
+  --n-accent-soft: #f1d8ce;
+  --n-water: #2b6870;
+  --n-water-soft: #d9ece8;
+  --n-good: #2e7051;
+  --n-shadow: rgba(44, 38, 28, 0.12);
+
+  display: grid;
+  grid-template-columns: minmax(16rem, 0.75fr) minmax(24rem, 1.25fr);
+  color: var(--n-ink);
+  background: var(--n-paper);
+  border: 1px solid var(--n-line);
+  border-radius: 1.25rem;
+  box-shadow: 0 1rem 2rem var(--n-shadow);
+  overflow: hidden;
+}
+
+.theme-dark .lexical-coverage {
+  --n-paper: #181e22;
+  --n-card: #242d32;
+  --n-white: #fff;
+  --n-ink: #f5eddf;
+  --n-muted: #bec6c5;
+  --n-line: #4d5d60;
+  --n-accent: #f09278;
+  --n-accent-strong: #ffb09a;
+  --n-accent-soft: #5a3733;
+  --n-water: #8fd0cc;
+  --n-water-soft: #29464a;
+  --n-good: #94d1a9;
+  --n-shadow: rgba(0, 0, 0, 0.3);
+}
+
+.lexical-form,
+.lexical-result {
+  padding: 1.5rem;
+}
+
+.lexical-form {
+  display: grid;
+  align-content: start;
+  gap: 1.25rem;
+  border-right: 1px solid var(--n-line);
+}
+
+.field-label,
+.coverage-label,
+.preset-label {
+  display: block;
+  margin-bottom: 0.45rem;
+  color: var(--n-muted);
+  font-size: 0.75rem;
+  font-weight: 800;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.content-field,
+.choice,
+.words-field {
+  position: relative;
+}
+
+.choice-trigger,
+.words-field input[type='number'] {
+  width: 100%;
+  min-height: 3.1rem;
+  border: 1px solid var(--n-line);
+  border-radius: 0.7rem;
+  background: var(--n-card);
+  color: var(--n-ink);
+  font: inherit;
+  font-size: 1rem;
+  padding: 0.75rem 0.85rem;
+}
+
+.choice-trigger {
+  cursor: pointer;
+  text-align: left;
+}
+
+.choice-trigger::after {
+  content: '';
+  float: right;
+  width: 0.55rem;
+  height: 0.55rem;
+  margin-top: 0.1rem;
+  border-right: 2px solid var(--n-accent);
+  border-bottom: 2px solid var(--n-accent);
+  transform: rotate(45deg);
+}
+
+.choice-trigger[aria-expanded='true']::after {
+  transform: rotate(225deg) translate(-0.1rem, -0.1rem);
+}
+
+.choice-menu {
+  position: absolute;
+  z-index: 3;
+  top: calc(100% + 0.35rem);
+  right: 0;
+  left: 0;
+  display: grid;
+  gap: 0.2rem;
+  padding: 0.35rem;
+  border: 1px solid var(--n-line);
+  border-radius: 0.7rem;
+  background: var(--n-card);
+  box-shadow: 0 0.8rem 1.5rem var(--n-shadow);
+}
+
+.choice-menu[hidden] {
+  display: none;
+}
+
+.choice-menu button {
+  border: 0;
+  border-radius: 0.45rem;
+  background: transparent;
+  color: var(--n-ink);
+  cursor: pointer;
+  font: inherit;
+  padding: 0.65rem;
+  text-align: left;
+}
+
+.choice-menu button:hover,
+.choice-menu button[aria-selected='true'] {
+  background: var(--n-accent-soft);
+}
+
+.words-field input[type='number'] {
+  padding-right: 4.5rem;
+}
+
+.words-range {
+  width: 100%;
+  accent-color: var(--n-accent);
+}
+
+.words-hint,
+.lexical-note {
+  margin: 0.45rem 0 0;
+  color: var(--n-muted);
+  font-size: 0.83rem;
+  line-height: 1.45;
+}
+
+.coverage-options {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 0.45rem;
+}
+
+.coverage-options button,
+.preset-grid button,
+.lexical-actions button {
+  border: 1px solid var(--n-line);
+  border-radius: 0.6rem;
+  background: var(--n-card);
+  color: var(--n-ink);
+  cursor: pointer;
+  font: inherit;
+  font-weight: 700;
+  padding: 0.7rem 0.45rem;
+}
+
+.coverage-options button[aria-pressed='true'] {
+  border-color: var(--n-accent);
+  background: var(--n-accent-soft);
+  color: var(--n-accent-strong);
+}
+
+.preset-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 0.45rem;
+}
+
+.preset-grid button {
+  color: var(--n-water);
+  font-size: 0.85rem;
+}
+
+.lexical-actions {
+  display: flex;
+  gap: 0.6rem;
+}
+
+.lexical-actions .reset-button {
+  border-color: transparent;
+  background: transparent;
+  color: var(--n-muted);
+  font-size: 0.85rem;
+  font-weight: 600;
+}
+
+.lexical-actions .reset-button:hover {
+  border-color: var(--n-line);
+  color: var(--n-ink);
+}
+
+.lexical-form button:focus,
+.lexical-form input:focus {
+  outline: 3px solid var(--n-accent-soft);
+  outline-offset: 2px;
+}
+
+.lexical-result {
+  display: grid;
+  align-content: start;
+  gap: 1rem;
+  background: var(--n-card);
+}
+
+.lexical-result-title {
+  margin: 0;
+  color: var(--n-muted);
+  font-size: 0.75rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.lexical-status {
+  margin: 0;
+  border-left: 0.35rem solid var(--n-accent);
+  background: var(--n-accent-soft);
+  color: var(--n-accent-strong);
+  font-weight: 800;
+  padding: 0.8rem 1rem;
+}
+
+.lexical-status.at-target {
+  border-color: var(--n-good);
+  color: var(--n-good);
+}
+
+.lexical-status.buffer {
+  border-color: var(--n-water);
+  color: var(--n-water);
+}
+
+.lexical-headline,
+.lexical-readout {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap: 0.6rem;
+}
+
+.lexical-readout {
+  grid-template-columns: repeat(3, 1fr);
+}
+
+.lexical-metric {
+  display: grid;
+  gap: 0.25rem;
+  min-width: 0;
+  padding: 0.8rem;
+  border-top: 2px solid var(--n-line);
+}
+
+.lexical-metric-label {
+  color: var(--n-muted);
+  font-size: 0.7rem;
+  font-weight: 800;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+
+.lexical-metric-value {
+  overflow-wrap: anywhere;
+  color: var(--n-ink);
+  font-size: clamp(1rem, 2.4vw, 1.45rem);
+  font-weight: 850;
+}
+
+.lexical-headline .lexical-metric:first-child .lexical-metric-value {
+  color: var(--n-accent-strong);
+  font-size: clamp(1.8rem, 4vw, 3rem);
+  line-height: 1;
+}
+
+.lexical-scene-wrap {
+  padding: 0.8rem 0;
+  border-top: 1px solid var(--n-line);
+  border-bottom: 1px solid var(--n-line);
+}
+
+.lexical-scene-label {
+  display: block;
+  margin-bottom: 0.4rem;
+  color: var(--n-muted);
+  font-size: 0.75rem;
+  font-weight: 800;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.lexical-atlas {
+  container-type: inline-size;
+  display: block;
+  width: 100%;
+  height: auto;
+  overflow: visible;
+}
+
+.atlas-river,
+.atlas-bank {
+  fill: none;
+  stroke-linecap: round;
+}
+
+.atlas-river {
+  stroke: var(--n-water);
+  stroke-width: 18;
+}
+
+.atlas-bank {
+  stroke: var(--n-water-soft);
+  stroke-width: 4;
+}
+
+.atlas-guide {
+  stroke: var(--n-line);
+  stroke-dasharray: 3 7;
+  stroke-width: 1;
+}
+
+.atlas-checkpoint {
+  fill: var(--n-card);
+  stroke: var(--n-accent);
+  stroke-width: 3;
+}
+
+.atlas-current-marker {
+  fill: var(--n-accent);
+  stroke: var(--n-card);
+  stroke-width: 5;
+}
+
+.atlas-coverage,
+.atlas-word-count,
+.atlas-current-label {
+  fill: var(--n-ink);
+  font-size: 14px;
+  font-weight: 800;
+}
+
+@container (max-width: 760px) {
+  .atlas-word-count-intermediate {
+    display: none;
+  }
+}
+
+.atlas-word-count {
+  fill: var(--n-muted);
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.atlas-current-label {
+  fill: var(--n-accent-strong);
+  font-size: 16px;
+}
+
+.section-seo .seo-title .prefix {
+  display: none;
+}
+
+.lexical-next,
+.lexical-empty,
+.lexical-error {
+  margin: 0;
+  color: var(--n-muted);
+  line-height: 1.5;
+}
+
+.lexical-next {
+  grid-column: 1 / -1;
+  padding: 0.75rem 0.8rem;
+  border: 1px solid var(--n-line);
+  background: var(--n-water-soft);
+  color: var(--n-ink);
+}
+
+.lexical-interpretation {
+  grid-column: 1 / -1;
+  display: grid;
+  gap: 0.35rem;
+  padding: 0.8rem;
+  border-left: 0.25rem solid var(--n-water);
+  background: var(--n-water-soft);
+}
+
+.lexical-interpretation-title {
+  color: var(--n-water);
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.lexical-interpretation-copy {
+  color: var(--n-ink);
+  line-height: 1.45;
+}
+
+.lexical-empty {
+  display: grid;
+  justify-items: center;
+  gap: 0.8rem;
+  padding: 1rem 0;
+  text-align: center;
+}
+
+.empty-atlas-glyph {
+  width: 7rem;
+  height: auto;
+}
+
+.empty-page {
+  fill: var(--n-accent-soft);
+  stroke: var(--n-accent);
+  stroke-width: 3;
+}
+
+.empty-line {
+  stroke: var(--n-accent-strong);
+  stroke-linecap: round;
+  stroke-width: 3;
+}
+
+@media (max-width: 760px) {
+  .lexical-coverage {
+    grid-template-columns: 1fr;
+  }
+
+  .lexical-form {
+    border-right: 0;
+    border-bottom: 1px solid var(--n-line);
+  }
+}
+
+@media (max-width: 430px) {
+  .lexical-form,
+  .lexical-result {
+    padding: 1rem;
+  }
+
+  .preset-grid button {
+    font-size: 0.75rem;
+  }
+
+  .lexical-readout {
+    grid-template-columns: 1fr;
+  }
+}

package/src/tool/lexical-coverage-vocabulary-calculator/logic.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { calculateLexicalCoverage, estimateCoverage, validateInputs, VOCABULARY_PRESETS } from './logic';
+
+describe('calculateLexicalCoverage', () => {
+  it('matches the 2,000 word and 80% conversation reference case', () => {
+    const result = calculateLexicalCoverage({ contentType: 'conversation', knownWords: 0, targetCoverage: 80 });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.plan.recommendedWords).toBe(2000);
+    expect(result.plan.estimatedCoverage).toBe(0);
+    expect(result.plan.gapWords).toBe(2000);
+  });
+
+  it('matches the 8,000 word novel and business planning band', () => {
+    const novel = calculateLexicalCoverage({ contentType: 'novels', knownWords: 8000, targetCoverage: 95 });
+    const business = calculateLexicalCoverage({ contentType: 'business', knownWords: 5000, targetCoverage: 95 });
+    expect(novel.ok && novel.plan.recommendedWords).toBe(8000);
+    expect(business.ok && business.plan.recommendedWords).toBe(8000);
+    expect(business.ok && business.plan.gapWords).toBe(3000);
+  });
+
+  it('interpolates coverage between documented checkpoints and caps the model', () => {
+    const preset = VOCABULARY_PRESETS.conversation;
+    expect(estimateCoverage(preset, 2500)).toBe(85);
+    expect(estimateCoverage(preset, 10000)).toBe(98);
+  });
+});
+
+describe('validateInputs', () => {
+  it('rejects unsupported content, word counts, and targets', () => {
+    expect(validateInputs({ contentType: 'unknown' as never, knownWords: 1000, targetCoverage: 80 })).toContain('content type');
+    expect(validateInputs({ contentType: 'conversation', knownWords: -1, targetCoverage: 80 })).toContain('between 0');
+    expect(validateInputs({ contentType: 'conversation', knownWords: 1000, targetCoverage: 85 as never })).toContain('coverage target');
+  });
+});

package/src/tool/lexical-coverage-vocabulary-calculator/logic.ts

@@ -0,0 +1,76 @@
+import type { ContentType, CoverageTarget, LexicalCoverageInputs, LexicalCoverageResult, VocabularyPreset } from './types';
+
+export const COVERAGE_TARGETS: CoverageTarget[] = [80, 90, 95, 98];
+
+export const VOCABULARY_PRESETS: Record<ContentType, VocabularyPreset> = {
+  conversation: { id: 'conversation', wordsByCoverage: { 80: 2000, 90: 3000, 95: 4500, 98: 6500 } },
+  travel: { id: 'travel', wordsByCoverage: { 80: 2500, 90: 3500, 95: 5000, 98: 7000 } },
+  media: { id: 'media', wordsByCoverage: { 80: 3000, 90: 4500, 95: 6000, 98: 8000 } },
+  generalReading: { id: 'generalReading', wordsByCoverage: { 80: 4000, 90: 5500, 95: 7000, 98: 9000 } },
+  novels: { id: 'novels', wordsByCoverage: { 80: 5000, 90: 6500, 95: 8000, 98: 9000 } },
+  business: { id: 'business', wordsByCoverage: { 80: 5000, 90: 6500, 95: 8000, 98: 10000 } },
+  academic: { id: 'academic', wordsByCoverage: { 80: 6000, 90: 8000, 95: 10000, 98: 12000 } },
+};
+
+export function calculateLexicalCoverage(inputs: LexicalCoverageInputs): LexicalCoverageResult {
+  const error = validateInputs(inputs);
+  if (error) return { ok: false, error };
+  const preset = VOCABULARY_PRESETS[inputs.contentType];
+  const recommendedWords = preset.wordsByCoverage[inputs.targetCoverage];
+  const estimatedCoverage = estimateCoverage(preset, inputs.knownWords);
+  const checkpoints = COVERAGE_TARGETS.map((coverage) => ({ coverage, words: preset.wordsByCoverage[coverage] }));
+  const nextCheckpoint = checkpoints.find((checkpoint) => checkpoint.words > inputs.knownWords) ?? null;
+  return {
+    ok: true,
+    plan: {
+      inputs,
+      recommendedWords,
+      knownWords: inputs.knownWords,
+      estimatedCoverage,
+      unknownPerHundred: round(100 - estimatedCoverage, 1),
+      gapWords: Math.max(0, recommendedWords - inputs.knownWords),
+      status: getStatus(inputs.knownWords, recommendedWords, preset.wordsByCoverage[98]),
+      checkpoints,
+      nextCheckpoint,
+    },
+  };
+}
+
+export function validateInputs(inputs: LexicalCoverageInputs): string | null {
+  if (!Object.hasOwn(VOCABULARY_PRESETS, inputs.contentType)) return 'Choose a supported content type.';
+  if (!Number.isFinite(inputs.knownWords) || inputs.knownWords < 0 || inputs.knownWords > 50000) return 'Known vocabulary must be between 0 and 50,000 words.';
+  if (!COVERAGE_TARGETS.includes(inputs.targetCoverage)) return 'Choose a coverage target between 80% and 98%.';
+  return null;
+}
+
+export function estimateCoverage(preset: VocabularyPreset, knownWords: number): number {
+  if (knownWords <= 0) return 0;
+  const first = COVERAGE_TARGETS[0]!;
+  const firstWords = preset.wordsByCoverage[first];
+  if (knownWords < firstWords) return round((knownWords / firstWords) * first, 1);
+  const last = COVERAGE_TARGETS.at(-1)!;
+  if (knownWords >= preset.wordsByCoverage[last]) return 98;
+  for (let index = 0; index < COVERAGE_TARGETS.length - 1; index += 1) {
+    const lowCoverage = COVERAGE_TARGETS[index]!;
+    const highCoverage = COVERAGE_TARGETS[index + 1]!;
+    const lowWords = preset.wordsByCoverage[lowCoverage];
+    const highWords = preset.wordsByCoverage[highCoverage];
+    if (knownWords < highWords) return round(interpolate({ value: knownWords, lowValue: lowWords, highValue: highWords, lowResult: lowCoverage, highResult: highCoverage }), 1);
+  }
+  return 80;
+}
+
+function getStatus(knownWords: number, targetWords: number, bufferWords: number): 'below-target' | 'at-target' | 'buffer' {
+  if (knownWords < targetWords) return 'below-target';
+  if (knownWords < bufferWords) return 'at-target';
+  return 'buffer';
+}
+
+function interpolate(values: { value: number; lowValue: number; highValue: number; lowResult: number; highResult: number }): number {
+  return values.lowResult + ((values.value - values.lowValue) / (values.highValue - values.lowValue)) * (values.highResult - values.lowResult);
+}
+
+function round(value: number, decimals: number): number {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}

package/src/tool/lexical-coverage-vocabulary-calculator/seo.astro

@@ -0,0 +1,11 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { lexicalCoverageVocabularyCalculator } from './entry';
+import type { KnownLocale } from '../../types';
+
+const locale = (Astro.props.locale ?? 'en') as KnownLocale;
+const loader = lexicalCoverageVocabularyCalculator.i18n[locale] ?? lexicalCoverageVocabularyCalculator.i18n.en;
+const content = await loader?.();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/lexical-coverage-vocabulary-calculator/storage.ts

@@ -0,0 +1,24 @@
+import type { LexicalCoverageInputs } from './types';
+
+const STORAGE_KEY = 'jjlmoya-language-lexical-coverage-vocabulary-calculator';
+
+export function readLexicalCoverageInputs(): Partial<LexicalCoverageInputs> | null {
+  try {
+    const stored = window.localStorage.getItem(STORAGE_KEY);
+    return stored ? JSON.parse(stored) as Partial<LexicalCoverageInputs> : null;
+  } catch {
+    return null;
+  }
+}
+
+export function saveLexicalCoverageInputs(inputs: LexicalCoverageInputs): void {
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(inputs));
+  } catch {}
+}
+
+export function clearLexicalCoverageInputs(): void {
+  try {
+    window.localStorage.removeItem(STORAGE_KEY);
+  } catch {}
+}