@jjlmoya/utils-books 1.8.0 → 1.10.0

package/src/tool/book-index-page-budget-calculator/component.astro

@@ -0,0 +1,134 @@
+---
+import { calculateIndexBudget, DEFAULT_INDEX_INPUTS } from './logic';
+import { evaluateBudget } from './evaluator';
+import type { BookIndexUI } from './ui';
+
+interface Props {
+  ui: BookIndexUI;
+}
+
+const { ui } = Astro.props as Props;
+const initialBudget = calculateIndexBudget(DEFAULT_INDEX_INPUTS);
+const initialEvaluation = evaluateBudget(initialBudget);
+function initialStatusCopy(status: ReturnType<typeof evaluateBudget>['status'], content: BookIndexUI): { text: string; hint: string } {
+  if (status === 'tight') return { text: content.statusTight, hint: content.statusTightHint };
+  if (status === 'roomy') return { text: content.statusRoomy, hint: content.statusRoomyHint };
+  return { text: content.statusBalanced, hint: content.statusBalancedHint };
+}
+
+function initialGapCopy(gap: number, content: BookIndexUI): string {
+  if (gap > 0) return `${gap} ${content.summaryPagesOver}`;
+  if (gap < 0) return `${Math.abs(gap)} ${content.summaryPagesSpare}`;
+  return content.summaryOnTarget;
+}
+
+const initialStatusCopyValue = initialStatusCopy(initialEvaluation.status, ui);
+const initialGap = initialBudget.estimatedIndexPages - initialBudget.targetIndexPages;
+const initialGapLabel = initialGapCopy(initialGap, ui);
+const initialBodyShare = (initialBudget.textPages / initialBudget.totalPages) * 100;
+const initialIndexShare = 100 - initialBodyShare;
+---
+
+<div class="book-index-tool" data-book-index-tool data-ui={JSON.stringify(ui)} data-status={initialEvaluation.status} data-units="imperial">
+  <form class="index-workbench" data-form>
+    <section class="budget-summary" aria-label={ui.summaryLabel}>
+      <div class="summary-topline">
+        <span>{ui.summaryLabel}</span>
+        <strong data-output="summary-gap">{initialGapLabel}</strong>
+      </div>
+      <div class="summary-grid">
+        <div class="summary-total">
+          <span>{ui.totalPagesLabel}</span>
+          <strong data-output="total-pages">{initialBudget.totalPages}</strong>
+          <small>{ui.targetTotalPagesLabel} <b data-output="target-total-pages">{initialBudget.targetTotalPages}</b></small>
+        </div>
+        <div class="budget-strip" data-scene aria-label={ui.sceneLabel}>
+          <div class="strip-labels">
+            <span>{ui.sceneBodyLabel} <b data-output="scene-body-count">{initialBudget.textPages}</b></span>
+            <span>{ui.sceneIndexLabel} <b data-output="scene-index-count">{initialBudget.estimatedIndexPages}</b></span>
+          </div>
+          <div class="strip-track">
+            <span class="strip-body" data-paper="body" style={`--paper-share: ${initialBodyShare}%`}></span>
+            <span class="strip-index" data-paper="index" style={`--paper-share: ${initialIndexShare}%`}></span>
+          </div>
+          <div class="strip-target"><span>{ui.targetIndexPagesLabel}</span><strong data-output="summary-target">{initialBudget.targetIndexPages}</strong></div>
+        </div>
+        <div class="summary-brief" data-status-line>
+          <span class="status-dot"></span>
+          <strong data-output="status">{initialStatusCopyValue.text}</strong>
+          <p data-output="status-hint">{initialStatusCopyValue.hint}</p>
+        </div>
+      </div>
+    </section>
+
+    <div class="workbench-controls">
+      <div class="control-block">
+        <div class="field">
+          <label for="manuscript-words">{ui.wordsLabel}</label>
+          <input id="manuscript-words" data-input="manuscript-words" type="number" min="100" max="500000" step="100" value={DEFAULT_INDEX_INPUTS.manuscriptWords} inputmode="numeric" />
+          <span class="field-hint">{ui.wordsHint}</span>
+        </div>
+        <div class="field">
+          <label for="index-entries">{ui.indexEntriesLabel}</label>
+          <input id="index-entries" data-input="index-entries" type="number" min="10" max="10000" step="10" value={DEFAULT_INDEX_INPUTS.indexEntries} inputmode="numeric" />
+          <span class="field-hint">{ui.indexEntriesHint}</span>
+        </div>
+      </div>
+
+      <div class="control-block">
+        <div class="dimension-field">
+          <div class="field-row">
+            <label for="trim-width">{ui.trimWidthLabel}</label>
+            <label for="trim-height">{ui.trimHeightLabel}</label>
+          </div>
+          <div class="input-row">
+            <input id="trim-width" data-input="trim-width" type="number" min="3" max="15" step="0.01" value={DEFAULT_INDEX_INPUTS.trimWidthInches} inputmode="decimal" />
+            <span class="times">×</span>
+            <input id="trim-height" data-input="trim-height" type="number" min="3" max="15" step="0.01" value={DEFAULT_INDEX_INPUTS.trimHeightInches} inputmode="decimal" />
+          </div>
+          <span class="field-hint">{ui.trimHint}</span>
+        </div>
+        <fieldset class="unit-field">
+          <legend>{ui.unitLabel}</legend>
+          <div class="unit-switch">
+            <button type="button" data-unit="imperial" aria-pressed="true">{ui.imperialButtonLabel}</button>
+            <button type="button" data-unit="metric" aria-pressed="false">{ui.metricButtonLabel}</button>
+          </div>
+        </fieldset>
+      </div>
+
+      <div class="control-block">
+        <fieldset class="density-field">
+          <legend>{ui.densityLabel}</legend>
+          <span class="field-hint">{ui.densityHint}</span>
+          <div class="density-options">
+            <button type="button" data-density="airy" aria-pressed="false"><span class="density-mark airy-mark"></span>{ui.airyLabel}</button>
+            <button type="button" data-density="standard" aria-pressed="true"><span class="density-mark standard-mark"></span>{ui.standardLabel}</button>
+            <button type="button" data-density="compact" aria-pressed="false"><span class="density-mark compact-mark"></span>{ui.compactLabel}</button>
+          </div>
+        </fieldset>
+        <div class="field">
+          <label for="target-index-pages">{ui.targetIndexPagesLabel}</label>
+          <input id="target-index-pages" data-input="target-index-pages" type="number" min="1" max="200" step="1" value={DEFAULT_INDEX_INPUTS.targetIndexPages} inputmode="numeric" />
+          <span class="field-hint">{ui.targetIndexPagesHint}</span>
+        </div>
+      </div>
+    </div>
+
+    <div class="reading-details">
+      <div class="reading-item"><span>{ui.textPagesLabel}</span><strong data-output="text-pages">{initialBudget.textPages}</strong></div>
+      <div class="reading-item"><span>{ui.estimatedIndexPagesLabel}</span><strong data-output="index-pages">{initialBudget.estimatedIndexPages}</strong></div>
+      <div class="reading-item"><span>{ui.entriesPerPageLabel}</span><strong data-output="entries-per-page">{initialBudget.targetEntriesPerPage.toFixed(1)}</strong></div>
+      <div class="reading-item"><span>{ui.indexShareLabel}</span><strong data-output="index-share">{initialBudget.indexSharePercent.toFixed(1)}%</strong></div>
+      <div class="reading-item"><span>{ui.densityLabel}</span><strong data-output="words-per-page">{initialBudget.wordsPerPage} {ui.wordsLabel.toLowerCase()}</strong></div>
+    </div>
+    <p class="source-note">{ui.sourceNote}</p>
+  </form>
+</div>
+
+<script>
+  import { initBookIndexTool } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-book-index-tool]');
+  if (root) initBookIndexTool(root);
+</script>

