@jjlmoya/utils-language 1.8.0 → 1.9.0

package/src/tool/cefr-language-skill-profile-planner/component.astro

@@ -0,0 +1,100 @@
+---
+import './cefr-language-skill-profile-planner.css';
+import { CEFR_LEVELS, SKILL_KEYS } from './logic';
+import type { CefrSkillProfileUI } from './ui';
+import type { SkillKey } from './types';
+
+interface Props {
+  ui: CefrSkillProfileUI;
+}
+
+const { ui } = Astro.props as Props;
+const skillLabels: Record<SkillKey, string> = {
+  listening: ui.skillListening,
+  reading: ui.skillReading,
+  spokenInteraction: ui.skillSpokenInteraction,
+  spokenProduction: ui.skillSpokenProduction,
+  writing: ui.skillWriting,
+};
+const skillDefaults: Record<SkillKey, [string, string]> = {
+  listening: ['A1', 'B1'], reading: ['A1', 'B1'], spokenInteraction: ['A1', 'B1'], spokenProduction: ['A1', 'B1'], writing: ['A1', 'B1'],
+};
+---
+
+<div class="cefr-profile" data-cefr-profile data-ui={JSON.stringify(ui)}>
+  <form class="profile-form" data-profile-form>
+    <div class="profile-settings">
+      <label class="date-field">
+        <span>{ui.targetDate}</span>
+        <input type="date" name="targetDate" required />
+      </label>
+      <label>
+        <span>{ui.weeklyHours}</span>
+        <input type="number" name="weeklyHours" min="0.5" max="40" step="0.5" value="5" required />
+      </label>
+    </div>
+
+    <div class="profile-table" role="group" aria-label={ui.skillProfile}>
+      <div class="profile-table-head">
+        <span>{ui.skillProfile}</span>
+        <span>{ui.currentLevel}</span>
+        <span>{ui.targetLevel}</span>
+      </div>
+      {SKILL_KEYS.map((key) => {
+        const [current, target] = skillDefaults[key];
+        return (
+          <div class="skill-input-row">
+            <span class="skill-input-label">{skillLabels[key]}</span>
+            <div class="choice" data-choice>
+              <input type="hidden" name={`${key}Current`} value={current} />
+              <button type="button" class="choice-trigger" aria-label={`${skillLabels[key]} ${ui.currentLevel}`} aria-haspopup="listbox" aria-expanded="false">{current}</button>
+              <div class="choice-menu" role="listbox" hidden>
+                {CEFR_LEVELS.map((level) => <button type="button" role="option" data-choice-value={level} aria-selected={level === current}>{level}</button>)}
+              </div>
+            </div>
+            <div class="choice" data-choice>
+              <input type="hidden" name={`${key}Target`} value={target} />
+              <button type="button" class="choice-trigger" aria-label={`${skillLabels[key]} ${ui.targetLevel}`} aria-haspopup="listbox" aria-expanded="false">{target}</button>
+              <div class="choice-menu" role="listbox" hidden>
+                {CEFR_LEVELS.map((level) => <button type="button" role="option" data-choice-value={level} aria-selected={level === target}>{level}</button>)}
+              </div>
+            </div>
+          </div>
+        );
+      })}
+    </div>
+
+    <p class="profile-note">{ui.plannerNote} {ui.hoursEstimateNote}</p>
+    <div class="preset-strip" aria-label={ui.presetLabel}>
+      <span>{ui.presetLabel}</span>
+      <button type="button" data-profile-preset="gentle">{ui.gentlePreset}</button>
+      <button type="button" data-profile-preset="steady">{ui.steadyPreset}</button>
+      <button type="button" data-profile-preset="focused">{ui.focusedPreset}</button>
+    </div>
+    <div class="profile-actions">
+      <button class="profile-submit" type="submit">{ui.planButton}</button>
+      <button class="profile-reset" type="reset">{ui.resetButton}</button>
+    </div>
+  </form>
+
+  <section class="profile-result" aria-live="polite" aria-atomic="true">
+    <div class="result-title-row">
+      <h2>{ui.resultTitle}</h2>
+      <span class="result-routes" aria-hidden="true"><i></i><i></i><i></i><i></i><i></i></span>
+    </div>
+    <div data-profile-results>
+      <div class="profile-empty">
+        <span class="empty-atlas" aria-hidden="true"><i></i><i></i><i></i><i></i><i></i></span>
+        <span>{ui.emptyResult}</span>
+      </div>
+    </div>
+  </section>
+</div>
+
+<script>
+  import { mountCefrProfile } from './controller';
+  import type { CefrSkillProfileUI } from './ui';
+
+  const root = document.querySelector<HTMLElement>('[data-cefr-profile]');
+  if (root) mountCefrProfile(root, JSON.parse(root.dataset.ui ?? '{}') as CefrSkillProfileUI);
+</script>

package/src/tool/cefr-language-skill-profile-planner/controller.ts

