@jjlmoya/utils-finance 1.19.0 → 1.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-finance",
-    "version": "1.19.0",
+    "version": "1.21.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/i18n/fr.ts

@@ -8,7 +8,7 @@ export const content: CategoryLocaleContent = {
   seo: [
     {
       type: 'title',
-      text: "Ingénierie Financière Personnelle : Décisions Basées sur les Mathématiques",
+      text: "Ingénierie Financière Personnelle: Décisions Basées sur les Mathématiques",
       level: 2,
     },
     {
@@ -21,7 +21,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: "Investissement et Patrimoine : Le Pouvoir des Intérêts Composés",
+      text: "Investissement et Patrimoine: Le Pouvoir des Intérêts Composés",
       level: 2,
     },
     {
@@ -34,7 +34,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Finances du Foyer : Prêts Immobiliers et Loyers',
+      text: 'Finances du Foyer: Prêts Immobiliers et Loyers',
       level: 2,
     },
     {
@@ -75,16 +75,16 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Diversification et Gestion du Risque : Portefeuille Optimal',
+      text: 'Diversification et Gestion du Risque: Portefeuille Optimal',
       level: 2,
     },
     {
       type: 'paragraph',
-      html: "Le risque ne peut pas être éliminé, mais il peut être géré. La diversification est la stratégie fondamentale : ne pas mettre tous ses œufs dans le même panier. Nos outils permettent de modéliser un portefeuille hypothétique avec différentes proportions (60% actions, 30% obligations, 10% liquidités).",
+      html: "Le risque ne peut pas être éliminé, mais il peut être géré. La diversification est la stratégie fondamentale: ne pas mettre tous ses œufs dans le même panier. Nos outils permettent de modéliser un portefeuille hypothétique avec différentes proportions (60% actions, 30% obligations, 10% liquidités).",
     },
     {
       type: 'title',
-      text: 'Analyse de Rentabilité : ROI et Période de Récupération',
+      text: 'Analyse de Rentabilité: ROI et Période de Récupération',
       level: 2,
     },
     {
@@ -93,7 +93,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Fiscalité et Déductions : Optimisation Fiscale',
+      text: 'Fiscalité et Déductions: Optimisation Fiscale',
       level: 2,
     },
     {
@@ -102,7 +102,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Cryptomonnaies et Actifs Numériques : Conversion et Valorisation',
+      text: 'Cryptomonnaies et Actifs Numériques: Conversion et Valorisation',
       level: 2,
     },
     {
@@ -111,7 +111,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Planification de la Retraite Anticipée : FIRE',
+      text: 'Planification de la Retraite Anticipée: FIRE',
       level: 2,
     },
     {

package/src/category/i18n/ru.ts

@@ -70,7 +70,7 @@ export const content: CategoryLocaleContent = {
     {
       type: 'tip',
       title: 'Стратегический Совет по Сбережениям',
-      html: '<p><strong>Стратегия 2026:</strong> В условиях устойчивой инфляции хранение наличных — гарантированный убыток. Используйте симулятор сложных процентов, чтобы оценить, как небольшое увеличение доходности кардинально влияет на вашу пенсию.</p>',
+      html: '<p><strong>Стратегия 2026:</strong> В условиях устойчивой инфляции хранение наличных - гарантированный убыток. Используйте симулятор сложных процентов, чтобы оценить, как небольшое увеличение доходности кардинально влияет на вашу пенсию.</p>',
     },
     {
       type: 'title',
@@ -79,7 +79,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: 'Риск нельзя устранить, но им можно управлять. Диверсификация — это фундаментальная стратегия: не кладите все яйца в одну корзину. Наши инструменты позволяют моделировать гипотетический портфель с разными долями (60% акций, 30% облигаций, 10% наличных) и прогнозировать его историческую доходность в разных рыночных сценариях.',
+      html: 'Риск нельзя устранить, но им можно управлять. Диверсификация - это фундаментальная стратегия: не кладите все яйца в одну корзину. Наши инструменты позволяют моделировать гипотетический портфель с разными долями (60% акций, 30% облигаций, 10% наличных) и прогнозировать его историческую доходность в разных рыночных сценариях.',
     },
     {
       type: 'title',
@@ -97,7 +97,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: 'Налоги поглощают более половины состояния многих людей. Знание, какие расходы вычитаются, какие инвестиции генерируют отложенные налоги (пенсионные планы) и как получить возврат — разница между пассивным и активным налогоплательщиком.',
+      html: 'Налоги поглощают более половины состояния многих людей. Знание, какие расходы вычитаются, какие инвестиции генерируют отложенные налоги (пенсионные планы) и как получить возврат - разница между пассивным и активным налогоплательщиком.',
     },
     {
       type: 'title',
@@ -142,7 +142,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: 'Будущее финансов — это <strong>самостоятельное хранение и техническое понимание</strong>. Доверять тому, что говорит банк, больше недостаточно. Эти инструменты дают способность проверять каждый цент, каждое начисление процентов и каждый договор, позволяя ориентироваться в финансовой системе с уверенностью, которую даёт математическое знание.',
+      html: 'Будущее финансов - это <strong>самостоятельное хранение и техническое понимание</strong>. Доверять тому, что говорит банк, больше недостаточно. Эти инструменты дают способность проверять каждый цент, каждое начисление процентов и каждый договор, позволяя ориентироваться в финансовой системе с уверенностью, которую даёт математическое знание.',
     },
     {
       type: 'stats',

package/src/layouts/PreviewLayout.astro

@@ -78,6 +78,7 @@ const { title, currentLocale = "es", localeUrls = {}, hasSidebar = false } = Ast
     transition:
       background-color 0.3s ease,
       color 0.3s ease;
+    font-family: Inter, sans-serif;
   }
 
   main {

package/src/tests/diacritics_density.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it, afterAll } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const failures: Map<string, string[]> = new Map();
+
+type LocaleWithDiacritics = keyof typeof DIACRITIC_RULES;
+
+const DIACRITIC_RULES = {
+  de: {
+    language: 'German',
+    expectedCharacters: 'ä ö ü ß',
+    characters: /[äöüÄÖÜß]/g,
+    minPerThousandLetters: 0.1,
+  },
+  es: {
+    language: 'Spanish',
+    expectedCharacters: 'á é í ó ú ü ñ',
+    characters: /[áéíóúüñÁÉÍÓÚÜÑ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  fr: {
+    language: 'French',
+    expectedCharacters: 'à â æ ç é è ê ë î ï ô œ ù û ü ÿ',
+    characters: /[àâæçéèêëîïôœùûüÿÀÂÆÇÉÈÊËÎÏÔŒÙÛÜŸ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  it: {
+    language: 'Italian',
+    expectedCharacters: 'à è é ì í î ò ó ù ú',
+    characters: /[àèéìíîòóùúÀÈÉÌÍÎÒÓÙÚ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pl: {
+    language: 'Polish',
+    expectedCharacters: 'ą ć ę ł ń ó ś ź ż',
+    characters: /[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pt: {
+    language: 'Portuguese',
+    expectedCharacters: 'á â ã à ç é ê í ó ô õ ú ü',
+    characters: /[áâãàçéêíóôõúüÁÂÃÀÇÉÊÍÓÔÕÚÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  sv: {
+    language: 'Swedish',
+    expectedCharacters: 'å ä ö',
+    characters: /[åäöÅÄÖ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  tr: {
+    language: 'Turkish',
+    expectedCharacters: 'ç ğ ı İ ö ş ü',
+    characters: /[çğıöşüÇĞİÖŞÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function diacriticCount(text: string, locale: LocaleWithDiacritics): number {
+  return text.match(DIACRITIC_RULES[locale].characters)?.length ?? 0;
+}
+
+function diacriticsPerThousandLetters(text: string, locale: LocaleWithDiacritics): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return diacriticCount(text, locale) / letters * 1000;
+}
+
+describe('Diacritics density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(DIACRITIC_RULES).forEach((locale) => {
+        it(`${locale} keeps the expected accent and special-letter set`, async () => {
+          const typedLocale = locale as LocaleWithDiacritics;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const rule = DIACRITIC_RULES[typedLocale];
+          const letters = letterCount(text);
+          const matches = diacriticCount(text, typedLocale);
+          const density = diacriticsPerThousandLetters(text, typedLocale);
+
+          expect(
+            density,
+            [
+              `Possible spelling or encoding issue detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} special characters (${density.toFixed(2)} per 1000 letters, ${letters} letters analyzed).`,
+              `This locale should include some of these characters: ${rule.expectedCharacters}.`,
+              'If the count is 0 or near 0, accents, tildes, or special letters were probably stripped by encoding or normalization.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minPerThousandLetters);
+
+          if (density < rule.minPerThousandLetters) {
+            const existing = failures.get(tool.entry.id) ?? [];
+            existing.push(typedLocale);
+            failures.set(tool.entry.id, existing);
+          }
+        });
+      });
+    });
+  });
+});
+
+afterAll(() => {
+  if (failures.size > 0) {
+    const sorted = [...failures.entries()].sort(([a], [b]) => a.localeCompare(b));
+    console.log('\n=== DIACRITICS DENSITY FAILURES (grouped by tool) ===');
+    let total = 0;
+    for (const [tool, locales] of sorted) {
+      locales.sort();
+      console.log(`  ${tool}: ${locales.join(', ')}`);
+      total += locales.length;
+    }
+    console.log(`  Total: ${total} failures across ${failures.size} tools\n`);
+  }
+});

package/src/tests/inverted_punctuation.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const INVERTED_PUNCTUATION_LOCALES = {
+  es: {
+    language: 'Spanish',
+    questionStart: '¿',
+    questionEnd: '?',
+    exclamationStart: '¡',
+    exclamationEnd: '!',
+  },
+} as const;
+
+type InvertedPunctuationLocale = keyof typeof INVERTED_PUNCTUATION_LOCALES;
+
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function translatableStrings(content: Record<string, unknown>): string[] {
+  return TRANSLATABLE_KEYS.flatMap((key) => collectStrings(content[key]));
+}
+
+const SENTENCE_BOUNDARIES = ['.', ':', ';', '\n'];
+
+function isNumberPeriod(text: string, index: number): boolean {
+  const prev = text[index - 1];
+  const next = text[index + 1];
+  return prev !== undefined && next !== undefined && /\d/.test(prev) && /\d/.test(next);
+}
+
+function sentenceStart(text: string, endIndex: number): string {
+  const beforeMark = text.slice(0, endIndex).trimEnd();
+
+  for (let i = beforeMark.length - 1; i >= 0; i--) {
+    if (SENTENCE_BOUNDARIES.includes(beforeMark[i])) {
+      if (beforeMark[i] === '.' && isNumberPeriod(beforeMark, i)) {
+        continue;
+      }
+      return beforeMark.slice(i + 1).trimStart();
+    }
+  }
+
+  return beforeMark.trimStart();
+}
+
+function findMissingInvertedMarks(
+  text: string,
+  startMark: string,
+  endMark: string,
+): string[] {
+  return [...text.matchAll(new RegExp(`\\${endMark}`, 'g'))]
+    .map((match) => sentenceStart(text, match.index ?? 0))
+    .filter((segment) => segment.length > 0 && !segment.includes(startMark))
+    .map((segment) => `${segment}${endMark}`);
+}
+
+describe('Inverted punctuation validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(INVERTED_PUNCTUATION_LOCALES).forEach((locale) => {
+        it(`${locale} uses opening punctuation marks for questions and exclamations`, async () => {
+          const typedLocale = locale as InvertedPunctuationLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const rule = INVERTED_PUNCTUATION_LOCALES[typedLocale];
+          const content = await loader();
+          const strings = translatableStrings(content as Record<string, unknown>);
+          const missingQuestions = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd)
+          );
+          const missingExclamations = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.exclamationStart, rule.exclamationEnd)
+          );
+          const failures = [...missingQuestions, ...missingExclamations];
+
+          expect(
+            failures,
+            [
+              `Missing opening punctuation marks in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `Questions must use ${rule.questionStart}...${rule.questionEnd} and exclamations must use ${rule.exclamationStart}...${rule.exclamationEnd}.`,
+              `Examples: ${failures.slice(0, 5).join(' | ')}`,
+            ].join(' '),
+          ).toHaveLength(0);
+        });
+      });
+    });
+  });
+});

package/src/tests/no_en_dash.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function getFiles(dir: string): string[] {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) {
+    return results;
+  }
+  const list = fs.readdirSync(dir);
+  for (const file of list) {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+    if (stat && stat.isDirectory()) {
+      if (file !== 'tests' && file !== 'node_modules' && file !== '.astro') {
+        results.push(...getFiles(fullPath));
+      }
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+function isContentFile(filePath: string): boolean {
+  return /\\i18n\\/.test(filePath) || filePath.endsWith('bibliography.ts');
+}
+
+const srcDir = path.join(process.cwd(), 'src');
+const scriptsDir = path.join(process.cwd(), 'scripts');
+const filesToTest = [
+  ...getFiles(srcDir).filter(isContentFile),
+  ...getFiles(scriptsDir).filter(isContentFile),
+];
+
+const aiTypographyGarbage = [
+  '\u2013',
+  '\u2014',
+  '\u2026',
+  '\u201C',
+  '\u201D',
+  '\u2018',
+  '\u2019',
+  '\u00AB',
+  '\u00BB',
+  '\u200B',
+  '\u201E',
+];
+
+describe('Typography Garbage Character Validation', () => {
+  filesToTest.forEach((filePath) => {
+    const relativePath = path.relative(process.cwd(), filePath);
+    it(`should not contain typography garbage characters in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const hasAiPatterns = aiTypographyGarbage.some(char => content.includes(char));
+      expect(hasAiPatterns).toBe(false);
+    });
+
+    it(`should not contain space before colon in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const spaceBeforeColon = / : /.test(content);
+      expect(spaceBeforeColon).toBe(false);
+    });
+
+    it(`should not contain double hyphen in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).not.toContain('--');
+    });
+  });
+});

package/src/tests/script_density.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+  ja: {
+    language: 'Japanese',
+    scriptName: 'kana/kanji',
+    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
+    minScriptRatio: 0.45,
+  },
+  ko: {
+    language: 'Korean',
+    scriptName: 'hangul',
+    scriptCharacters: /\p{Script=Hangul}/gu,
+    minScriptRatio: 0.55,
+  },
+  ru: {
+    language: 'Russian',
+    scriptName: 'cyrillic',
+    scriptCharacters: /\p{Script=Cyrillic}/gu,
+    minScriptRatio: 0.65,
+  },
+  zh: {
+    language: 'Chinese',
+    scriptName: 'han',
+    scriptCharacters: /\p{Script=Han}/gu,
+    minScriptRatio: 0.45,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(SCRIPT_RULES).forEach((locale) => {
+        it(`${locale} keeps most translated text in its native script`, async () => {
+          const typedLocale = locale as ScriptLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const rule = SCRIPT_RULES[typedLocale];
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const letters = letterCount(text);
+          const matches = scriptCount(text, typedLocale);
+          const ratio = scriptRatio(text, typedLocale);
+
+          expect(
+            ratio,
+            [
+              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+              `Most translatable content should be written in ${rule.scriptName} script.`,
+              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+        });
+      });
+    });
+  });
+});