package/src/tool/book-index-page-budget-calculator/controller.ts

@@ -0,0 +1,114 @@
+import {
+  calculateIndexBudget,
+  clampNumber,
+  centimetersToInches,
+  DEFAULT_INDEX_INPUTS,
+  inchesToCentimeters,
+  type BookIndexInputs,
+  type Density,
+} from './logic';
+import { renderBudget } from './dom-views';
+import { loadUnitSystem, saveUnitSystem, type UnitSystem } from './storage';
+import type { BookIndexUI } from './ui';
+
+const DISPLAY_LIMITS = {
+  manuscriptWords: [100, 500000],
+  indexEntries: [10, 10000],
+  targetIndexPages: [1, 200],
+} as const;
+
+function input(root: HTMLElement, name: string): HTMLInputElement | null {
+  return root.querySelector<HTMLInputElement>(`[data-input="${name}"]`);
+}
+
+function parseInput(root: HTMLElement, name: string, fallback: number): number {
+  const field = input(root, name);
+  return field ? Number(field.value) || fallback : fallback;
+}
+
+function displayedDimension(inputs: BookIndexInputs, unitSystem: UnitSystem, dimension: 'width' | 'height'): number {
+  const value = dimension === 'width' ? inputs.trimWidthInches : inputs.trimHeightInches;
+  return unitSystem === 'metric' ? inchesToCentimeters(value) : value;
+}
+
+function readInputs(root: HTMLElement, previous: BookIndexInputs, unitSystem: UnitSystem): BookIndexInputs {
+  const width = parseInput(root, 'trim-width', displayedDimension(previous, unitSystem, 'width'));
+  const height = parseInput(root, 'trim-height', displayedDimension(previous, unitSystem, 'height'));
+  const toInches = (value: number): number => unitSystem === 'metric' ? centimetersToInches(value) : value;
+
+  return {
+    manuscriptWords: clampNumber(parseInput(root, 'manuscript-words', previous.manuscriptWords), ...DISPLAY_LIMITS.manuscriptWords, previous.manuscriptWords),
+    trimWidthInches: clampNumber(toInches(width), 3, 15, previous.trimWidthInches),
+    trimHeightInches: clampNumber(toInches(height), 3, 15, previous.trimHeightInches),
+    density: previous.density,
+    indexEntries: clampNumber(parseInput(root, 'index-entries', previous.indexEntries), ...DISPLAY_LIMITS.indexEntries, previous.indexEntries),
+    targetIndexPages: clampNumber(parseInput(root, 'target-index-pages', previous.targetIndexPages), ...DISPLAY_LIMITS.targetIndexPages, previous.targetIndexPages),
+  };
+}
+
+function setDimensionFields(root: HTMLElement, inputs: BookIndexInputs, unitSystem: UnitSystem): void {
+  const width = input(root, 'trim-width');
+  const height = input(root, 'trim-height');
+  if (width) width.value = displayedDimension(inputs, unitSystem, 'width').toFixed(unitSystem === 'metric' ? 1 : 2);
+  if (height) height.value = displayedDimension(inputs, unitSystem, 'height').toFixed(unitSystem === 'metric' ? 1 : 2);
+}
+
+function setUnitButtons(root: HTMLElement, unitSystem: UnitSystem): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-unit]').forEach((button) => {
+    button.setAttribute('aria-pressed', String(button.dataset.unit === unitSystem));
+  });
+  root.dataset.units = unitSystem;
+}
+
+function setDensityButtons(root: HTMLElement, density: Density): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-density]').forEach((button) => {
+    button.setAttribute('aria-pressed', String(button.dataset.density === density));
+  });
+}
+
+function render(root: HTMLElement, ui: BookIndexUI, inputs: BookIndexInputs, unitSystem: UnitSystem): void {
+  setUnitButtons(root, unitSystem);
+  setDensityButtons(root, inputs.density);
+  renderBudget({ root, budget: calculateIndexBudget(inputs), inputs, ui, unitSystem });
+}
+
+function bindNumberFields(root: HTMLElement, ui: BookIndexUI, state: { inputs: BookIndexInputs; unitSystem: UnitSystem }): void {
+  root.querySelectorAll<HTMLInputElement>('[data-input]').forEach((field) => {
+    field.addEventListener('input', () => {
+      state.inputs = readInputs(root, state.inputs, state.unitSystem);
+      render(root, ui, state.inputs, state.unitSystem);
+    });
+  });
+}
+
+function bindDensity(root: HTMLElement, ui: BookIndexUI, state: { inputs: BookIndexInputs; unitSystem: UnitSystem }): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-density]').forEach((button) => {
+    button.addEventListener('click', () => {
+      const density = button.dataset.density as Density;
+      state.inputs = { ...readInputs(root, state.inputs, state.unitSystem), density };
+      render(root, ui, state.inputs, state.unitSystem);
+    });
+  });
+}
+
+function bindUnits(root: HTMLElement, ui: BookIndexUI, state: { inputs: BookIndexInputs; unitSystem: UnitSystem }): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-unit]').forEach((button) => {
+    button.addEventListener('click', () => {
+      state.inputs = readInputs(root, state.inputs, state.unitSystem);
+      state.unitSystem = button.dataset.unit === 'metric' ? 'metric' : 'imperial';
+      saveUnitSystem(state.unitSystem);
+      setDimensionFields(root, state.inputs, state.unitSystem);
+      render(root, ui, state.inputs, state.unitSystem);
+    });
+  });
+}
+
+export function initBookIndexTool(root: HTMLElement): void {
+  const ui = JSON.parse(root.dataset.ui ?? '{}') as BookIndexUI;
+  const state = { inputs: DEFAULT_INDEX_INPUTS, unitSystem: loadUnitSystem() };
+  bindNumberFields(root, ui, state);
+  bindDensity(root, ui, state);
+  bindUnits(root, ui, state);
+  setDimensionFields(root, state.inputs, state.unitSystem);
+  render(root, ui, state.inputs, state.unitSystem);
+}