@@ -0,0 +1,158 @@
+import { calculateCefrProfile, SKILL_KEYS } from './logic';
+import { renderEmpty, renderError, renderProfile } from './dom-views';
+import { clearSavedInputs, readSavedInputs, saveInputs } from './storage';
+import type { CefrPlannerInputs, CefrLevel } from './types';
+import type { CefrSkillProfileUI } from './ui';
+
+export function mountCefrProfile(root: HTMLElement, ui: CefrSkillProfileUI): void {
+  const form = root.querySelector<HTMLFormElement>('[data-profile-form]');
+  if (!form) return;
+  applySavedInputs(form, readSavedInputs());
+  setDefaultDate(form);
+  setupChoices(root, form);
+  form.addEventListener('submit', (event) => submitProfile(event, root, form, ui));
+  form.addEventListener('reset', () => resetProfile(root, form, ui));
+  root.querySelectorAll<HTMLButtonElement>('[data-profile-preset]').forEach((button) => button.addEventListener('click', () => applyPreset(button.dataset.profilePreset, form)));
+}
+
+function submitProfile(event: SubmitEvent, root: HTMLElement, form: HTMLFormElement, ui: CefrSkillProfileUI): void {
+  event.preventDefault();
+  const result = calculateCefrProfile(readInputs(form));
+  if (!result.ok) {
+    renderError(root, translateError(result.error, ui), ui);
+    return;
+  }
+  saveInputs(result.plan.inputs);
+  renderProfile(root, result.plan, ui);
+}
+
+function resetProfile(root: HTMLElement, form: HTMLFormElement, ui: CefrSkillProfileUI): void {
+  window.setTimeout(() => {
+    clearSavedInputs();
+    setDefaultDate(form);
+    syncChoices(form);
+    renderEmpty(root, ui);
+  }, 0);
+}
+
+function setupChoices(root: HTMLElement, form: HTMLFormElement): void {
+  root.querySelectorAll<HTMLElement>('[data-choice]').forEach((choice) => {
+    const trigger = choice.querySelector<HTMLButtonElement>('.choice-trigger');
+    const menu = choice.querySelector<HTMLElement>('.choice-menu');
+    if (!trigger || !menu) return;
+    trigger.addEventListener('click', () => toggleChoice(trigger, menu));
+    choice.querySelectorAll<HTMLButtonElement>('[data-choice-value]').forEach((option) => option.addEventListener('click', () => chooseValue(form, choice, option)));
+    trigger.addEventListener('keydown', (event) => closeOnEscape(event, trigger, menu));
+    document.addEventListener('click', (event) => closeOutside(event, choice, trigger, menu));
+  });
+  syncChoices(form);
+}
+
+function toggleChoice(trigger: HTMLButtonElement, menu: HTMLElement): void {
+  const isOpen = trigger.getAttribute('aria-expanded') === 'true';
+  closeMenus();
+  trigger.setAttribute('aria-expanded', String(!isOpen));
+  menu.hidden = isOpen;
+}
+
+function chooseValue(form: HTMLFormElement, choice: HTMLElement, option: HTMLButtonElement): void {
+  const hidden = choice.querySelector<HTMLInputElement>('input[type="hidden"]');
+  const trigger = choice.querySelector<HTMLButtonElement>('.choice-trigger');
+  const menu = choice.querySelector<HTMLElement>('.choice-menu');
+  if (!hidden || !trigger || !menu) return;
+  hidden.value = option.dataset.choiceValue ?? hidden.value;
+  trigger.textContent = hidden.value;
+  choice.querySelectorAll<HTMLButtonElement>('[data-choice-value]').forEach((item) => item.setAttribute('aria-selected', String(item === option)));
+  trigger.setAttribute('aria-expanded', 'false');
+  menu.hidden = true;
+  form.dispatchEvent(new Event('change', { bubbles: true }));
+}
+
+function syncChoices(form: HTMLFormElement): void {
+  form.querySelectorAll<HTMLElement>('[data-choice]').forEach((choice) => {
+    const hidden = choice.querySelector<HTMLInputElement>('input[type="hidden"]');
+    const trigger = choice.querySelector<HTMLButtonElement>('.choice-trigger');
+    if (!hidden || !trigger) return;
+    trigger.textContent = hidden.value;
+    choice.querySelectorAll<HTMLButtonElement>('[data-choice-value]').forEach((option) => option.setAttribute('aria-selected', String(option.dataset.choiceValue === hidden.value)));
+  });
+}
+
+function closeOnEscape(event: KeyboardEvent, trigger: HTMLButtonElement, menu: HTMLElement): void {
+  if (event.key !== 'Escape') return;
+  trigger.setAttribute('aria-expanded', 'false');
+  menu.hidden = true;
+  trigger.focus();
+}
+
+function closeOutside(event: MouseEvent, choice: HTMLElement, trigger: HTMLButtonElement, menu: HTMLElement): void {
+  if (choice.contains(event.target as Node)) return;
+  trigger.setAttribute('aria-expanded', 'false');
+  menu.hidden = true;
+}
+
+function closeMenus(): void {
+  document.querySelectorAll<HTMLElement>('[data-choice]').forEach((choice) => {
+    choice.querySelector<HTMLButtonElement>('.choice-trigger')?.setAttribute('aria-expanded', 'false');
+    const menu = choice.querySelector<HTMLElement>('.choice-menu');
+    if (menu) menu.hidden = true;
+  });
+}
+
+function readInputs(form: HTMLFormElement): CefrPlannerInputs {
+  const skills = Object.fromEntries(SKILL_KEYS.map((key) => [key, { current: value(form, `${key}Current`) as CefrLevel, target: value(form, `${key}Target`) as CefrLevel }])) as CefrPlannerInputs['skills'];
+  return { targetDate: value(form, 'targetDate'), weeklyHours: Number(value(form, 'weeklyHours')), skills };
+}
+
+function applySavedInputs(form: HTMLFormElement, saved: Partial<CefrPlannerInputs> | null): void {
+  if (!saved) return;
+  setValue(form, 'targetDate', saved.targetDate);
+  setValue(form, 'weeklyHours', saved.weeklyHours);
+  if (!saved.skills) return;
+  SKILL_KEYS.forEach((key) => {
+    setValue(form, `${key}Current`, saved.skills?.[key]?.current);
+    setValue(form, `${key}Target`, saved.skills?.[key]?.target);
+  });
+}
+
+function applyPreset(preset: string | undefined, form: HTMLFormElement): void {
+  setValue(form, 'weeklyHours', getPresetHours(preset));
+  form.requestSubmit();
+}
+
+function getPresetHours(preset: string | undefined): number {
+  if (preset === 'gentle') return 3;
+  if (preset === 'focused') return 10;
+  return 5;
+}
+
+function setDefaultDate(form: HTMLFormElement): void {
+  const input = form.elements.namedItem('targetDate') as HTMLInputElement | null;
+  if (!input) return;
+  input.min = new Date().toISOString().slice(0, 10);
+  if (input.value) return;
+  const date = new Date();
+  date.setUTCDate(date.getUTCDate() + 180);
+  input.value = date.toISOString().slice(0, 10);
+}
+
+function translateError(error: string, ui: CefrSkillProfileUI): string {
+  if (error.includes('future')) return ui.futureDateError;
+  if (error.includes('valid target date')) return ui.dateFormatError;
+  if (error.includes('Weekly')) return ui.hoursError;
+  if (error.includes('below')) return ui.targetBelowCurrentError;
+  if (error.includes('at least one')) return ui.noProgressError;
+  return error;
+}
+
+function value(form: HTMLFormElement, name: string): string {
+  return String((form.elements.namedItem(name) as HTMLInputElement | HTMLSelectElement).value);
+}
+
+function setValue(form: HTMLFormElement, name: string, valueToSet: unknown): void {
+  if (valueToSet === undefined) return;
+  const field = form.elements.namedItem(name) as HTMLInputElement | HTMLSelectElement | null;
+  if (!field) return;
+  field.value = String(valueToSet);
+  if (field.closest('[data-choice]')) syncChoices(form);
+}

