@jjlmoya/utils-astronomy 1.27.0 → 1.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-astronomy",
-    "version": "1.27.0",
+    "version": "1.28.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -3,11 +3,12 @@ import { bortleVisualizer } from '../tool/bortleVisualizer/entry';
 import { deepSpaceScope } from '../tool/deepSpaceScope/entry';
 import { starExposureCalculator } from '../tool/starExposureCalculator/entry';
 import { telescopeResolution } from '../tool/telescopeResolution/entry';
-import { eyepieceCalculator } from '../tool/smartEyepieceCalculator/entry';
+import { eyepieceCalculator } from '../tool/smartEyepieceCalculator/entry';
+import { telescopeExitPupilPlanner } from '../tool/telescopeExitPupilPlanner/entry';
 
 export const toolsCategory: AstronomyCategoryEntry = {
   icon: 'mdi:telescope',
-  tools: [bortleVisualizer, deepSpaceScope, starExposureCalculator, telescopeResolution, eyepieceCalculator],
+  tools: [bortleVisualizer, deepSpaceScope, starExposureCalculator, telescopeResolution, eyepieceCalculator, telescopeExitPupilPlanner],
   i18n: {
     de: () => import('./i18n/de').then((m) => m.content),
     en: () => import('./i18n/en').then((m) => m.content),

package/src/data.ts

@@ -4,7 +4,8 @@ export type { BortleVisualizerUI, BortleVisualizerLocaleContent } from './tool/b
 export type { DeepSpaceScopeUI, DeepSpaceScopeLocaleContent } from './tool/deepSpaceScope';
 export type { StarExposureCalculatorUI, StarExposureCalculatorLocaleContent } from './tool/starExposureCalculator';
 export type { TelescopeResolutionUI, TelescopeResolutionLocaleContent } from './tool/telescopeResolution';
-export type { EyepieceCalculatorUI, EyepieceCalculatorLocaleContent } from './tool/smartEyepieceCalculator/entry';
+export type { EyepieceCalculatorUI, EyepieceCalculatorLocaleContent } from './tool/smartEyepieceCalculator/entry';
+export type { TelescopeExitPupilPlannerUI, TelescopeExitPupilPlannerLocaleContent } from './tool/telescopeExitPupilPlanner/entry';
 
 export type {
   KnownLocale,

package/src/entries.ts

@@ -8,10 +8,13 @@ export { telescopeResolution } from './tool/telescopeResolution/entry';
 export type { TelescopeResolutionUI, TelescopeResolutionLocaleContent } from './tool/telescopeResolution/entry';
 export { eyepieceCalculator } from './tool/smartEyepieceCalculator/entry';
 export type { EyepieceCalculatorUI, EyepieceCalculatorLocaleContent } from './tool/smartEyepieceCalculator/entry';
+export { telescopeExitPupilPlanner } from './tool/telescopeExitPupilPlanner/entry';
+export type { TelescopeExitPupilPlannerUI, TelescopeExitPupilPlannerLocaleContent } from './tool/telescopeExitPupilPlanner/entry';
 export { toolsCategory, astronomyCategory } from './category';
 import { bortleVisualizer } from './tool/bortleVisualizer/entry';
 import { deepSpaceScope } from './tool/deepSpaceScope/entry';
 import { starExposureCalculator } from './tool/starExposureCalculator/entry';
 import { telescopeResolution } from './tool/telescopeResolution/entry';
 import { eyepieceCalculator } from './tool/smartEyepieceCalculator/entry';
-export const ALL_ENTRIES = [bortleVisualizer, deepSpaceScope, starExposureCalculator, telescopeResolution, eyepieceCalculator];
+import { telescopeExitPupilPlanner } from './tool/telescopeExitPupilPlanner/entry';
+export const ALL_ENTRIES = [bortleVisualizer, deepSpaceScope, starExposureCalculator, telescopeResolution, eyepieceCalculator, telescopeExitPupilPlanner];

package/src/tests/locale_completeness.test.ts

@@ -2,8 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { ALL_TOOLS } from '../tools';
 
 describe('Locale Completeness Validation', () => {
-  it('all 4 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(5);
+  it('all 6 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(6);
   });
 });
-

package/src/tests/tool_validation.test.ts

@@ -75,9 +75,10 @@ describe('Tool Validation Suite', () => {
                   'simulador-cielo-oscuro',
                   'alcance-telescopio',
                   'calculadora-regla-500',
-                  'calculadora-resolucion-telescopio',
-                  'calculadora-oculares',
-                ];
+                  'calculadora-resolucion-telescopio',
+                  'calculadora-oculares',
+                  'planificador-pupila-salida-aumentos-telescopio',
+                ];
                 expect(validSlugs).toContain(content.slug);
               }
             });