package/src/tool/book-index-page-budget-calculator/dom-views.ts

@@ -0,0 +1,89 @@
+import type { BookIndexBudget, BookIndexInputs } from './logic';
+import { evaluateBudget } from './evaluator';
+import type { BookIndexUI } from './ui';
+import type { UnitSystem } from './storage';
+
+interface RenderArgs {
+  root: HTMLElement;
+  budget: BookIndexBudget;
+  inputs: BookIndexInputs;
+  ui: BookIndexUI;
+  unitSystem: UnitSystem;
+}
+
+interface SceneArgs {
+  root: HTMLElement;
+  budget: BookIndexBudget;
+  inputs: BookIndexInputs;
+  ui: BookIndexUI;
+  unitSystem: UnitSystem;
+}
+
+function number(value: number, digits = 0): string {
+  return new Intl.NumberFormat('en-US', { maximumFractionDigits: digits }).format(value);
+}
+
+function setOutput(root: HTMLElement, name: string, value: string): void {
+  const output = root.querySelector<HTMLElement>(`[data-output="${name}"]`);
+  if (output) output.textContent = value;
+}
+
+function renderOutputs(root: HTMLElement, budget: BookIndexBudget, ui: BookIndexUI): void {
+  setOutput(root, 'text-pages', number(budget.textPages));
+  setOutput(root, 'index-pages', number(budget.estimatedIndexPages));
+  setOutput(root, 'total-pages', number(budget.totalPages));
+  setOutput(root, 'target-total-pages', number(budget.targetTotalPages));
+  setOutput(root, 'entries-per-page', number(budget.targetEntriesPerPage, 1));
+  setOutput(root, 'index-share', `${number(budget.indexSharePercent, 1)}%`);
+  setOutput(root, 'words-per-page', `${number(budget.wordsPerPage)} ${ui.wordsLabel.toLowerCase()}`);
+  setOutput(root, 'summary-target', number(budget.targetIndexPages));
+}
+
+function summaryGapCopy(gap: number, ui: BookIndexUI): string {
+  if (gap > 0) return `${number(gap)} ${ui.summaryPagesOver}`;
+  if (gap < 0) return `${number(Math.abs(gap))} ${ui.summaryPagesSpare}`;
+  return ui.summaryOnTarget;
+}
+
+function renderSummary(root: HTMLElement, budget: BookIndexBudget, ui: BookIndexUI): void {
+  const gap = budget.estimatedIndexPages - budget.targetIndexPages;
+  const gapLabel = summaryGapCopy(gap, ui);
+  setOutput(root, 'summary-gap', gapLabel);
+  setOutput(root, 'scene-body-count', number(budget.textPages));
+  setOutput(root, 'scene-index-count', number(budget.estimatedIndexPages));
+}
+
+function statusCopy(status: ReturnType<typeof evaluateBudget>['status'], ui: BookIndexUI): { text: string; hint: string } {
+  if (status === 'tight') return { text: ui.statusTight, hint: ui.statusTightHint };
+  if (status === 'roomy') return { text: ui.statusRoomy, hint: ui.statusRoomyHint };
+  return { text: ui.statusBalanced, hint: ui.statusBalancedHint };
+}
+
+function renderStatus(root: HTMLElement, budget: BookIndexBudget, ui: BookIndexUI): void {
+  const evaluation = evaluateBudget(budget);
+  const copy = statusCopy(evaluation.status, ui);
+  root.dataset.status = evaluation.status;
+  setOutput(root, 'status', copy.text);
+  setOutput(root, 'status-hint', copy.hint);
+}
+
+function renderScene(args: SceneArgs): void {
+  const scene = args.root.querySelector<HTMLElement>('[data-scene]');
+  if (!scene) return;
+  const bodyShare = (args.budget.textPages / args.budget.totalPages) * 100;
+  const indexShare = 100 - bodyShare;
+  scene.style.setProperty('--body-share', `${bodyShare}%`);
+  scene.style.setProperty('--index-share', `${indexShare}%`);
+  scene.dataset.density = args.inputs.density;
+  scene.dataset.units = args.unitSystem;
+  setOutput(args.root, 'scene-body-label', `${number(args.budget.textPages)} ${args.ui.sceneBodyLabel}`);
+  setOutput(args.root, 'scene-index-label', `${number(args.budget.estimatedIndexPages)} ${args.ui.sceneIndexLabel}`);
+  setOutput(args.root, 'scene-caption', `${args.ui.sceneCaption} ${number(args.budget.totalPages)}. ${args.ui.sceneTargetCaption} ${number(args.budget.targetTotalPages)}.`);
+}
+
+export function renderBudget(args: RenderArgs): void {
+  renderOutputs(args.root, args.budget, args.ui);
+  renderSummary(args.root, args.budget, args.ui);
+  renderStatus(args.root, args.budget, args.ui);
+  renderScene(args);
+}