package/src/tool/cefr-language-skill-profile-planner/dom-views.ts

@@ -0,0 +1,154 @@
+import { CEFR_LEVELS } from './logic';
+import type { CefrProfilePlan, SkillKey, SkillMilestone, SkillPlan } from './types';
+import type { CefrSkillProfileUI } from './ui';
+
+const skillLabelKeys: Record<SkillKey, keyof CefrSkillProfileUI> = {
+  listening: 'skillListening', reading: 'skillReading', spokenInteraction: 'skillSpokenInteraction', spokenProduction: 'skillSpokenProduction', writing: 'skillWriting',
+};
+
+export function renderProfile(root: HTMLElement, plan: CefrProfilePlan, ui: CefrSkillProfileUI): void {
+  const results = root.querySelector<HTMLElement>('[data-profile-results]');
+  if (!results) return;
+  results.replaceChildren(createStatus(plan, ui), createOverview(plan, ui), createSkillScene(plan, ui), createMilestoneList(plan, ui));
+}
+
+export function renderEmpty(root: HTMLElement, ui: CefrSkillProfileUI): void {
+  const results = root.querySelector<HTMLElement>('[data-profile-results]');
+  if (!results) return;
+  const empty = document.createElement('div');
+  empty.className = 'profile-empty';
+  empty.textContent = ui.emptyResult;
+  results.replaceChildren(empty);
+}
+
+export function renderError(root: HTMLElement, message: string, ui: CefrSkillProfileUI): void {
+  const results = root.querySelector<HTMLElement>('[data-profile-results]');
+  if (!results) return;
+  const error = document.createElement('div');
+  error.className = 'profile-error';
+  error.append(createText('profile-error-title', ui.checkInputs), createText('profile-error-copy', message));
+  results.replaceChildren(error);
+}
+
+function createStatus(plan: CefrProfilePlan, ui: CefrSkillProfileUI): HTMLElement {
+  const status = document.createElement('div');
+  status.className = `profile-status ${plan.status}`;
+  status.append(createText('profile-status-label', getStatusLabel(plan.status, ui)), createText('profile-status-detail', `${formatNumber(plan.availableHours)} ${ui.hours}`));
+  return status;
+}
+
+function getStatusLabel(status: CefrProfilePlan['status'], ui: CefrSkillProfileUI): string {
+  if (status === 'on-track') return ui.statusOnTrack;
+  if (status === 'tight') return ui.statusTight;
+  return ui.statusInsufficient;
+}
+
+function createOverview(plan: CefrProfilePlan, ui: CefrSkillProfileUI): HTMLElement {
+  const overview = document.createElement('div');
+  overview.className = 'profile-overview';
+  overview.append(metric(ui.totalHours, `${formatNumber(plan.totalHoursLow)} to ${formatNumber(plan.totalHoursHigh)} ${ui.hours}`), metric(ui.availableHours, `${formatNumber(plan.availableHours)} ${ui.hours}`), metric(ui.weeksAvailable, `${plan.weeksAvailable} ${ui.week}`));
+  return overview;
+}
+
+function createSkillScene(plan: CefrProfilePlan, ui: CefrSkillProfileUI): HTMLElement {
+  const section = document.createElement('section');
+  section.className = 'profile-scene';
+  section.append(createHeading(ui.skillProfile));
+  section.append(createAtlasScene(plan, ui), createSkillReadout(plan, ui));
+  return section;
+}
+
+function createAtlasScene(plan: CefrProfilePlan, ui: CefrSkillProfileUI): SVGSVGElement {
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+  svg.classList.add('atlas-scene');
+  svg.setAttribute('viewBox', '0 0 760 280');
+  svg.setAttribute('aria-hidden', 'true');
+  plan.skills.forEach((skill, index) => appendAtlasRoute(svg, skill, ui, index));
+  return svg;
+}
+
+function appendAtlasRoute(svg: SVGSVGElement, skill: SkillPlan, ui: CefrSkillProfileUI, index: number): void {
+  const y = 30 + index * 52;
+  const start = 150 + CEFR_LEVELS.indexOf(skill.current) * 82;
+  const end = 150 + CEFR_LEVELS.indexOf(skill.target) * 82;
+  const route = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+  route.classList.add('atlas-route');
+  route.dataset.skill = skill.key;
+  route.setAttribute('d', `M ${start} ${y} C ${(start + end) / 2} ${y - 25}, ${(start + end) / 2} ${y + 25}, ${end} ${y}`);
+  const current = createSvgText(18, y + 5, skill.current, 'atlas-level atlas-current');
+  const target = createSvgText(675, y + 5, `${ui[skillLabelKeys[skill.key]] ?? ''} ${skill.target}`, 'atlas-level atlas-target');
+  const startDot = createSvgCircle(start, y, 'atlas-dot atlas-start');
+  const endDot = createSvgCircle(end, y, 'atlas-dot atlas-end');
+  svg.append(route, startDot, endDot, current, target);
+}
+
+function createSkillReadout(plan: CefrProfilePlan, ui: CefrSkillProfileUI): HTMLElement {
+  const readout = document.createElement('div');
+  readout.className = 'skill-readout';
+  plan.skills.forEach((skill) => {
+    const row = document.createElement('div');
+    row.className = 'skill-readout-row';
+    row.dataset.skill = skill.key;
+    row.append(createText('skill-name', ui[skillLabelKeys[skill.key]] ?? ''), createText('skill-route', `${skill.current} to ${skill.target}`), createText('skill-allocation', skill.gapLevels ? `${skill.allocation}%` : ui.noGap));
+    readout.append(row);
+  });
+  return readout;
+}
+
+function createSvgText(x: number, y: number, text: string, className: string): SVGTextElement {
+  const element = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+  element.classList.add(...className.split(' '));
+  element.setAttribute('x', String(x));
+  element.setAttribute('y', String(y));
+  element.textContent = text;
+  return element;
+}
+
+function createSvgCircle(cx: number, cy: number, className: string): SVGCircleElement {
+  const element = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
+  element.classList.add(...className.split(' '));
+  element.setAttribute('cx', String(cx));
+  element.setAttribute('cy', String(cy));
+  element.setAttribute('r', '7');
+  return element;
+}
+
+function createMilestoneList(plan: CefrProfilePlan, ui: CefrSkillProfileUI): HTMLElement {
+  const section = document.createElement('section');
+  section.className = 'profile-milestones';
+  section.append(createHeading(ui.milestoneMap));
+  const list = document.createElement('div');
+  list.className = 'milestone-list';
+  plan.milestones.forEach((milestone) => list.append(createMilestone(milestone, ui)));
+  section.append(list);
+  return section;
+}
+
+function createMilestone(milestone: SkillMilestone, ui: CefrSkillProfileUI): HTMLElement {
+  const item = document.createElement('div');
+  item.className = 'milestone-item';
+  item.append(createText('milestone-skill', ui[skillLabelKeys[milestone.key]] ?? ''), createText('milestone-level', milestone.level), createText('milestone-date', `${ui.week} ${milestone.week} - ${milestone.date}`));
+  return item;
+}
+
+function createHeading(text: string): HTMLElement {
+  return createText('section-heading', text);
+}
+
+function metric(label: string, value: string): HTMLElement {
+  const item = document.createElement('div');
+  item.className = 'profile-metric';
+  item.append(createText('metric-label', label), createText('metric-value', value));
+  return item;
+}
+
+function createText(className: string, text: string): HTMLElement {
+  const element = document.createElement('span');
+  element.className = className;
+  element.textContent = text;
+  return element;
+}
+
+function formatNumber(value: number): string {
+  return new Intl.NumberFormat(undefined, { maximumFractionDigits: 1 }).format(value);
+}