@@ -102,12 +103,12 @@ describe('Tool Validation Suite', () => {
   });
 
   describe('Library Registration', () => {
-    it('should have 5 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(5);
+    it('should have 6 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(6);
     });
 
     it('should have all tools in astronomyCategory', () => {
-      expect(astronomyCategory.tools.length).toBe(5);
+      expect(astronomyCategory.tools.length).toBe(6);
       ALL_TOOLS.forEach(({ entry }) => {
         const exists = astronomyCategory.tools.some((t: any) => t.id === entry.id);
         expect(exists).toBe(true);

package/src/tool/telescopeExitPupilPlanner/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { telescopeExitPupilPlanner } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await telescopeExitPupilPlanner.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/telescopeExitPupilPlanner/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Sky & Telescope, Telescope Calculator: magnification, true field and exit pupil',
+    url: 'https://skyandtelescope.org/stargazing-and-observing/telescope-calculator/',
+  },
+  {
+    name: 'Universidad Nacional Autónoma de México, Óptica geométrica del telescopio y pupila de salida',
+    url: 'https://internos.icat.unam.mx/internosV2/public/documents/materialesRegistrados/documentosPDF/DocumentoPDF_692764f5337f2.pdf',
+  },
+];

package/src/tool/telescopeExitPupilPlanner/component.astro

@@ -0,0 +1,93 @@
+---
+import type { TelescopeExitPupilPlannerUI } from './ui';
+import { calculateOptics, DEFAULT_INPUTS } from './logic';
+
+interface Props {
+  ui: TelescopeExitPupilPlannerUI;
+}
+
+const { ui } = Astro.props;
+const initial = calculateOptics(DEFAULT_INPUTS);
+const uiJson = JSON.stringify(ui).replace(/</g, '\\u003c');
+---
+
+<script is:inline type="application/json" id="tep-ui-data" set:html={uiJson}></script>
+
+<div class="tep-root" id="tep-root">
+  <div class="tep-layout">
+    <section class="tep-inputs" aria-label="Optical setup">
+      <div class="tep-input-grid">
+        <label class="tep-field">
+          <span>{ui.apertureLabel}</span>
+          <div class="tep-number-wrap">
+            <input data-input="aperture" type="number" min="1" max="2000" step="1" value={DEFAULT_INPUTS.apertureMm} inputmode="decimal" />
+            <b>{ui.millimetreUnit}</b>
+          </div>
+        </label>
+        <label class="tep-field">
+          <span>{ui.scopeFocalLengthLabel}</span>
+          <div class="tep-number-wrap">
+            <input data-input="scope-focal-length" type="number" min="1" max="10000" step="1" value={DEFAULT_INPUTS.scopeFocalLengthMm} inputmode="decimal" />
+            <b>{ui.millimetreUnit}</b>
+          </div>
+        </label>
+        <label class="tep-field">
+          <span>{ui.eyepieceFocalLengthLabel}</span>
+          <div class="tep-number-wrap">
+            <input data-input="eyepiece-focal-length" type="number" min="1" max="200" step="0.1" value={DEFAULT_INPUTS.eyepieceFocalLengthMm} inputmode="decimal" />
+            <b>{ui.millimetreUnit}</b>
+          </div>
+        </label>
+        <div class="tep-field" data-select="barlow">
+          <span>{ui.barlowLabel}</span>
+          <input data-select-value type="hidden" value={DEFAULT_INPUTS.barlowFactor} />
+          <button class="tep-select-trigger" type="button" data-select-trigger aria-expanded="false" aria-haspopup="listbox">{ui.barlowOptions[0].label}</button>
+          <div class="tep-select-menu" data-select-menu hidden role="listbox">
+            {ui.barlowOptions.map((option) => <button type="button" data-select-option data-value={option.value} aria-selected={option.value === String(DEFAULT_INPUTS.barlowFactor)} role="option">{option.label}</button>)}
+          </div>
+        </div>
+        <div class="tep-field" data-select="apparent-field">
+          <span>{ui.apparentFieldLabel}</span>
+          <input data-select-value type="hidden" value={DEFAULT_INPUTS.apparentFieldDeg} />
+          <button class="tep-select-trigger" type="button" data-select-trigger aria-expanded="false" aria-haspopup="listbox">{ui.apparentFieldOptions[1].label}</button>
+          <div class="tep-select-menu" data-select-menu hidden role="listbox">
+            {ui.apparentFieldOptions.map((option) => <button type="button" data-select-option data-value={option.value} aria-selected={option.value === String(DEFAULT_INPUTS.apparentFieldDeg)} role="option">{option.label}</button>)}
+          </div>
+        </div>
+      </div>
+      <p class="tep-hint">{ui.presetHint}</p>
+      <button class="tep-reset" type="button" data-reset>{ui.resetLabel}</button>
+    </section>
+
+    <section class="tep-output" aria-live="polite">
+      <div class="tep-primary-result">
+        <span>{ui.magnificationLabel}</span>
+        <strong data-result="magnification">{initial.magnification.toFixed(1)}</strong><b>{ui.magnificationUnit}</b>
+        <small>{ui.magnificationHint}</small>
+      </div>
+      <div class="tep-metrics">
+        <div><span>{ui.exitPupilLabel}</span><div class="tep-metric-value"><strong data-result="exit-pupil">{initial.exitPupilMm.toFixed(2)}</strong><b>{ui.exitPupilUnit}</b></div></div>
+        <div><span>{ui.trueFieldLabel}</span><div class="tep-metric-value"><strong data-result="true-field">{initial.trueFieldDeg.toFixed(2)}</strong><b>{ui.fieldUnit}</b></div></div>
+        <div><span>{ui.focalRatioLabel}</span><div class="tep-metric-value"><strong data-result="focal-ratio">f/{initial.focalRatio.toFixed(1)}</strong><b>{ui.focalRatioUnit}</b></div></div>
+      </div>
+      <div class="tep-scene-wrap">
+        <div class="tep-scene-heading"><span>{ui.opticalPathLabel}</span><strong data-result="pupil-status">{ui.pupilWorking}</strong></div>
+        <div data-scene class="tep-scene" aria-label={ui.opticalPathLabel}></div>
+        <p class="tep-scene-copy" data-result="pupil-detail">{ui.pupilWorkingDetail}</p>
+      </div>
+      <div class="tep-footnotes">
+        <p><span>{ui.effectiveEyepieceLabel}</span><strong data-result="effective-eyepiece">{initial.effectiveEyepieceMm.toFixed(2)} {ui.millimetreUnit}</strong></p>
+        <p><span>{ui.assumptionLabel}</span>{ui.assumptionText}</p>
+        <p class="tep-hint">{ui.trueFieldHint}</p>
+      </div>
+    </section>
+  </div>
+</div>
+
+<script>
+  import { mountTelescopeExitPupilPlanner } from './controller';
+
+  const root = document.getElementById('tep-root');
+  const data = document.getElementById('tep-ui-data');
+  if (root && data) mountTelescopeExitPupilPlanner(root, JSON.parse(data.textContent || '{}'));
+</script>

package/src/tool/telescopeExitPupilPlanner/controller.ts

@@ -0,0 +1,102 @@
+import { calculateOptics, DEFAULT_INPUTS, type OpticsInputs } from './logic';
+import { clearStoredInputs, readStoredInputs, writeStoredInputs } from './storage';
+import { renderResults } from './dom-views';
+import type { TelescopeExitPupilPlannerUI } from './ui';
+
+interface CustomSelect {
+  root: HTMLElement;
+  value: HTMLInputElement;
+  trigger: HTMLButtonElement;
+  menu: HTMLElement;
+}
+
+function numberInput(root: HTMLElement, name: string): HTMLInputElement {
+  return root.querySelector<HTMLInputElement>(`[data-input="${name}"]`) as HTMLInputElement;
+}
+
+function setupSelect(root: HTMLElement): CustomSelect {
+  const value = root.querySelector<HTMLInputElement>('[data-select-value]') as HTMLInputElement;
+  const trigger = root.querySelector<HTMLButtonElement>('[data-select-trigger]') as HTMLButtonElement;
+  const menu = root.querySelector<HTMLElement>('[data-select-menu]') as HTMLElement;
+  const options = Array.from(root.querySelectorAll<HTMLButtonElement>('[data-select-option]'));
+
+  const close = () => {
+    menu.hidden = true;
+    trigger.setAttribute('aria-expanded', 'false');
+  };
+  const open = () => {
+    menu.hidden = false;
+    trigger.setAttribute('aria-expanded', 'true');
+  };
+  trigger.addEventListener('click', () => (menu.hidden ? open() : close()));
+  options.forEach((option) => {
+    option.addEventListener('click', () => {
+      value.value = option.dataset.value || '';
+      trigger.textContent = option.textContent || '';
+      options.forEach((item) => item.setAttribute('aria-selected', String(item === option)));
+      close();
+      root.dispatchEvent(new Event('change', { bubbles: true }));
+    });
+  });
+  document.addEventListener('click', (event) => {
+    if (!root.contains(event.target as Node)) close();
+  });
+  return { root, value, trigger, menu };
+}
+
+function readInputs(root: HTMLElement, selects: CustomSelect[]): OpticsInputs {
+  const value = (name: string) => Number(numberInput(root, name).value);
+  const selectValue = (name: string) => Number(selects.find((select) => select.root.dataset.select === name)?.value.value);
+  return {
+    apertureMm: value('aperture'),
+    scopeFocalLengthMm: value('scope-focal-length'),
+    eyepieceFocalLengthMm: value('eyepiece-focal-length'),
+    barlowFactor: selectValue('barlow'),
+    apparentFieldDeg: selectValue('apparent-field'),
+  };
+}
+
+function writeInputs(root: HTMLElement, selects: CustomSelect[], inputs: OpticsInputs): void {
+  numberInput(root, 'aperture').value = String(inputs.apertureMm);
+  numberInput(root, 'scope-focal-length').value = String(inputs.scopeFocalLengthMm);
+  numberInput(root, 'eyepiece-focal-length').value = String(inputs.eyepieceFocalLengthMm);
+  selects.forEach((select) => {
+    const inputName = select.root.dataset.select;
+    const value = inputName === 'barlow' ? inputs.barlowFactor : inputs.apparentFieldDeg;
+    const option = select.root.querySelector<HTMLButtonElement>(`[data-select-option][data-value="${value}"]`);
+    if (option) {
+      select.value.value = String(value);
+      select.trigger.textContent = option.textContent || '';
+      select.root.querySelectorAll('[data-select-option]').forEach((item) => item.setAttribute('aria-selected', String(item === option)));
+    }
+  });
+}
+
+function bindReset(root: HTMLElement, selects: CustomSelect[], ui: TelescopeExitPupilPlannerUI): void {
+  const reset = root.querySelector<HTMLButtonElement>('[data-reset]');
+  reset?.addEventListener('click', () => {
+    clearStoredInputs();
+    writeInputs(root, selects, DEFAULT_INPUTS);
+    root.dispatchEvent(new Event('input', { bubbles: true }));
+    reset.textContent = ui.resetLabel;
+  });
+}
+
+export function mountTelescopeExitPupilPlanner(root: HTMLElement, ui: TelescopeExitPupilPlannerUI): void {
+  const selects = Array.from(root.querySelectorAll<HTMLElement>('[data-select]')).map(setupSelect);
+  const stored = readStoredInputs();
+  const inputs = { ...DEFAULT_INPUTS, ...stored };
+  writeInputs(root, selects, inputs);
+
+  const update = () => {
+    const nextInputs = readInputs(root, selects);
+    const result = calculateOptics(nextInputs);
+    renderResults(root, result, ui);
+    writeStoredInputs(nextInputs);
+  };
+
+  root.querySelectorAll('input').forEach((input) => input.addEventListener('input', update));
+  root.querySelectorAll('[data-select]').forEach((select) => select.addEventListener('change', update));
+  bindReset(root, selects, ui);
+  update();
+}

package/src/tool/telescopeExitPupilPlanner/dom-views.ts

@@ -0,0 +1,64 @@
+import type { TelescopeExitPupilPlannerUI } from './ui';
+import type { OpticsResult } from './logic';
+import { evaluateExitPupil } from './evaluator';
+
+function formatNumber(value: number, digits = 2): string {
+  return value.toFixed(digits).replace(/\.00$/, '').replace(/(\.\d)0$/, '$1');
+}
+
+function sceneSvg(result: OpticsResult): string {
+  const pupilRadius = 9 + Math.min(22, Math.max(2, result.exitPupilMm * 3));
+  const coneWidth = 18 + Math.min(72, result.exitPupilMm * 10);
+  const fieldRadius = 34 + Math.min(42, result.trueFieldDeg * 16);
+
+  return `<svg class="tep-optical-scene" viewBox="0 0 640 250" role="img" aria-label="Optical path from aperture to exit pupil">
+    <rect class="tep-scene-ground" x="0" y="0" width="640" height="250" rx="18" />
+    <path class="tep-light-cone" d="M 92 87 L 420 ${125 - coneWidth / 2} L 420 ${125 + coneWidth / 2} Z" />
+    <path class="tep-light-cone tep-light-cone-secondary" d="M 92 163 L 420 ${125 - coneWidth / 2} L 420 ${125 + coneWidth / 2} Z" />
+    <rect class="tep-tube" x="42" y="76" width="58" height="98" rx="12" />
+    <circle class="tep-aperture" cx="71" cy="125" r="35" />
+    <circle class="tep-aperture-core" cx="71" cy="125" r="19" />
+    <rect class="tep-eyepiece" x="408" y="77" width="42" height="96" rx="10" />
+    <circle class="tep-exit-ring" cx="450" cy="125" r="${pupilRadius + 9}" />
+    <circle class="tep-exit-pupil" cx="450" cy="125" r="${pupilRadius}" />
+    <path class="tep-eye" d="M 500 125 Q 550 69 600 125 Q 550 181 500 125 Z" />
+    <circle class="tep-eye-iris" cx="550" cy="125" r="${Math.min(18, pupilRadius)}" />
+    <circle class="tep-eye-glint" cx="556" cy="118" r="3" />
+    <line class="tep-guide" x1="71" y1="207" x2="450" y2="207" />
+    <text class="tep-scene-label" x="71" y="232" text-anchor="middle">aperture</text>
+    <text class="tep-scene-label" x="450" y="232" text-anchor="middle">exit pupil</text>
+    <text class="tep-scene-value" x="550" y="49" text-anchor="middle">${formatNumber(result.trueFieldDeg, 2)}° field</text>
+    <circle class="tep-field-orbit" cx="550" cy="125" r="${fieldRadius}" />
+  </svg>`;
+}
+
+function setText(root: HTMLElement, name: string, value: string): void {
+  const element = root.querySelector<HTMLElement>(`[data-result="${name}"]`);
+  if (element) element.textContent = value;
+}
+
+function updateEvaluation(root: HTMLElement, result: OpticsResult, ui: TelescopeExitPupilPlannerUI): void {
+  const evaluation = evaluateExitPupil(result);
+  const labels = {
+    'too-small': [ui.pupilTooSmall, ui.pupilTooSmallDetail],
+    detail: [ui.pupilDetail, ui.pupilDetailDetail],
+    working: [ui.pupilWorking, ui.pupilWorkingDetail],
+    wide: [ui.pupilWide, ui.pupilWideDetail],
+  } as const;
+  const [label, detail] = labels[evaluation.band];
+  setText(root, 'pupil-status', label);
+  setText(root, 'pupil-detail', detail);
+  const marker = root.querySelector<HTMLElement>('[data-result="pupil-marker"]');
+  if (marker) marker.style.left = `${evaluation.markerPercent}%`;
+  const scene = root.querySelector<HTMLElement>('[data-scene]');
+  if (scene) scene.innerHTML = sceneSvg(result);
+}
+
+export function renderResults(root: HTMLElement, result: OpticsResult, ui: TelescopeExitPupilPlannerUI): void {
+  setText(root, 'magnification', formatNumber(result.magnification, 1));
+  setText(root, 'exit-pupil', formatNumber(result.exitPupilMm, 2));
+  setText(root, 'true-field', formatNumber(result.trueFieldDeg, 2));
+  setText(root, 'focal-ratio', `f/${formatNumber(result.focalRatio, 1)}`);
+  setText(root, 'effective-eyepiece', `${formatNumber(result.effectiveEyepieceMm, 2)} ${ui.millimetreUnit}`);
+  updateEvaluation(root, result, ui);
+}

package/src/tool/telescopeExitPupilPlanner/entry.ts

@@ -0,0 +1,31 @@
+import type { AstronomyToolEntry, ToolLocaleContent } from '../../types';
+import type { TelescopeExitPupilPlannerUI } from './ui';
+
+export type TelescopeExitPupilPlannerLocaleContent = ToolLocaleContent<TelescopeExitPupilPlannerUI>;
+
+export const telescopeExitPupilPlanner: AstronomyToolEntry<TelescopeExitPupilPlannerUI> = {
+  id: 'telescope-exit-pupil-planner',
+  icons: {
+    bg: 'mdi:eye-outline',
+    fg: 'mdi:telescope',
+  },
+  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 { bibliography } from './bibliography';

package/src/tool/telescopeExitPupilPlanner/evaluator.ts

@@ -0,0 +1,17 @@
+import type { OpticsResult } from './logic';
+
+export type PupilBand = 'too-small' | 'detail' | 'working' | 'wide';
+
+export interface PupilEvaluation {
+  band: PupilBand;
+  markerPercent: number;
+}
+
+export function evaluateExitPupil(result: OpticsResult): PupilEvaluation {
+  const markerPercent = Math.min(100, Math.max(0, (result.exitPupilMm / 7) * 100));
+
+  if (result.exitPupilMm < 0.5) return { band: 'too-small', markerPercent };
+  if (result.exitPupilMm < 1) return { band: 'detail', markerPercent };
+  if (result.exitPupilMm <= 5) return { band: 'working', markerPercent };
+  return { band: 'wide', markerPercent };
+}

package/src/tool/telescopeExitPupilPlanner/i18n/de.ts

@@ -0,0 +1,2 @@
+import { createTranslatedContent } from './translated';
+export const content = createTranslatedContent('de');

package/src/tool/telescopeExitPupilPlanner/i18n/en.ts

@@ -0,0 +1,177 @@
+import { bibliography } from '../bibliography';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { TelescopeExitPupilPlannerLocaleContent } from '../entry';
+import type { TelescopeExitPupilPlannerUI } from '../ui';
+
+const slug = 'telescope-exit-pupil-magnification-planner';
+const title = 'Telescope Exit Pupil and Magnification Planner';
+const description = 'Plan a telescope and eyepiece combination by calculating magnification, exit pupil, focal ratio and an estimated true field of view.';
+
+const ui: TelescopeExitPupilPlannerUI = {
+  apertureLabel: 'Telescope aperture',
+  scopeFocalLengthLabel: 'Telescope focal length',
+  eyepieceFocalLengthLabel: 'Eyepiece focal length',
+  barlowLabel: 'Barlow factor',
+  apparentFieldLabel: 'Eyepiece apparent field',
+  millimetreUnit: 'mm',
+  presetHint: 'Use the figures printed on your telescope and eyepiece. The field estimate assumes the selected apparent field.',
+  barlowOptions: [
+    { value: '1', label: 'No Barlow, 1x' },
+    { value: '1.5', label: '1.5x Barlow' },
+    { value: '2', label: '2x Barlow' },
+    { value: '2.5', label: '2.5x Barlow' },
+    { value: '3', label: '3x Barlow' },
+  ],
+  apparentFieldOptions: [
+    { value: '40', label: '40° narrow field' },
+    { value: '50', label: '50° standard field' },
+    { value: '60', label: '60° wide field' },
+    { value: '68', label: '68° wide angle' },
+    { value: '82', label: '82° ultra wide field' },
+  ],
+  magnificationLabel: 'Magnification',
+  exitPupilLabel: 'Exit pupil',
+  trueFieldLabel: 'Estimated true field',
+  focalRatioLabel: 'Focal ratio',
+  effectiveEyepieceLabel: 'Effective eyepiece',
+  magnificationUnit: 'x',
+  exitPupilUnit: 'mm',
+  fieldUnit: '°',
+  focalRatioUnit: 'f ratio',
+  opticalPathLabel: 'The optical path',
+  opticalPathDescription: 'A wider beam is brighter and easier to place your eye into. A narrower beam supports higher detail but gives a dimmer, less forgiving view.',
+  pupilTooSmall: 'Very demanding pupil',
+  pupilDetail: 'High detail pupil',
+  pupilWorking: 'Comfortable working pupil',
+  pupilWide: 'Wide field pupil',
+  pupilTooSmallDetail: 'Below 0.5 mm, diffraction, floaters and atmospheric turbulence become especially intrusive.',
+  pupilDetailDetail: 'Between 0.5 and 1 mm, the view favours fine detail when the atmosphere and optics cooperate.',
+  pupilWorkingDetail: 'Between 1 and 5 mm, the view balances brightness, detail and comfortable eye placement.',
+  pupilWideDetail: 'Above 5 mm, the view favours brightness and framing. Your eye may accept only part of a very large beam.',
+  assumptionLabel: 'Field estimate',
+  assumptionText: 'True field is estimated as apparent field divided by magnification. Distortion and the eyepiece field stop can make the real sky area differ.',
+  magnificationHint: 'Scope focal length divided by effective eyepiece focal length',
+  trueFieldHint: 'A planning estimate, not a drift measurement',
+  resetLabel: 'Reset figures',
+};
+
+const faq: TelescopeExitPupilPlannerLocaleContent['faq'] = [
+  {
+    question: 'How is telescope magnification calculated?',
+    answer: 'Magnification is the telescope focal length divided by the eyepiece focal length. A Barlow lens increases the effective telescope focal length, so this planner multiplies the basic magnification by the selected Barlow factor. For example, a 750 mm telescope with a 25 mm eyepiece gives 30x without a Barlow and 60x with a 2x Barlow.',
+  },
+  {
+    question: 'What does exit pupil tell me?',
+    answer: 'Exit pupil is the diameter of the light beam leaving the eyepiece. It equals the aperture divided by magnification, or the eyepiece focal length divided by the telescope focal ratio. A larger exit pupil usually gives a brighter and more forgiving view, while a smaller exit pupil supports higher magnification but makes dimness, eye floaters and unsteady air more noticeable.',
+  },
+  {
+    question: 'Can this planner calculate the exact true field of view?',
+    answer: 'No. It gives a useful first estimate by dividing the eyepiece apparent field by magnification. The exact field also depends on the eyepiece field stop and optical distortion. If you need an observed value, measure a star drift or use the manufacturer field stop specification for the specific eyepiece.',
+  },
+  {
+    question: 'Why does a Barlow change the exit pupil?',
+    answer: 'A Barlow increases the effective focal length of the telescope while the eyepiece stays the same. That raises magnification and therefore makes the exit pupil smaller. It can provide higher power without requiring an extremely short eyepiece, but the result is still limited by optical quality, alignment, tracking and atmospheric seeing.',
+  },
+];
+
+const howTo: TelescopeExitPupilPlannerLocaleContent['howTo'] = [
+  { name: 'Enter the telescope aperture', text: 'Enter the clear aperture printed in the telescope specifications. Use millimetres for all figures so the formulas share one unit.' },
+  { name: 'Enter both focal lengths', text: 'Add the telescope focal length and the eyepiece focal length. These two numbers determine the base magnification.' },
+  { name: 'Choose the optical accessories', text: 'Select the Barlow factor if one is in the optical path, then select the eyepiece apparent field from its specification.' },
+  { name: 'Read the optical path', text: 'Use the exit pupil band to decide whether the combination prioritises a wide bright view, a balanced view or high detail. Treat the true field as an estimate.' },
+];
+
+const seo: TelescopeExitPupilPlannerLocaleContent['seo'] = [
+  { type: 'title', text: 'Choose an Eyepiece With the Right Optical Tradeoff', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'Choosing an eyepiece is not just a matter of chasing the largest number followed by an x. The same telescope can produce a bright, easy to frame view or a narrow, demanding view depending on the eyepiece and any Barlow lens in the path. This planner turns the specifications on your equipment into four decisions you can compare: magnification, exit pupil, estimated true field and focal ratio.',
+  },
+  {
+    type: 'paragraph',
+    html: 'Start with the clear aperture and focal length of the telescope, then enter the focal length printed on the eyepiece. If you use a Barlow, its factor changes the effective focal length of the telescope. The planner shows that change directly, so you can see why a 2x Barlow makes a 25 mm eyepiece behave like a 12.5 mm eyepiece for magnification while preserving the longer eyepiece body.',
+  },
+  { type: 'title', text: 'How Magnification and Exit Pupil Work Together', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'Magnification is calculated as telescope focal length divided by the effective eyepiece focal length. Exit pupil is aperture divided by magnification. The two values move in opposite directions: pushing power higher shrinks the outgoing light beam. A large exit pupil tends to be comfortable for locating objects and framing extended targets, while a small exit pupil can make fine planetary or double star detail easier to inspect when the optics and atmosphere are steady.',
+  },
+  {
+    type: 'list',
+    items: [
+      'Use a wide exit pupil when you need brightness, generous eye placement or a large sweep of sky.',
+      'Use a middle exit pupil when you want a practical balance for general observing.',
+      'Use a small exit pupil only when the target, tracking and seeing justify the extra demand.',
+      'Compare the estimated field with the size of the target before choosing more power.',
+    ],
+  },
+  { type: 'title', text: 'Reading the Field of View Estimate', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'The true field estimate divides the eyepiece apparent field by magnification. It is useful for comparing combinations, but it is not an exact measurement of the sky. The field stop inside the eyepiece and optical distortion can change the result. If the manufacturer publishes a field stop, use it for a more precise calculation. For a direct observing check, time how long a star near the celestial equator takes to drift across the field with the drive turned off.',
+  },
+  {
+    type: 'table',
+    headers: ['Combination', 'Magnification', 'Exit pupil', 'Estimated field'],
+    rows: [
+      ['150 mm aperture, 750 mm scope, 25 mm eyepiece', '30x', '5.0 mm', '1.67° at 50° apparent field'],
+      ['150 mm aperture, 750 mm scope, 10 mm eyepiece', '75x', '2.0 mm', '0.67° at 50° apparent field'],
+      ['150 mm aperture, 750 mm scope, 25 mm eyepiece with 2x Barlow', '60x', '2.5 mm', '0.83° at 50° apparent field'],
+    ],
+  },
+  { type: 'title', text: 'Limits That the Numbers Cannot See', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'The calculator cannot inspect your eyepiece field stop, optical quality, collimation, mount stability or atmospheric seeing. A mathematically attractive combination may still look soft or shake at the eyepiece. The focal ratio is included as context because it helps you compare instruments, but it does not by itself predict visual image quality. Consider the result a planning map for your equipment, not a promise of resolution or brightness.',
+  },
+  {
+    type: 'tip',
+    title: 'Compare Before You Buy',
+    html: 'Enter two eyepieces in turn and compare exit pupil and estimated field before ordering an accessory. If the second option only raises magnification while producing a very small pupil and a narrow field, it may be better suited to rare steady nights than to everyday observing.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howTo.map((step) => ({
+    '@type': 'HowToStep',
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilitiesApplication',
+  operatingSystem: 'Web',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'en',
+};
+
+export const content: TelescopeExitPupilPlannerLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo,
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, howToSchema, appSchema],
+};

package/src/tool/telescopeExitPupilPlanner/i18n/es.ts

@@ -0,0 +1,2 @@
+import { createTranslatedContent } from './translated';
+export const content = createTranslatedContent('es');

package/src/tool/telescopeExitPupilPlanner/i18n/fr.ts

@@ -0,0 +1,2 @@
+import { createTranslatedContent } from './translated';
+export const content = createTranslatedContent('fr');

package/src/tool/telescopeExitPupilPlanner/i18n/id.ts

@@ -0,0 +1,2 @@
+import { createTranslatedContent } from './translated';
+export const content = createTranslatedContent('id');

package/src/tool/telescopeExitPupilPlanner/i18n/it.ts

@@ -0,0 +1,2 @@
+import { createTranslatedContent } from './translated';
+export const content = createTranslatedContent('it');

package/src/tool/telescopeExitPupilPlanner/i18n/ja.ts

@@ -0,0 +1,2 @@
+import { createTranslatedContent } from './translated';
+export const content = createTranslatedContent('ja');