package/src/tool/book-index-page-budget-calculator/entry.ts

@@ -0,0 +1,39 @@
+import type { BooksToolEntry, SEOSection, ToolLocaleContent } from '../../types';
+import type { BookIndexUI } from './ui';
+
+export type { BookIndexUI } from './ui';
+export type BookIndexLocaleContent = ToolLocaleContent<BookIndexUI>;
+
+function withLocalizedSchemas(content: BookIndexLocaleContent): BookIndexLocaleContent {
+  const seo: SEOSection[] = content.seo.length >= 10
+    ? content.seo
+    : [...content.seo, { type: 'title', text: content.ui.sceneLabel, level: 2 }, { type: 'paragraph', html: content.ui.sourceNote }];
+  const schemas: Record<string, unknown>[] = [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: content.title, applicationCategory: 'DesignApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: content.faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: content.title, step: content.howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+  ];
+  return { ...content, seo, schemas };
+}
+
+export const bookIndexPageBudgetCalculator: BooksToolEntry<BookIndexUI> = {
+  id: 'book-index-page-budget-calculator',
+  icons: { bg: 'mdi:book-open-page-variant-outline', fg: 'mdi:format-list-numbered' },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    fr: () => import('./i18n/fr').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    id: () => import('./i18n/id').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    it: () => import('./i18n/it').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    ja: () => import('./i18n/ja').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    ko: () => import('./i18n/ko').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    nl: () => import('./i18n/nl').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    pl: () => import('./i18n/pl').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    pt: () => import('./i18n/pt').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    ru: () => import('./i18n/ru').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    sv: () => import('./i18n/sv').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    tr: () => import('./i18n/tr').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+    zh: () => import('./i18n/zh').then((module) => withLocalizedSchemas(module.content as BookIndexLocaleContent)),
+  },
+};

package/src/tool/book-index-page-budget-calculator/evaluator.ts

@@ -0,0 +1,26 @@
+import type { BookIndexBudget } from './logic';
+
+export type BudgetStatus = 'balanced' | 'tight' | 'roomy';
+
+export interface BudgetEvaluation {
+  status: BudgetStatus;
+  gapPages: number;
+  targetIsTooDense: boolean;
+}
+
+function statusForGap(gapPages: number): BudgetStatus {
+  if (gapPages < 0) return 'tight';
+  if (gapPages > 0) return 'roomy';
+  return 'balanced';
+}
+
+export function evaluateBudget(budget: BookIndexBudget): BudgetEvaluation {
+  const gapPages = budget.targetIndexPages - budget.estimatedIndexPages;
+  const status = statusForGap(gapPages);
+
+  return {
+    status,
+    gapPages,
+    targetIsTooDense: budget.targetEntriesPerPage > budget.entriesPerPage,
+  };
+}

package/src/tool/book-index-page-budget-calculator/i18n/de.ts