package/src/tool/cefr-language-skill-profile-planner/entry.ts

@@ -0,0 +1,34 @@
+import type { LanguageToolEntry, ToolDefinition, ToolLocaleContent } from '../../types';
+import type { CefrSkillProfileUI } from './ui';
+
+export type { CefrSkillProfileUI } from './ui';
+export type CefrLanguageSkillProfilePlannerLocaleContent = ToolLocaleContent<CefrSkillProfileUI>;
+
+export const cefrLanguageSkillProfilePlanner: LanguageToolEntry<CefrSkillProfileUI> = {
+  id: 'cefr-language-skill-profile-planner',
+  icons: { bg: 'mdi:chart-timeline-variant-shimmer', fg: 'mdi:translate' },
+  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),
+  },
+};
+
+export const CEFR_LANGUAGE_SKILL_PROFILE_PLANNER_TOOL: ToolDefinition = {
+  entry: cefrLanguageSkillProfilePlanner,
+  Component: () => import('./component.astro'),
+  SEOComponent: () => import('./seo.astro'),
+  BibliographyComponent: () => import('./bibliography.astro'),
+};

package/src/tool/cefr-language-skill-profile-planner/evaluator.ts

@@ -0,0 +1,12 @@
+import type { CefrProfilePlan, ProfileStatus } from './types';
+
+export interface StatusCopy {
+  status: ProfileStatus;
+  messageKey: 'statusOnTrack' | 'statusTight' | 'statusInsufficient';
+}
+
+export function evaluateStatus(plan: CefrProfilePlan): StatusCopy {
+  if (plan.status === 'on-track') return { status: plan.status, messageKey: 'statusOnTrack' };
+  if (plan.status === 'tight') return { status: plan.status, messageKey: 'statusTight' };
+  return { status: plan.status, messageKey: 'statusInsufficient' };
+}

package/src/tool/cefr-language-skill-profile-planner/i18n/de.ts

