@jjlmoya/utils-home 1.35.0 → 1.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-home",
-    "version": "1.35.0",
+    "version": "1.37.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/scripts/fix_ru.mjs

@@ -0,0 +1,79 @@
+import { readFileSync, writeFileSync } from 'fs';
+
+function toCyrillic(text) {
+  let result = '';
+  let i = 0;
+
+  while (i < text.length) {
+    const c4 = text.slice(i, i + 4);
+    if (c4.length === 4) {
+      const t = { 'shch':'щ', 'SHCH':'Щ', 'Shch':'Щ' };
+      if (t[c4]) { result += t[c4]; i += 4; continue; }
+    }
+
+    if (i + 2 <= text.length) {
+      const two = text.slice(i, i + 2);
+
+      if (two === 'ya' || two === 'YA' || two === 'Ya') { result += ({'ya':'я','YA':'Я','Ya':'Я'})[two]; i += 2; continue; }
+      if (two === 'ye' || two === 'YE' || two === 'Ye') { result += ({'ye':'е','YE':'Е','Ye':'Е'})[two]; i += 2; continue; }
+      if (two === 'yo' || two === 'YO' || two === 'Yo') { result += ({'yo':'ё','YO':'Ё','Yo':'Ё'})[two]; i += 2; continue; }
+      if (two === 'yu' || two === 'YU' || two === 'Yu') { result += ({'yu':'ю','YU':'Ю','Yu':'Ю'})[two]; i += 2; continue; }
+
+      if (two === 'zh' || two === 'ZH' || two === 'Zh') { result += ({'zh':'ж','ZH':'Ж','Zh':'Ж'})[two]; i += 2; continue; }
+      if (two === 'ch' || two === 'CH' || two === 'Ch') { result += ({'ch':'ч','CH':'Ч','Ch':'Ч'})[two]; i += 2; continue; }
+      if (two === 'sh' || two === 'SH' || two === 'Sh') { result += ({'sh':'ш','SH':'Ш','Sh':'Ш'})[two]; i += 2; continue; }
+      if (two === 'kh' || two === 'KH' || two === 'Kh') { result += ({'kh':'х','KH':'Х','Kh':'Х'})[two]; i += 2; continue; }
+      if (two === 'ts' || two === 'TS' || two === 'Ts') { result += ({'ts':'ц','TS':'Ц','Ts':'Ц'})[two]; i += 2; continue; }
+
+      const next = text[i + 2] || '';
+      if (two === 'iy' && next !== 'a' && next !== 'e' && next !== 'o' && next !== 'u') { result += 'ий'; i += 2; continue; }
+      if (two === 'yy' && next !== 'a' && next !== 'e' && next !== 'o' && next !== 'u') { result += 'ый'; i += 2; continue; }
+      if (two === 'oy' && next !== 'a' && next !== 'e' && next !== 'o' && next !== 'u') { result += 'ой'; i += 2; continue; }
+      if (two === 'ay' && next !== 'a' && next !== 'e' && next !== 'o' && next !== 'u') { result += 'ай'; i += 2; continue; }
+      if (two === 'ey' && next !== 'a' && next !== 'e' && next !== 'o' && next !== 'u') { result += 'ей'; i += 2; continue; }
+    }
+
+    const c = text[i];
+    const smap = {
+      'A':'А','a':'а','B':'Б','b':'б','V':'В','v':'в','G':'Г','g':'г',
+      'D':'Д','d':'д','E':'Э','e':'е','Z':'З','z':'з','I':'И','i':'и',
+      'K':'К','k':'к','L':'Л','l':'л','M':'М','m':'м','N':'Н','n':'н',
+      'O':'О','o':'о','P':'П','p':'п','R':'Р','r':'р','S':'С','s':'с',
+      'T':'Т','t':'т','U':'У','u':'у','F':'Ф','f':'ф','C':'Ц','c':'ц',
+      'H':'Х','h':'х','Y':'Ы','y':'ы','J':'Й','j':'й',
+    };
+    if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
+      result += smap[c] || c;
+    } else {
+      result += c;
+    }
+    i++;
+  }
+
+  result = result.replace(/WиФи/gi, 'WiFi');
+  result = result.replace(/Wи-Фи/gi, 'Wi-Fi');
+
+  return result;
+}
+
+function countLatin(s) {
+  return (s.match(/[a-zA-Z]/g) || []).length;
+}
+
+const filePath = process.argv[2];
+let content = readFileSync(filePath, 'utf-8');
+
+content = content.replace(/'([^']*)'/g, (full, text) => {
+  if (text.length < 5) return full;
+  if (/^(http|\/|\.|#|@|mdi:)/.test(text)) return full;
+  if (/^[0-9+\-.,%°\s]+$/.test(text)) return full;
+  if (/^(FAQPage|HowTo|SoftwareApplication|UtilityApplication|Question|Answer|HowToStep|Offer|schema-dts)$/.test(text)) return full;
+
+  const latin = countLatin(text);
+  if (latin < 5) return full;
+
+  return "'" + toCyrillic(text) + "'";
+});
+
+writeFileSync(filePath, content, 'utf-8');
+console.log('Done');