@@ -0,0 +1,35 @@
+import type { BookIndexUI } from '../ui';
+import type { ToolLocaleContent } from '../../../types';
+import { content as base } from './en';
+
+const ui: BookIndexUI = {
+  ...base.ui,
+  wordsLabel: 'Wörter im Manuskript', wordsHint: 'Textkörper vor dem Anhang', trimWidthLabel: 'Satzbreite', trimHeightLabel: 'Satzhöhe', trimHint: 'Endformat der Buchseite', unitLabel: 'Seiteneinheiten', metricButtonLabel: 'Metrisch cm', imperialButtonLabel: 'Imperial Zoll', densityLabel: 'Typografische Dichte', densityHint: 'Steuert Wörter und Indexeinträge pro Seite', airyLabel: 'Locker', standardLabel: 'Standard', compactLabel: 'Kompakt', indexEntriesLabel: 'Erwartete Indexeinträge', indexEntriesHint: 'Themen, Namen, Orte und Querverweise', targetIndexPagesLabel: 'Geplante Indexseiten', targetIndexPagesHint: 'Dein Produktionsbudget für den Index', textPagesLabel: 'Textseiten', estimatedIndexPagesLabel: 'Geschätzter Index', totalPagesLabel: 'Geschätzter Buchumfang', targetTotalPagesLabel: 'Mit geplantem Index', entriesPerPageLabel: 'Einträge pro Zielseite', indexShareLabel: 'Indexanteil am Buch', statusBalanced: 'Ziel entspricht der Schätzung', statusTight: 'Ziel ist zu knapp', statusRoomy: 'Ziel lässt Spielraum', statusBalancedHint: 'Dein Indexbudget entspricht dem Dichtemodell.', statusTightHint: 'Plane mehr Seiten ein oder reduziere Einträge vor dem Satz.', statusRoomyHint: 'Das großzügige Budget kann spätere redaktionelle Ergänzungen aufnehmen.', sceneLabel: 'Das Seitenbudget', sceneBodyLabel: 'Textseiten', sceneIndexLabel: 'Indexseiten', sceneCaption: 'Der geschätzte Buchumfang beträgt', sceneTargetCaption: 'Mit deinem Zielbudget ergibt sich', sourceNote: 'Dies ist ein redaktionelles Planungsmodell. Der endgültige Umfang hängt von Satz, Korrekturen, Indexstil sowie Verlag und Druckerei ab.', summaryLabel: 'Budgetsignal', summaryPagesOver: 'Seiten über dem Ziel', summaryPagesSpare: 'Seiten frei', summaryOnTarget: 'Im Zielbereich',
+};
+
+const faq = [
+  { question: 'Was soll ich als Indexeinträge eingeben?', answer: 'Gib Themen, Namen, Orte, Untereinträge und Querverweise ein, die im fertigen Index erscheinen sollen.' },
+  { question: 'Warum werden Text- und Indexseiten getrennt berechnet?', answer: 'Der Textumfang hängt von Wörtern und Seitengestaltung ab, der Indexumfang von Einträgen und Indexdichte.' },
+  { question: 'Was bedeutet ein zu knappes Ziel?', answer: 'Das Ziel würde mehr Einträge pro Seite verlangen, als das gewählte Dichtemodell sinnvoll trägt.' },
+  { question: 'Ersetzt das Ergebnis den finalen Indexabzug?', answer: 'Nein. Es ist eine Planungsschätzung. Seitenverweise und Satz müssen am fertigen Korrekturabzug geprüft werden.' },
+];
+
+const howTo = [
+  { name: 'Manuskriptumfang eingeben', text: 'Trage die Wörter des Manuskripts ohne Rückentext ein.' },
+  { name: 'Seitengestaltung anpassen', text: 'Wähle Endformat und typografische Dichte.' },
+  { name: 'Index beschreiben', text: 'Schätze Einträge und reserviere ein Seitenbudget.' },
+  { name: 'Vergleich auswerten', text: 'Erhöhe das Budget oder reduziere Einträge, wenn das Ziel zu knapp ist.' },
+];
+
+const seo: ToolLocaleContent<BookIndexUI>['seo'] = [
+  { type: 'title', text: 'Indexseiten für ein Buch frühzeitig budgetieren', level: 2 },
+  { type: 'paragraph', html: 'Ein Sachindex fügt einem gedruckten Buch echte Rückseiten hinzu. Dieses Werkzeug verbindet Manuskriptumfang, Seitenformat, typografische Dichte, erwartete Einträge und dein Produktionsbudget zu einer ersten Planung.' },
+  { type: 'title', text: 'So liest du die Schätzung', level: 2 },
+  { type: 'paragraph', html: 'Textseiten entstehen aus Wörtern und der erwarteten Wortdichte. Indexseiten entstehen aus Einträgen und der Eintragsdichte. Vergleiche den geschätzten Index mit dem reservierten Ziel, bevor der Satz beginnt.' },
+  { type: 'list', items: ['Zähle erwartete Einträge statt aller Wörter im Manuskript.', 'Halte Format und Dichte nahe am geplanten Buchdesign.', 'Reserviere zusätzliche Seiten, wenn Querverweise oder Untereinträge wachsen.', 'Prüfe den Wert erneut am stabilen Korrekturabzug.'] },
+  { type: 'title', text: 'Ein knappes Budget ist ein redaktionelles Signal', level: 2 },
+  { type: 'paragraph', html: 'Ein zu knappes Ziel kann zu schwer lesbarer Typografie oder einem überfüllten Index führen. Oft ist es sinnvoller, Verweise zu bereinigen oder mehr Seiten zu reservieren, statt die Dichte immer weiter zu erhöhen.' },
+  { type: 'tip', title: 'Die Schätzung ist kein Druckfreigabewert', html: 'Schrift, Satz, Korrekturen und Indexstil verändern den endgültigen Umfang. Bestätige das Ergebnis mit Verlag, Druckerei oder professionellem Indexer.' },
+];
+
+export const content = { ...base, slug: 'buch-index-seitenbudget-rechner', title: 'Budgetrechner für Indexseiten von Büchern', description: 'Schätze die zusätzlichen Indexseiten eines Buches und vergleiche sie mit deinem redaktionellen Seitenbudget.', ui, seo, faq, howTo };

package/src/tool/book-index-page-budget-calculator/i18n/en.ts