@@ -0,0 +1,26 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CefrSkillProfileUI } from '../ui';
+
+const ui: CefrSkillProfileUI = {
+  targetDate: 'Zieldatum', weeklyHours: 'Lernzeit pro Woche', listening: 'Hörverstehen', reading: 'Leseverstehen', spokenInteraction: 'Mündliche Interaktion', spokenProduction: 'Mündlicher Ausdruck', writing: 'Schreiben', currentLevel: 'Aktuelles Niveau', targetLevel: 'Zielniveau', planButton: 'Mein Profil abbilden', resetButton: 'Zurücksetzen', presetLabel: 'Mit einem Tempo starten', gentlePreset: '3 Stunden', steadyPreset: '5 Stunden', focusedPreset: '10 Stunden', resultTitle: 'Dein Kompetenzprofil', emptyResult: 'Lege deine fünf aktuellen Niveaus, Ziele, dein Datum und deine Wochenzeit fest, um die Profilkarte zu sehen.', statusOnTrack: 'Dein Kalender bietet genug Spielraum für die Schätzung.', statusTight: 'Dein Kalender erreicht die untere Schätzung.', statusInsufficient: 'Dein Kalender ist kürzer als die untere Schätzung.', totalHours: 'Geschätzte angeleitete Lernstunden', availableHours: 'Verfügbare Stunden', weeksAvailable: 'Verfügbare Wochen', skillProfile: 'Fünf Kompetenzpfade', milestoneMap: 'Meilensteinkarte', hours: 'Stunden', week: 'Woche', noGap: 'Auf Zielniveau', checkInputs: 'Eingaben prüfen', futureDateError: 'Wähle ein Zieldatum in der Zukunft.', dateFormatError: 'Wähle ein gültiges Zieldatum.', hoursError: 'Die wöchentliche Lernzeit muss zwischen 0,5 und 40 Stunden liegen.', targetBelowCurrentError: 'Ein Zielniveau darf nicht unter dem aktuellen Niveau liegen.', noProgressError: 'Erhöhe mindestens ein Zielniveau, um einen Lernplan zu erstellen.', plannerNote: 'Nutze die GER-Niveaus als Ausgangspunkt für eine Selbsteinschätzung, nicht als Prüfungsergebnis.', hoursEstimateNote: 'Die Stundenangabe ist ein Planungsbereich und verändert sich je nach sprachlicher Distanz, Kontakt und Lernqualität.', skillListening: 'Hörverstehen', skillReading: 'Leseverstehen', skillSpokenInteraction: 'Mündliche Interaktion', skillSpokenProduction: 'Mündlicher Ausdruck', skillWriting: 'Schreiben',
+};
+
+const faq = [
+  { question: 'Was berechnet der Planer für das GER-Kompetenzprofil?', answer: 'Er vergleicht das aktuelle und das angestrebte GER-Niveau für Hörverstehen, Leseverstehen, mündliche Interaktion, mündlichen Ausdruck und Schreiben. Danach schätzt er einen Bereich angeleiteter Lernstunden, vergleicht ihn mit deinen verfügbaren Wochen und verteilt den Aufwand auf die Kompetenzen mit einer Lücke.' },
+  { question: 'Kann ich das als Sprachtest verwenden?', answer: 'Nein. Der Planer ordnet eine Selbsteinschätzung und einen Lernaufwand. Er prüft keine Leistung, bestätigt kein Zertifikat und garantiert nicht, dass du bis zu einem bestimmten Datum ein Niveau erreichst.' },
+  { question: 'Warum werden die Stunden als Bereich angezeigt?', answer: 'Der Fortschritt hängt von sprachlicher Distanz, Vorerfahrung, Kontakt, Unterrichtsqualität, Übungsmöglichkeiten und der Art der verwendeten Nachweise ab. Der Bereich ist deshalb bewusst eine Planungshilfe und kein Versprechen.' },
+  { question: 'Wie verteilt der Planer die Wochenzeit?', answer: 'Kompetenzen mit größeren Niveaulücken erhalten einen größeren Anteil der Wochenzeit. Kompetenzen, die bereits ihr Ziel erreicht haben, werden als auf Zielniveau angezeigt und erhalten keinen geplanten Anteil.' },
+  { question: 'Was soll ich bei einem unzureichenden Status tun?', answer: 'Erhöhe die realistische Wochenzeit, verschiebe das Zieldatum oder senke eines oder mehrere Zielniveaus. Prüfe das Profil nach einem festen Lernabschnitt erneut, statt versäumte Stunden auf einmal nachzuholen.' },
+];
+
+const appSchema: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Planer für GER Sprachkompetenzprofile', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', isAccessibleForFree: true, url: 'https://gamebob.dev/de/cefr-sprachkompetenz-profil-planer' };
+const howToSchema: HowTo = { '@type': 'HowTo', name: 'Einen Lernplan für ein GER Kompetenzprofil erstellen', step: [{ '@type': 'HowToStep', name: 'Datum festlegen', text: 'Wähle das Datum, an dem du dein Zielprofil überprüfen möchtest.' }, { '@type': 'HowToStep', name: 'Kompetenzen einschätzen', text: 'Wähle für alle fünf Kompetenzen ein aktuelles und ein angestrebtes GER Niveau.' }, { '@type': 'HowToStep', name: 'Wochenzeit schützen', text: 'Gib die Lernzeit ein, die du jede Woche nachhaltig aufbringen kannst.' }, { '@type': 'HowToStep', name: 'Karte lesen', text: 'Nutze Status, Kompetenzpfade und Meilensteine, um den Plan anzupassen.' }] };
+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<CefrSkillProfileUI> = {
+  slug: 'cefr-sprachkompetenz-profil-planer', title: 'Planer für GER Sprachkompetenzprofile', description: 'Ordne aktuelle und angestrebte GER Niveaus für fünf Sprachkompetenzen, schätze angeleitete Lernstunden und setze realistische Meilensteine.', ui,
+  seo: [{ type: 'title', text: 'Ein Sprachziel über fünf Kompetenzen abbilden', level: 2 }, { type: 'paragraph', html: 'Ein einziges Sprachniveau kann ein ungleichmäßiges Profil verbergen. Vielleicht liest du auf B1, verstehst Gespräche aber erst auf A2 und brauchst beim Sprechen noch mehr Übung. Dieser Planer macht die Unterschiede sichtbar und verwandelt sie in einen Arbeits- und Meilensteinplan.' }, { type: 'title', text: 'So funktioniert die Profilschätzung', level: 2 }, { type: 'paragraph', html: 'Die Berechnung ordnet jedem GER Schritt einen breiten Bereich angeleiteter Lernstunden zu und addiert die Bereiche für jede Kompetenz mit einer Lücke. Die Wochenzeit folgt dem Mittelwert jedes Bereichs, sodass eine Lücke von zwei Niveaus mehr Zeit erhält als eine Lücke von einem Niveau. Das Ergebnis ist ein Planungsmodell, keine Leistungsmessung.' }, { type: 'title', text: 'Den Kalenderstatus lesen', level: 2 }, { type: 'table', headers: ['Status', 'Bedeutung', 'Nächster sinnvoller Schritt'], rows: [['Spielraum für die Schätzung', 'Die verfügbaren Stunden reichen bis zum oberen Ende des kombinierten Bereichs.', 'Behalte die Routine bei und nutze die Meilensteine als Prüfzeitpunkte.'], ['Untere Schätzung erreicht', 'Die verfügbaren Stunden reichen bis zum unteren, aber nicht bis zum oberen Ende.', 'Halte das Ziel flexibel und reserviere Zeit für Feedback und Wiederholung.'], ['Kürzer als die Schätzung', 'Die verfügbaren Stunden erreichen nicht das untere Ende des kombinierten Bereichs.', 'Verschiebe das Datum, reduziere ein Ziel oder erhöhe die nachhaltige Lernzeit.']] }, { type: 'title', text: 'Meilensteine mit Nachweisen verbinden', level: 2 }, { type: 'paragraph', html: 'Nutze jeden Meilenstein als Anlass, Nachweise zu sammeln, nicht als automatische Beförderung. Halte eine Hörprobe, ein kurzes Gespräch, eine Leseaufgabe und einen Text fest, die zum angestrebten Beschreibungsniveau passen. Wenn eine Kompetenz stagniert, ändere ihre Übung statt die Lücke in einem Gesamtdurchschnitt zu verstecken.' }, { type: 'list', items: ['Wähle Niveaus aus Aufgaben, die du konkret beschreiben kannst.', 'Halte die Wochenzeit über den gesamten Kalender nachhaltig.', 'Prüfe das Profil nach einem festen Lernblock und ändere jeweils nur eine Variable.', 'Nutze Lehrkraftfeedback oder eine offizielle Prüfung, wenn das Niveau für Studium, Arbeit oder Einwanderung zählt.'] }, { type: 'tip', title: 'Grenzen der Schätzung', html: 'Der GER beschreibt kommunikative Fähigkeiten anhand von Deskriptoren und schreibt keine universelle Stundenzahl vor. Sprachdistanz, Erfahrung, Kontakt, Feedback und Lernbedingungen können den tatsächlichen Aufwand deutlich verändern. Behandle diesen Plan nicht als Zertifikat oder Garantie.' }],
+  faq, bibliography: [{ name: 'Europarat: Gemeinsamer europäischer Referenzrahmen für Sprachen', url: 'https://rm.coe.int/marco-comun-europeo-de-referencia-para-las-lenguas-aprendizaje-ensenan/1680a52d53' }, { name: 'Cambridge English: Guided learning hours', url: 'https://support.cambridgeenglish.org/hc/en-gb/articles/202838506-Guided-learning-hours' }], howTo: [{ name: 'Datum festlegen', text: 'Wähle das Datum, an dem du dein Zielprofil überprüfen möchtest.' }, { name: 'Kompetenzen einschätzen', text: 'Wähle aktuelle und angestrebte GER Niveaus für alle fünf Kompetenzen.' }, { name: 'Wochenzeit schützen', text: 'Gib eine Lernzeit ein, die du jede Woche nachhaltig einhalten kannst, und bilde dein Profil ab.' }, { name: 'Lesen und anpassen', text: 'Nutze Status, Pfade und Meilensteine, um den Plan nach echter Übung zu überarbeiten.' }], schemas: [withContext(appSchema), withContext(howToSchema), withContext(faqSchema)],
+};

