@jjlmoya/utils-nautical 1.18.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-nautical",
-    "version": "1.18.0",
+    "version": "1.20.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -28,7 +28,7 @@
         "check": "astro check",
         "type-check": "astro check",
         "test": "vitest run",
-        "preversion": "npm run lint && npm run test",
+        "preversion": "npm run lint && npm run test && npm run build",
         "postversion": "git push && git push --tags",
         "patch": "npm version patch",
         "minor": "npm version minor",

package/src/category/index.ts

@@ -5,12 +5,13 @@ import { nauticalConverter } from '../tool/nauticalConverter/entry';
 import { sailArea } from '../tool/sailArea/entry';
 import { speedConverter } from '../tool/speedConverter/entry';
 import { endurance } from '../tool/endurance/entry';
+import { anchorScope } from '../tool/anchorScope/entry';
 
 export type { CategoryLocaleContent };
 
 export const nauticalCategory: NauticalCategoryEntry = {
   icon: 'mdi:sail-boat',
-  tools: [tideCalculator, underKeel, nauticalConverter, sailArea, speedConverter, endurance],
+  tools: [tideCalculator, underKeel, nauticalConverter, sailArea, speedConverter, endurance, anchorScope],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -10,6 +10,9 @@ export { tideCalculator } from './tool/tideCalculator/entry';
 export type { TideCalculatorUI, TideCalculatorLocaleContent } from './tool/tideCalculator/entry';
 export { underKeel } from './tool/underKeel/entry';
 export type { UnderKeelUI, UnderKeelLocaleContent } from './tool/underKeel/entry';
+export { anchorScope } from './tool/anchorScope/entry';
+export type { AnchorScopeLocaleContent } from './tool/anchorScope/entry';
+export type { AnchorScopeUI } from './tool/anchorScope/ui';
 export { nauticalCategory } from './category';
 import { endurance } from './tool/endurance/entry';
 import { nauticalConverter } from './tool/nauticalConverter/entry';
@@ -17,4 +20,5 @@ import { sailArea } from './tool/sailArea/entry';
 import { speedConverter } from './tool/speedConverter/entry';
 import { tideCalculator } from './tool/tideCalculator/entry';
 import { underKeel } from './tool/underKeel/entry';
-export const ALL_ENTRIES = [endurance, nauticalConverter, sailArea, speedConverter, tideCalculator, underKeel];
+import { anchorScope } from './tool/anchorScope/entry';
+export const ALL_ENTRIES = [endurance, nauticalConverter, sailArea, speedConverter, tideCalculator, underKeel, anchorScope];

package/src/index.ts

@@ -1,10 +1,4 @@
-export * from './tool/tideCalculator';
-export * from './tool/underKeel';
-export * from './tool/nauticalConverter';
-export * from './tool/sailArea';
-export * from './tool/speedConverter';
-export * from './tool/endurance';
-export * from './category';
+export { nauticalCategory } from './category';
 export const NauticalCategorySEO = () => import('./category/seo.astro').then((m) => m.default);
 
 export type {
@@ -18,6 +12,14 @@ export type {
   LocaleMap,
   NauticalToolEntry,
   NauticalCategoryEntry,
+  ToolDefinition,
 } from './types';
 
 export { ALL_ENTRIES, ALL_TOOLS } from './tools';
+export { tideCalculator, TIDE_CALCULATOR_TOOL } from './tool/tideCalculator';
+export { underKeel, UNDER_KEEL_TOOL } from './tool/underKeel';
+export { nauticalConverter, NAUTICAL_CONVERTER_TOOL } from './tool/nauticalConverter';
+export { sailArea, SAIL_AREA_TOOL } from './tool/sailArea';
+export { speedConverter, SPEED_CONVERTER_TOOL } from './tool/speedConverter';
+export { endurance, ENDURANCE_TOOL } from './tool/endurance';
+export { anchorScope, ANCHOR_SCOPE_TOOL } from './tool/anchorScope';

package/src/tests/diacritics_density.test.ts

@@ -96,7 +96,7 @@ describe('Diacritics density validation', () => {
           if (!loader) return;
 
           const content = await loader();
-          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const text = normalizeText(translatableContent((content as unknown) as Record<string, unknown>));
           const rule = DIACRITIC_RULES[typedLocale];
           const letters = letterCount(text);
           const matches = diacriticCount(text, typedLocale);

package/src/tests/inverted_punctuation.test.ts

@@ -60,7 +60,7 @@ describe('Inverted punctuation validation', () => {
 
           const rule = INVERTED_PUNCTUATION_LOCALES[typedLocale];
           const content = await loader();
-          const strings = translatableStrings(content as Record<string, unknown>);
+          const strings = translatableStrings((content as unknown) as Record<string, unknown>);
           const missingQuestions = strings.flatMap((text) =>
             findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd)
           );

package/src/tests/locale_completeness.test.ts

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

package/src/tests/script_density.test.ts

@@ -73,7 +73,7 @@ describe('Native script density validation', () => {
 
           const content = await loader();
           const rule = SCRIPT_RULES[typedLocale];
-          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const text = normalizeText(translatableContent((content as unknown) as Record<string, unknown>));
           const letters = letterCount(text);
           const matches = scriptCount(text, typedLocale);
           const ratio = scriptRatio(text, typedLocale);

package/src/tests/seo_parity.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+import type { KnownLocale } from '../types';
+
+interface ExpectedCounts {
+  seo: number;
+  faq: number;
+  howTo: number;
+}
+
+function countItems(arr: unknown[] | undefined): number {
+  return arr?.length ?? 0;
+}
+
+async function verifyLocaleParity(
+  entry: typeof ALL_ENTRIES[number],
+  loc: KnownLocale,
+  expected: ExpectedCounts,
+): Promise<void> {
+  const locContent = await entry.i18n[loc]?.();
+  expect(locContent, `Locale ${loc} missing content`).toBeDefined();
+
+  const locSeoCount = countItems(locContent?.seo);
+  const locFaqCount = countItems(locContent?.faq);
+  const locHowToCount = countItems(locContent?.howTo);
+
+  expect(
+    locSeoCount,
+    `Locale ${loc} SEO sections count (${locSeoCount}) must match EN (${expected.seo})`,
+  ).toBe(expected.seo);
+  expect(
+    locFaqCount,
+    `Locale ${loc} FAQ items count (${locFaqCount}) must match EN (${expected.faq})`,
+  ).toBe(expected.faq);
+  expect(
+    locHowToCount,
+    `Locale ${loc} HowTo steps count (${locHowToCount}) must match EN (${expected.howTo})`,
+  ).toBe(expected.howTo);
+}
+
+describe('SEO & i18n Structural Parity Suite', () => {
+  ALL_ENTRIES.forEach((entry) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('all 15 locales should have identical SEO section counts and types as English', async () => {
+        const enContent = await entry.i18n.en?.();
+        expect(enContent).toBeDefined();
+        const expected: ExpectedCounts = {
+          seo: countItems(enContent?.seo),
+          faq: countItems(enContent?.faq),
+          howTo: countItems(enContent?.howTo),
+        };
+
+        const locales = Object.keys(entry.i18n) as KnownLocale[];
+        for (const loc of locales) {
+          await verifyLocaleParity(entry, loc, expected);
+        }
+      });
+    });
+  });
+});

package/src/tests/title_quality.test.ts

@@ -40,7 +40,7 @@ describe('Project Titles - Separator Validation', () => {
     for (const pattern of titlePatterns) {
       let match;
       while ((match = pattern.exec(content)) !== null) {
-        const title = match[1];
+        const title = match[1] ?? '';
         if (title.includes('|') || title.includes('-')) {
           findings.push(title);
         }

package/src/tests/tool_validation.test.ts

@@ -5,8 +5,8 @@ const TOOL_ID_REGEX = /^[a-z0-9]+-?[a-z0-9]*$/;
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 6 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(6);
+    it('should have 7 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(7);
     });
   });
 

package/src/tests/translation_copy.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+
+const COPY_THRESHOLD = 0.9;
+
+const STRUCTURAL_KEYS = new Set([
+  '@context',
+  '@type',
+  'applicationCategory',
+  'columns',
+  'highlight',
+  'icon',
+  'level',
+  'operatingSystem',
+  'position',
+  'positive',
+  'price',
+  'priceCurrency',
+  'slug',
+  'trend',
+  'type',
+  'url',
+  'value',
+  'variant',
+]);
+
+function normalizeText(value: string): string {
+  return value
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&(?:amp|lt|gt|quot|apos|nbsp);/gi, ' ')
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u201c\u201d]/g, '"')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLocaleLowerCase();
+}
+
+function collectText(value: unknown, path: string, parts: string[]): void {
+  if (typeof value === 'string') {
+    const normalized = normalizeText(value);
+    if (normalized.length >= 2) parts.push(normalized);
+    return;
+  }
+
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectText(item, `${path}[${index}]`, parts));
+    return;
+  }
+
+  if (!value || typeof value !== 'object') return;
+
+  Object.entries(value).forEach(([key, child]) => {
+    if (STRUCTURAL_KEYS.has(key)) return;
+    collectText(child, `${path}.${key}`, parts);
+  });
+}
+
+function localeCorpus(content: unknown): string {
+  if (!content || typeof content !== 'object') return '';
+
+  const record = content as Record<string, unknown>;
+  const parts: string[] = [];
+  collectText(record.title, 'title', parts);
+  collectText(record.description, 'description', parts);
+  collectText(record.faqTitle, 'faqTitle', parts);
+  collectText(record.faq, 'faq', parts);
+  collectText(record.seo, 'seo', parts);
+  collectText(record.schemas, 'schemas', parts);
+  return parts.join(' ');
+}
+
+function tokenCounts(text: string): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const token of text.match(/[\p{L}\p{N}]+/gu) ?? []) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function copySimilarity(left: string, right: string): number {
+  const leftCounts = tokenCounts(left);
+  const rightCounts = tokenCounts(right);
+  const leftTotal = [...leftCounts.values()].reduce((sum, count) => sum + count, 0);
+  const rightTotal = [...rightCounts.values()].reduce((sum, count) => sum + count, 0);
+  if (leftTotal === 0 || rightTotal === 0) return 0;
+
+  let shared = 0;
+  for (const [token, count] of leftCounts) {
+    shared += Math.min(count, rightCounts.get(token) ?? 0);
+  }
+  return (2 * shared) / (leftTotal + rightTotal);
+}
+
+describe('Locales must not copy another locale wholesale', () => {
+  ALL_ENTRIES.forEach((entry) => {
+    it(`${entry.id} is not at least ${COPY_THRESHOLD * 100}% identical to another locale`, async () => {
+      const corpora = new Map<string, string>();
+
+      for (const [locale, loader] of Object.entries(entry.i18n)) {
+        if (!loader) continue;
+        corpora.set(locale, localeCorpus(await loader()));
+      }
+
+      const locales = [...corpora.keys()];
+      const violations: string[] = [];
+
+      for (let leftIndex = 0; leftIndex < locales.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < locales.length; rightIndex += 1) {
+          const left = locales[leftIndex];
+          const right = locales[rightIndex];
+          const similarity = copySimilarity(corpora.get(left) ?? '', corpora.get(right) ?? '');
+
+          if (similarity >= COPY_THRESHOLD) {
+            violations.push(`${left} ↔ ${right}: ${(similarity * 100).toFixed(1)}%`);
+          }
+        }
+      }
+
+      expect(violations, `Locale copy threshold exceeded in ${entry.id}`).toEqual([]);
+    });
+  });
+});
+
+