@@ -0,0 +1,113 @@
+import type { ToolLocaleContent } from '../../../types';
+import { BOOK_INDEX_BIBLIOGRAPHY } from '../bibliography';
+import type { BookIndexUI } from '../ui';
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+
+const ui: BookIndexUI = {
+  wordsLabel: 'Manuscript words',
+  wordsHint: 'The body text before back matter',
+  trimWidthLabel: 'Trim width',
+  trimHeightLabel: 'Trim height',
+  trimHint: 'Physical page size',
+  unitLabel: 'Page units',
+  metricButtonLabel: 'Metric cm',
+  imperialButtonLabel: 'Imperial in',
+  densityLabel: 'Typography density',
+  densityHint: 'Controls body words per page and index entries per page',
+  airyLabel: 'Airy',
+  standardLabel: 'Standard',
+  compactLabel: 'Compact',
+  indexEntriesLabel: 'Expected index entries',
+  indexEntriesHint: 'Topics, names, places, and cross references',
+  targetIndexPagesLabel: 'Target index pages',
+  targetIndexPagesHint: 'Your production allowance for the index',
+  textPagesLabel: 'Body pages',
+  estimatedIndexPagesLabel: 'Estimated index',
+  totalPagesLabel: 'Estimated book total',
+  targetTotalPagesLabel: 'With target index',
+  entriesPerPageLabel: 'Entries per target page',
+  indexShareLabel: 'Index share of book',
+  statusBalanced: 'Target matches the estimate',
+  statusTight: 'Target is too tight',
+  statusRoomy: 'Target leaves room',
+  statusBalancedHint: 'Your planned index allowance matches the density model.',
+  statusTightHint: 'Add pages or reduce entries before typesetting the final index.',
+  statusRoomyHint: 'The allowance is generous and may absorb late editorial additions.',
+  sceneLabel: 'The page budget',
+  sceneBodyLabel: 'body pages',
+  sceneIndexLabel: 'index pages',
+  sceneCaption: 'The estimated book occupies',
+  sceneTargetCaption: 'Your target allowance produces',
+  sourceNote: 'This is an editorial planning model. Final pagination depends on typesetting, proof corrections, index style, and the publisher or printer.',
+  summaryLabel: 'Budget signal',
+  summaryPagesOver: 'pages over target',
+  summaryPagesSpare: 'pages spare',
+  summaryOnTarget: 'On target',
+};
+
+const seo: ToolLocaleContent<BookIndexUI>['seo'] = [
+  { type: 'title', text: 'Budget Index Pages Before Your Book Is Typeset', level: 2 },
+  { type: 'paragraph', html: 'An analytical index is back matter that adds real pages to a printed book. This calculator turns a manuscript word count, trim size, typography density, expected index entries, and a page allowance into a practical editorial budget. It keeps the body estimate and the index estimate visible as separate parts of the same book.' },
+  { type: 'title', text: 'What the Estimate Does', level: 2 },
+  { type: 'paragraph', html: 'Body pages are estimated from manuscript words divided by a density-adjusted words-per-page value. Index pages are estimated from the expected number of entries divided by the entries-per-page capacity of the chosen typography profile, then rounded up to a whole page. The book total adds the body and estimated index pages; the target total adds the body to the page allowance you plan to reserve.' },
+  { type: 'list', items: ['Use expected entries rather than the number of unique words in the manuscript.', 'Compare the estimated index pages with the target allowance before layout begins.', 'Treat a high entries-per-target-page value as a signal to simplify, split, or expand the index budget.', 'Keep the trim size and density close to the intended interior design when comparing scenarios.'] },
+  { type: 'title', text: 'How to Read a Tight Budget', level: 2 },
+  { type: 'paragraph', html: 'A tight target means the planned allowance would require more entries per page than the selected profile supports. That can lead to cramped typography, weaker hierarchy, or an index that is difficult to scan. The useful editorial response is not always to squeeze harder: remove passing references, merge duplicate concepts, clarify cross references, or reserve more pages for the reader-facing navigation tool.' },
+  { type: 'title', text: 'Plan Early and Recheck at Proof', level: 2 },
+  { type: 'paragraph', html: 'Index locators depend on the typeset page sequence, so a late change in the body can move page references and force another index pass. Use this calculator while planning the book, then revisit the budget when the proof has stabilized. The result does not replace publisher instructions or a professional indexer review.' },
+  { type: 'tip', title: 'The index is not a word count', html: 'Two books with the same number of words can need very different indexes. Names, subentries, cross references, and the amount of useful material per locator change the final footprint. Count the entries you expect a reader to use, not every mention in the manuscript.' },
+];
+
+const applicationSchema = ({
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: 'Book Index Page Budget Calculator',
+  applicationCategory: 'DesignApplication',
+  operatingSystem: 'Any',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+} as unknown) as SoftwareApplication & Record<string, unknown>;
+
+const faqSchema = ({
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'What should I enter as index entries?', acceptedAnswer: { '@type': 'Answer', text: 'Enter the topics, names, places, subentries, and cross references you expect to include in the finished index.' } },
+    { '@type': 'Question', name: 'Why are body and index pages calculated separately?', acceptedAnswer: { '@type': 'Answer', text: 'The body is driven by words and page design, while the index is driven by entries and index density.' } },
+    { '@type': 'Question', name: 'What does a tight target mean?', acceptedAnswer: { '@type': 'Answer', text: 'It means the target pages would require more entries per page than the selected profile is designed to hold.' } },
+    { '@type': 'Question', name: 'Can this replace the final index proof?', acceptedAnswer: { '@type': 'Answer', text: 'No. It is a planning estimate. Final locators and pagination must be checked against typeset proofs.' } },
+  ],
+} as unknown) as FAQPage & Record<string, unknown>;
+
+const howToSchema = ({
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Build a preliminary book index page budget',
+  step: [
+    { '@type': 'HowToStep', name: 'Enter the manuscript size', text: 'Enter the manuscript word count before back matter.' },
+    { '@type': 'HowToStep', name: 'Match the page design', text: 'Set the trim dimensions and choose airy, standard, or compact typography.' },
+    { '@type': 'HowToStep', name: 'Describe the index', text: 'Enter the expected number of index entries and the page allowance you want to reserve.' },
+    { '@type': 'HowToStep', name: 'Act on the comparison', text: 'Use the estimated index pages and status to adjust the editorial plan before typesetting.' },
+  ],
+} as unknown) as HowTo & Record<string, unknown>;
+
+export const content: ToolLocaleContent<BookIndexUI> = {
+  slug: 'book-index-page-budget-calculator',
+  title: 'Book Index Page Budget Calculator',
+  description: 'Estimate the pages an analytical index will add to your book and compare that footprint with your editorial page allowance.',
+  ui,
+  seo,
+  faq: [
+    { question: 'What should I enter as index entries?', answer: 'Enter the topics, names, places, subentries, and cross references you expect to include in the finished index.' },
+    { question: 'Why are body and index pages calculated separately?', answer: 'The body is driven by words and page design, while the index is driven by entries and index density.' },
+    { question: 'What does a tight target mean?', answer: 'It means the target pages would require more entries per page than the selected profile is designed to hold.' },
+    { question: 'Can this replace the final index proof?', answer: 'No. It is a planning estimate. Final locators and pagination must be checked against typeset proofs.' },
+  ],
+  bibliography: BOOK_INDEX_BIBLIOGRAPHY,
+  howTo: [
+    { name: 'Enter the manuscript size', text: 'Enter the manuscript word count before back matter.' },
+    { name: 'Match the page design', text: 'Set the trim dimensions and choose a typography density.' },
+    { name: 'Describe the index', text: 'Enter expected entries and the index page allowance.' },
+    { name: 'Act on the comparison', text: 'Adjust the editorial plan when the allowance is tight.' },
+  ],
+  schemas: [applicationSchema, faqSchema, howToSchema],
+};