package/src/tool/cefr-language-skill-profile-planner/i18n/en.ts

@@ -0,0 +1,59 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CefrSkillProfileUI } from '../ui';
+
+const ui: CefrSkillProfileUI = {
+  targetDate: 'Target date', weeklyHours: 'Study time per week', listening: 'Listening', reading: 'Reading', spokenInteraction: 'Spoken interaction', spokenProduction: 'Spoken production', writing: 'Writing', currentLevel: 'Current level', targetLevel: 'Target level', planButton: 'Map my profile', resetButton: 'Reset', presetLabel: 'Start with a pace', gentlePreset: '3 hours', steadyPreset: '5 hours', focusedPreset: '10 hours', resultTitle: 'Your skill profile', emptyResult: 'Set your five current levels, target levels, date, and weekly time to reveal the profile map.', statusOnTrack: 'Your calendar has room for the estimate.', statusTight: 'Your calendar reaches the lower estimate.', statusInsufficient: 'Your calendar is shorter than the lower estimate.', totalHours: 'Estimated guided hours', availableHours: 'Hours available', weeksAvailable: 'Weeks available', skillProfile: 'Five skill paths', milestoneMap: 'Milestone map', hours: 'hours', week: 'week', noGap: 'At level', checkInputs: 'Check your inputs', futureDateError: 'Choose a target date in the future.', dateFormatError: 'Choose a valid target date.', hoursError: 'Weekly study time must be between 0.5 and 40 hours.', targetBelowCurrentError: 'A target level cannot be below the current level.', noProgressError: 'Raise at least one target level to make a profile plan.', plannerNote: 'Use the CEFR levels as a self assessment starting point, not as a certification result.', hoursEstimateNote: 'The hour range is a planning band and changes with language distance, exposure, and study quality.', skillListening: 'Listening', skillReading: 'Reading', skillSpokenInteraction: 'Spoken interaction', skillSpokenProduction: 'Spoken production', skillWriting: 'Writing',
+};
+
+const faq = [
+  { question: 'What does the CEFR skill profile planner calculate?', answer: 'It compares a current and target CEFR level for listening, reading, spoken interaction, spoken production, and writing. It estimates a guided hour range, compares it with your available weeks, and divides the effort across the skills that have a gap.' },
+  { question: 'Can I use this as a language test?', answer: 'No. The planner organizes a self assessment and a study workload. It does not test performance, verify a certificate, or predict that you will reach a level by a particular date.' },
+  { question: 'Why are the hours shown as a range?', answer: 'Progress varies with language distance, previous exposure, teaching quality, practice opportunities, and the kind of evidence used to judge a level. The range is deliberately a planning band rather than a promise.' },
+  { question: 'How does the planner divide weekly time?', answer: 'Skills with larger level gaps receive a larger share of the weekly time. Skills already at their target are shown as at level and receive no planned share.' },
+  { question: 'What should I do when the status is insufficient?', answer: 'Add realistic weekly time, move the target date, or lower one or more target levels. Recheck the profile after a study checkpoint instead of trying to make up every missed hour at once.' },
+];
+
+const appSchema: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'CEFR Language Skill Profile Planner', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', isAccessibleForFree: true, url: 'https://gamebob.dev/en/cefr-language-skill-profile-planner' };
+const howToSchema: HowTo = { '@type': 'HowTo', name: 'Build a CEFR skill profile plan', step: [
+  { '@type': 'HowToStep', name: 'Set your date', text: 'Choose the date by which you want to review the target profile.' },
+  { '@type': 'HowToStep', name: 'Rate each skill', text: 'Choose a current and target CEFR level for all five skills.' },
+  { '@type': 'HowToStep', name: 'Protect weekly time', text: 'Enter the study time you can sustain every week.' },
+  { '@type': 'HowToStep', name: 'Read the map', text: 'Use the status, skill paths, and milestone dates to adjust the plan.' },
+] };
+const faqSchema: FAQPage = { '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) };
+
+function withContext(schema: SoftwareApplication | HowTo | FAQPage): Record<string, unknown> {
+  return { '@context': 'https://schema.org', ...schema };
+}
+
+export const content: ToolLocaleContent<CefrSkillProfileUI> = {
+  slug: 'cefr-language-skill-profile-planner',
+  title: 'CEFR Language Skill Profile Planner',
+  description: 'Map current and target CEFR levels across five language skills, estimate guided hours, and set milestones for a realistic study plan.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Map a Language Goal Across Five Skills', level: 2 },
+    { type: 'paragraph', html: 'A single language level can hide an uneven profile. You may read at B1, listen at A2, and still need more practice in spoken interaction. This planner makes those differences visible by asking for a current and target CEFR level for each skill, then turning the gaps into a workload and milestone map.' },
+    { type: 'title', text: 'How the Profile Estimate Works', level: 2 },
+    { type: 'paragraph', html: 'The calculation assigns a broad guided hour band to each CEFR step and adds the bands for every skill with a gap. The weekly allocation follows the midpoint of each skill range, so a two level listening gap receives more of the available time than a one level writing gap. The result is a planning model, not a measurement of ability.' },
+    { type: 'title', text: 'Read the Calendar Status', level: 2 },
+    { type: 'table', headers: ['Status', 'Meaning', 'Useful next move'], rows: [['Room for the estimate', 'Available hours reach the upper end of the combined range.', 'Keep the routine and use the milestone dates as review points.'], ['Lower estimate reached', 'Available hours reach the lower end but not the upper end.', 'Keep the goal flexible and protect time for feedback and review.'], ['Shorter than the estimate', 'Available hours do not reach the lower end of the combined range.', 'Move the date, reduce a target, or add sustainable time.']] },
+    { type: 'title', text: 'Turn Milestones Into Evidence', level: 2 },
+    { type: 'paragraph', html: 'Use each milestone as a reason to collect evidence, not as an automatic promotion. Record a listening sample, a short conversation, a reading task, and a piece of writing that match the descriptor level you are targeting. If one skill stalls, change its practice rather than hiding the gap inside an overall average.' },
+    { type: 'list', items: ['Choose levels from recent tasks you can actually describe.', 'Keep the weekly time sustainable for the whole calendar.', 'Review the profile after a fixed study block and adjust one variable.', 'Use teacher feedback or an official assessment when the level matters for admission, work, or immigration.'] },
+    { type: 'tip', title: 'Limits of the estimate', html: 'The CEFR describes communicative ability through descriptors; it does not prescribe one universal number of hours. Language distance, previous experience, exposure, feedback, and study conditions can move the real workload substantially. Do not treat this plan as a certificate, a guarantee, or medical or legal advice.' },
+  ],
+  faq,
+  bibliography: [
+    { name: 'Council of Europe: Marco común europeo de referencia para las lenguas, volumen complementario', url: 'https://rm.coe.int/marco-comun-europeo-de-referencia-para-las-lenguas-aprendizaje-ensenan/1680a52d53' },
+    { name: 'Cambridge English: Guided learning hours', url: 'https://support.cambridgeenglish.org/hc/en-gb/articles/202838506-Guided-learning-hours' },
+  ],
+  howTo: [
+    { name: 'Set your date', text: 'Choose the date by which you want to review the target profile.' },
+    { name: 'Rate each skill', text: 'Choose a current and target CEFR level for listening, reading, spoken interaction, spoken production, and writing.' },
+    { name: 'Protect weekly time', text: 'Enter the study time you can sustain every week, then map the profile.' },
+    { name: 'Read and revise', text: 'Use the status, skill paths, and milestone dates to adjust the plan after real practice.' },
+  ],
+  schemas: [withContext(appSchema), withContext(howToSchema), withContext(faqSchema)],
+};