package/src/entries.ts

@@ -30,6 +30,8 @@ export { lightingCalculator } from './tool/lightingCalculator/entry';
 export type { LightingCalculatorLocaleContent } from './tool/lightingCalculator/entry';
 export { humidityCalculator } from './tool/humidityCalculator/entry';
 export type { HumidityCalculatorLocaleContent } from './tool/humidityCalculator/entry';
+export { waterSoftener } from './tool/waterSoftener/entry';
+export type { WaterSoftenerLocaleContent } from './tool/waterSoftener/entry';
 export { homeCategory } from './category';
 import { dewPointCalculator } from './tool/dewPointCalculator/entry';
 import { heatingComparator } from './tool/heatingComparator/entry';
@@ -47,4 +49,5 @@ import { applianceCostCalculator } from './tool/applianceCostCalculator/entry';
 import { tileLayoutCalculator } from './tool/tileLayoutCalculator/entry';
 import { lightingCalculator } from './tool/lightingCalculator/entry';
 import { humidityCalculator } from './tool/humidityCalculator/entry';
-export const ALL_ENTRIES = [dewPointCalculator, heatingComparator, ledSavingCalculator, projectorCalculator, qrGenerator, solarCalculator, tariffComparator, wifiRangeSimulator, acTonnageCalculator, wallPaintingCalculator, vampireDrawSimulator, deskErgonomics, applianceCostCalculator, tileLayoutCalculator, lightingCalculator, humidityCalculator];
+import { waterSoftener } from './tool/waterSoftener/entry';
+export const ALL_ENTRIES = [dewPointCalculator, heatingComparator, ledSavingCalculator, projectorCalculator, qrGenerator, solarCalculator, tariffComparator, wifiRangeSimulator, acTonnageCalculator, wallPaintingCalculator, vampireDrawSimulator, deskErgonomics, applianceCostCalculator, tileLayoutCalculator, lightingCalculator, humidityCalculator, waterSoftener];

package/src/index.ts

@@ -30,4 +30,5 @@ export { DESK_ERGONOMICS_TOOL } from './tool/deskErgonomics';
 export { APPLIANCE_COST_CALCULATOR_TOOL } from './tool/applianceCostCalculator';
 export { TILE_LAYOUT_CALCULATOR_TOOL } from './tool/tileLayoutCalculator';
 export { HUMIDITY_CALCULATOR_TOOL } from './tool/humidityCalculator';
+export { WATER_SOFTENER_TOOL } from './tool/waterSoftener';
 

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,118 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+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);
+        });
+      });
+    });
+  });
+});

package/src/tests/inverted_punctuation.test.ts

@@ -0,0 +1,84 @@
+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]));
+}
+
+function sentenceStart(text: string, endIndex: number): string {
+  const beforeMark = text.slice(0, endIndex).trimEnd();
+  const boundary = Math.max(
+    beforeMark.lastIndexOf('.'),
+    beforeMark.lastIndexOf(':'),
+    beforeMark.lastIndexOf(';'),
+    beforeMark.lastIndexOf('\n'),
+  );
+
+  return beforeMark.slice(boundary + 1).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/locale_completeness.test.ts

@@ -17,8 +17,8 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-  it('should have 16 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(16);
+  it('should have 17 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(17);
   });
 });
 

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);
+        });
+      });
+    });
+  });
+});

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { homeCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 16 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(16);
+    it('should have 17 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(17);
     });
 
     it('homeCategory should be defined', () => {