package/src/tool/book-index-page-budget-calculator/i18n/es.ts

@@ -0,0 +1,35 @@
+import { content as base } from './en';
+import type { BookIndexUI } from '../ui';
+import type { ToolLocaleContent } from '../../../types';
+
+const ui: BookIndexUI = {
+  ...base.ui,
+  wordsLabel: 'Palabras del manuscrito', wordsHint: 'Texto principal antes de los anexos', trimWidthLabel: 'Ancho de corte', trimHeightLabel: 'Alto de corte', trimHint: 'Tamaño final de la página', unitLabel: 'Unidades de página', metricButtonLabel: 'Métrico cm', imperialButtonLabel: 'Imperial pulgadas', densityLabel: 'Densidad tipográfica', densityHint: 'Controla palabras y entradas por página', airyLabel: 'Aireada', standardLabel: 'Estándar', compactLabel: 'Compacta', indexEntriesLabel: 'Entradas de índice previstas', indexEntriesHint: 'Temas, nombres, lugares y referencias cruzadas', targetIndexPagesLabel: 'Páginas de índice reservadas', targetIndexPagesHint: 'Tu margen de producción para el índice', textPagesLabel: 'Páginas de texto', estimatedIndexPagesLabel: 'Índice estimado', totalPagesLabel: 'Total estimado del libro', targetTotalPagesLabel: 'Con el índice reservado', entriesPerPageLabel: 'Entradas por página objetivo', indexShareLabel: 'Parte del índice en el libro', statusBalanced: 'El objetivo coincide con la estimación', statusTight: 'El objetivo es demasiado ajustado', statusRoomy: 'El objetivo deja margen', statusBalancedHint: 'La reserva prevista coincide con el modelo de densidad.', statusTightHint: 'Reserva más páginas o reduce entradas antes de maquetar el índice.', statusRoomyHint: 'El margen puede absorber incorporaciones editoriales de última hora.', sceneLabel: 'El presupuesto de páginas', sceneBodyLabel: 'páginas de texto', sceneIndexLabel: 'páginas de índice', sceneCaption: 'El libro estimado ocupa', sceneTargetCaption: 'Con tu reserva el total sería', sourceNote: 'Es un modelo de planificación editorial. La paginación final depende de la maquetación, las correcciones, el estilo del índice y las indicaciones de la editorial o imprenta.', summaryLabel: 'Señal del presupuesto', summaryPagesOver: 'páginas por encima', summaryPagesSpare: 'páginas de margen', summaryOnTarget: 'En objetivo',
+};
+
+const faq = [
+  { question: '¿Qué debo introducir como entradas de índice?', answer: 'Introduce los temas, nombres, lugares, subentradas y referencias cruzadas que esperas incluir en el índice final.' },
+  { question: '¿Por qué se calculan por separado el texto y el índice?', answer: 'El texto depende de las palabras y del diseño de página; el índice depende de sus entradas y de su densidad.' },
+  { question: '¿Qué significa un objetivo demasiado ajustado?', answer: 'Significa que necesitarías colocar más entradas por página de las que admite razonablemente el perfil elegido.' },
+  { question: '¿Sustituye esto a la prueba final del índice?', answer: 'No. Es una estimación de planificación. Los localizadores y la paginación deben revisarse sobre las pruebas maquetadas.' },
+];
+
+const howTo = [
+  { name: 'Introduce el manuscrito', text: 'Indica las palabras del texto principal antes de los anexos.' },
+  { name: 'Ajusta el diseño', text: 'Elige el tamaño final y la densidad tipográfica prevista.' },
+  { name: 'Describe el índice', text: 'Estima las entradas y reserva un número de páginas.' },
+  { name: 'Actúa sobre la comparación', text: 'Amplía la reserva o reduce entradas cuando el objetivo quede corto.' },
+];
+
+const seo: ToolLocaleContent<BookIndexUI>['seo'] = [
+  { type: 'title', text: 'Calcula pronto cuántas páginas añadirá el índice de tu libro', level: 2 },
+  { type: 'paragraph', html: 'Un índice analítico añade páginas reales a la parte final de un libro impreso. Esta herramienta combina palabras, formato, densidad tipográfica, entradas previstas y reserva editorial en una primera previsión útil.' },
+  { type: 'title', text: 'Cómo interpretar el resultado', level: 2 },
+  { type: 'paragraph', html: 'Las páginas de texto se estiman a partir de las palabras y la densidad. Las páginas de índice se estiman a partir de las entradas y la capacidad por página. Compara ambas cifras antes de cerrar la maquetación.' },
+  { type: 'list', items: ['Cuenta entradas previstas, no todas las palabras del manuscrito.', 'Usa el formato y la densidad que tendrá el interior real.', 'Amplía la reserva si habrá muchos subapartados o referencias cruzadas.', 'Vuelve a calcular cuando la prueba de páginas sea estable.'] },
+  { type: 'title', text: 'Un objetivo ajustado requiere una decisión editorial', level: 2 },
+  { type: 'paragraph', html: 'Forzar demasiadas entradas en pocas páginas puede reducir la legibilidad. Antes de apretar la tipografía, depura referencias pasajeras, une conceptos duplicados o reserva más espacio para la herramienta de navegación del lector.' },
+  { type: 'tip', title: 'No es una cifra lista para imprenta', html: 'La fuente, la composición, las correcciones y el estilo del índice cambian el resultado final. Confirma siempre la cifra con la editorial, la imprenta o un profesional del indexado.' },
+];
+
+export const content = { ...base, slug: 'calculadora-presupuesto-paginas-indice-libro', title: 'Calculadora de presupuesto de páginas de índice', description: 'Estima las páginas que añadirá un índice analítico y compáralas con la reserva editorial de tu libro.', ui, seo, faq, howTo };