package/src/tool/cefr-language-skill-profile-planner/i18n/es.ts

@@ -0,0 +1,15 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CefrSkillProfileUI } from '../ui';
+
+const ui: CefrSkillProfileUI = {
+  targetDate: 'Fecha objetivo', weeklyHours: 'Tiempo de estudio semanal', listening: 'Comprensión auditiva', reading: 'Comprensión lectora', spokenInteraction: 'Interacción oral', spokenProduction: 'Producción oral', writing: 'Expresión escrita', currentLevel: 'Nivel actual', targetLevel: 'Nivel objetivo', planButton: 'Mapear mi perfil', resetButton: 'Restablecer', presetLabel: 'Empieza con un ritmo', gentlePreset: '3 horas', steadyPreset: '5 horas', focusedPreset: '10 horas', resultTitle: 'Tu perfil de habilidades', emptyResult: 'Indica tus cinco niveles actuales, objetivos, fecha y tiempo semanal para ver el mapa del perfil.', statusOnTrack: 'Tu calendario tiene margen para la estimación.', statusTight: 'Tu calendario alcanza la estimación inferior.', statusInsufficient: 'Tu calendario es más corto que la estimación inferior.', totalHours: 'Horas guiadas estimadas', availableHours: 'Horas disponibles', weeksAvailable: 'Semanas disponibles', skillProfile: 'Cinco rutas de habilidad', milestoneMap: 'Mapa de hitos', hours: 'horas', week: 'semana', noGap: 'En el objetivo', checkInputs: 'Revisa tus datos', futureDateError: 'Elige una fecha objetivo futura.', dateFormatError: 'Elige una fecha objetivo válida.', hoursError: 'El tiempo de estudio semanal debe estar entre 0,5 y 40 horas.', targetBelowCurrentError: 'El nivel objetivo no puede ser inferior al nivel actual.', noProgressError: 'Sube al menos un nivel objetivo para crear un plan.', plannerNote: 'Usa los niveles del MCER como punto de partida para una autoevaluación, no como resultado de certificación.', hoursEstimateNote: 'El intervalo de horas es una banda de planificación y cambia según la distancia lingüística, la exposición y la calidad del estudio.', skillListening: 'Comprensión auditiva', skillReading: 'Comprensión lectora', skillSpokenInteraction: 'Interacción oral', skillSpokenProduction: 'Producción oral', skillWriting: 'Expresión escrita',
+};
+
+const faq = [{ question: '¿Qué calcula el planificador de perfil de habilidades del MCER?', answer: 'Compara el nivel actual y el objetivo de comprensión auditiva, comprensión lectora, interacción oral, producción oral y expresión escrita. Estima un intervalo de horas guiadas, lo compara con tus semanas disponibles y reparte el esfuerzo entre las habilidades que tienen una brecha.' }, { question: '¿Puedo usarlo como una prueba de idioma?', answer: 'No. El planificador organiza una autoevaluación y una carga de estudio. No examina tu rendimiento, no verifica certificados ni predice que alcanzarás un nivel en una fecha concreta.' }, { question: '¿Por qué las horas aparecen como un intervalo?', answer: 'El progreso depende de la distancia entre lenguas, la experiencia previa, la exposición, la calidad de la enseñanza, las oportunidades de práctica y las pruebas usadas para valorar el nivel. Por eso el intervalo es una banda de planificación, no una promesa.' }, { question: '¿Cómo reparte el tiempo semanal?', answer: 'Las habilidades con brechas de nivel mayores reciben una parte mayor del tiempo semanal. Las que ya están en su objetivo aparecen como en el objetivo y no reciben una parte planificada.' }, { question: '¿Qué hago si el estado es insuficiente?', answer: 'Añade tiempo semanal realista, mueve la fecha objetivo o reduce uno o varios niveles objetivo. Revisa el perfil después de un bloque de estudio en vez de intentar recuperar todas las horas de golpe.' }];
+const appSchema: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Planificador de perfil de habilidades lingüísticas del MCER', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', isAccessibleForFree: true, url: 'https://gamebob.dev/es/planificador-perfil-habilidades-idiomas-cefr' };
+const howToSchema: HowTo = { '@type': 'HowTo', name: 'Crear un plan de perfil de habilidades del MCER', step: [{ '@type': 'HowToStep', name: 'Fija la fecha', text: 'Elige la fecha en la que quieres revisar el perfil objetivo.' }, { '@type': 'HowToStep', name: 'Valora cada habilidad', text: 'Elige un nivel actual y uno objetivo del MCER para las cinco habilidades.' }, { '@type': 'HowToStep', name: 'Protege el tiempo semanal', text: 'Indica el tiempo de estudio que puedes mantener cada semana.' }, { '@type': 'HowToStep', name: 'Lee el mapa', text: 'Usa el estado, las rutas y las fechas de los hitos para ajustar el plan.' }] };
+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<CefrSkillProfileUI> = { slug: 'planificador-perfil-habilidades-idiomas-cefr', title: 'Planificador de perfil de habilidades lingüísticas del MCER', description: 'Mapea niveles actuales y objetivos del MCER en cinco habilidades, estima horas guiadas y fija hitos para un plan de estudio realista.', ui, seo: [{ type: 'title', text: 'Mapea un objetivo lingüístico en cinco habilidades', level: 2 }, { type: 'paragraph', html: 'Un único nivel de idioma puede ocultar un perfil desigual. Quizá leas en B1, escuches en A2 y todavía necesites practicar la interacción oral. Este planificador hace visibles esas diferencias y convierte las brechas en una carga de trabajo y un mapa de hitos.' }, { type: 'title', text: 'Cómo funciona la estimación del perfil', level: 2 }, { type: 'paragraph', html: 'El cálculo asigna una banda amplia de horas guiadas a cada paso del MCER y suma las bandas de cada habilidad con una brecha. El reparto semanal sigue el punto medio de cada intervalo, así que una brecha de dos niveles recibe más tiempo que una de un nivel. Es un modelo de planificación, no una medición de capacidad.' }, { type: 'title', text: 'Interpreta el estado del calendario', level: 2 }, { type: 'table', headers: ['Estado', 'Significado', 'Siguiente paso útil'], rows: [['Margen para la estimación', 'Las horas disponibles llegan al extremo superior del intervalo combinado.', 'Mantén la rutina y usa los hitos como puntos de revisión.'], ['Estimación inferior alcanzada', 'Las horas disponibles llegan al extremo inferior, pero no al superior.', 'Mantén flexible el objetivo y protege tiempo para feedback y repaso.'], ['Por debajo de la estimación', 'Las horas disponibles no llegan al extremo inferior del intervalo combinado.', 'Mueve la fecha, reduce un objetivo o añade tiempo sostenible.']] }, { type: 'title', text: 'Convierte los hitos en evidencias', level: 2 }, { type: 'paragraph', html: 'Usa cada hito como motivo para reunir evidencias, no como una promoción automática. Guarda una muestra auditiva, una conversación breve, una tarea de lectura y un texto que correspondan al nivel descriptor que buscas. Si una habilidad se estanca, cambia su práctica en lugar de esconder la brecha dentro de una media general.' }, { type: 'list', items: ['Elige niveles a partir de tareas recientes que puedas describir.', 'Mantén un tiempo semanal sostenible durante todo el calendario.', 'Revisa el perfil después de un bloque fijo y cambia una sola variable.', 'Usa feedback docente o una evaluación oficial cuando el nivel importe para estudiar, trabajar o emigrar.'] }, { type: 'tip', title: 'Límites de la estimación', html: 'El MCER describe la capacidad comunicativa mediante descriptores y no prescribe un número universal de horas. La distancia lingüística, la experiencia, la exposición, el feedback y las condiciones de estudio pueden cambiar mucho el esfuerzo real. No trates este plan como certificado ni garantía.' }], faq, bibliography: [{ name: 'Consejo de Europa: Marco común europeo de referencia para las lenguas, volumen complementario', url: 'https://rm.coe.int/marco-comun-europeo-de-referencia-para-las-lenguas-aprendizaje-ensenan/1680a52d53' }, { name: 'Cambridge English: Guided learning hours', url: 'https://support.cambridgeenglish.org/hc/en-gb/articles/202838506-Guided-learning-hours' }], howTo: [{ name: 'Fija la fecha', text: 'Elige la fecha en la que quieres revisar el perfil objetivo.' }, { name: 'Valora cada habilidad', text: 'Elige niveles actuales y objetivos del MCER para las cinco habilidades.' }, { name: 'Protege el tiempo semanal', text: 'Indica el tiempo de estudio que puedes mantener cada semana y mapea el perfil.' }, { name: 'Lee y revisa', text: 'Usa el estado, las rutas y las fechas de los hitos para ajustar el plan después de practicar.' }], schemas: [withContext(appSchema), withContext(howToSchema), withContext(faqSchema)] };