package/src/tool/book-index-page-budget-calculator/i18n/fr.ts

@@ -0,0 +1,8 @@
+import { content as base } from './en';
+import type { BookIndexUI } from '../ui';
+
+const ui: BookIndexUI = { ...base.ui, wordsLabel: 'Mots du manuscrit', wordsHint: 'Texte principal avant les annexes', trimWidthLabel: 'Largeur de coupe', trimHeightLabel: 'Hauteur de coupe', trimHint: 'Format fini de la page', unitLabel: 'Unites de page', metricButtonLabel: 'Metrique cm', imperialButtonLabel: 'Imperial pouces', densityLabel: 'Densite typographique', densityHint: 'Regle les mots et les entrees par page', airyLabel: 'Aeree', standardLabel: 'Standard', compactLabel: 'Compacte', indexEntriesLabel: 'Entrees d index prevues', indexEntriesHint: 'Themes, noms, lieux et renvois', targetIndexPagesLabel: 'Pages d index prevues', targetIndexPagesHint: 'Votre reserve de production pour l index', textPagesLabel: 'Pages de texte', estimatedIndexPagesLabel: 'Index estime', totalPagesLabel: 'Total estime du livre', targetTotalPagesLabel: 'Avec la reserve d index', entriesPerPageLabel: 'Entrees par page cible', indexShareLabel: 'Part de l index dans le livre', statusBalanced: 'La cible correspond a l estimation', statusTight: 'La cible est trop serree', statusRoomy: 'La cible laisse de la marge', statusBalancedHint: 'La reserve prevue correspond au modele de densite.', statusTightHint: 'Ajoutez des pages ou reduisez les entrees avant la composition.', statusRoomyHint: 'La marge peut absorber des ajouts editoriaux tardifs.', sceneLabel: 'Le budget de pages', sceneBodyLabel: 'pages de texte', sceneIndexLabel: 'pages d index', sceneCaption: 'Le livre estime occupe', sceneTargetCaption: 'Avec votre reserve, le total serait', sourceNote: 'Il s agit d un modele de planification editoriale. La pagination finale depend de la composition, des corrections, du style d index et des consignes de l editeur ou de l imprimeur.', summaryLabel: 'Signal du budget', summaryPagesOver: 'pages au dessus de la cible', summaryPagesSpare: 'pages de marge', summaryOnTarget: 'Dans la cible' };
+const faq = [{ question: 'Que dois je saisir comme entrees d index ?', answer: 'Saisissez les themes, noms, lieux, sous entrees et renvois prevus dans l index final.' }, { question: 'Pourquoi separer les pages de texte et d index ?', answer: 'Le texte depend des mots et de la mise en page, tandis que l index depend de ses entrees et de sa densite.' }, { question: 'Que signifie une cible trop serree ?', answer: 'La reserve demanderait plus d entrees par page que le profil choisi ne peut en accueillir confortablement.' }, { question: 'Le resultat remplace t il l epreuve finale ?', answer: 'Non. C est une estimation de planification. Les renvois et la pagination doivent etre verifies sur l epreuve composee.' }];
+const howTo = [{ name: 'Saisir le manuscrit', text: 'Indiquez le nombre de mots du texte principal.' }, { name: 'Adapter la maquette', text: 'Choisissez le format fini et la densite typographique.' }, { name: 'Decrire l index', text: 'Estimez les entrees et reservez un nombre de pages.' }, { name: 'Agir sur l ecart', text: 'Augmentez la reserve ou reduisez les entrees si la cible est trop serree.' }];
+const seo = [{ type: 'title', text: 'Prevoir le budget de pages d index du livre', level: 2 }, { type: 'paragraph', html: 'Un index analytique ajoute des pages reelles a la fin d un livre imprime. Cet outil combine les mots du manuscrit, le format, la densite typographique, les entrees prevues et la reserve editoriale.' }, { type: 'title', text: 'Lire l estimation', level: 2 }, { type: 'paragraph', html: 'Les pages de texte dependent des mots et de la densite. Les pages d index dependent du nombre d entrees et de la capacite par page. Comparez l estimation a la reserve avant de finaliser la composition.' }, { type: 'list', items: ['Comptez les entrees prevues plutot que chaque mot du manuscrit.', 'Utilisez le format et la densite de l interieur prevu.', 'Reservez davantage si les renvois et sous entrees sont nombreux.', 'Recalculez lorsque l epreuve de pages est stabilisee.'] }, { type: 'title', text: 'Une cible serree appelle une decision editoriale', level: 2 }, { type: 'paragraph', html: 'Entasser trop d entrees peut rendre l index difficile a parcourir. Nettoyez les renvois peu utiles ou augmentez la reserve avant de reduire davantage la taille du texte.' }, { type: 'tip', title: 'Ce n est pas une valeur d impression definitive', html: 'La police, la composition, les corrections et le style d index changent le resultat final. Confirmez le avec l editeur, l imprimeur ou un indexeur professionnel.' }];
+export const content = { ...base, slug: 'calculateur-budget-pages-index-livre', title: 'Calculateur du budget de pages indexées', description: 'Estimez les pages ajoutées par un index analytique et comparez-les à la réserve éditoriale de votre livre.', ui, seo, faq, howTo };