npm - @jjlmoya/utils-aquarium - Versions diffs - 1.0.0 - Mend

@jjlmoya/utils-aquarium 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (68) hide show

package/package.json +56 -0
package/scripts/postinstall.mjs +27 -0
package/src/category/i18n/de.ts +13 -0
package/src/category/i18n/en.ts +13 -0
package/src/category/i18n/es.ts +13 -0
package/src/category/i18n/fr.ts +13 -0
package/src/category/i18n/id.ts +13 -0
package/src/category/i18n/it.ts +13 -0
package/src/category/i18n/ja.ts +13 -0
package/src/category/i18n/ko.ts +13 -0
package/src/category/i18n/nl.ts +13 -0
package/src/category/i18n/pl.ts +13 -0
package/src/category/i18n/pt.ts +13 -0
package/src/category/i18n/ru.ts +13 -0
package/src/category/i18n/sv.ts +13 -0
package/src/category/i18n/tr.ts +13 -0
package/src/category/i18n/zh.ts +13 -0
package/src/category/index.ts +24 -0
package/src/category/seo.astro +12 -0
package/src/components/PreviewNavSidebar.astro +116 -0
package/src/components/PreviewToolbar.astro +143 -0
package/src/data.ts +14 -0
package/src/entries.ts +7 -0
package/src/env.d.ts +5 -0
package/src/index.ts +20 -0
package/src/layouts/PreviewLayout.astro +117 -0
package/src/pages/[locale]/[slug].astro +65 -0
package/src/pages/[locale].astro +69 -0
package/src/pages/index.astro +4 -0
package/src/tests/diacritics_density.test.ts +118 -0
package/src/tests/faq_count.test.ts +13 -0
package/src/tests/i18n_coverage.test.ts +14 -0
package/src/tests/inverted_punctuation.test.ts +84 -0
package/src/tests/locale_completeness.test.ts +29 -0
package/src/tests/mocks/astro_mock.js +2 -0
package/src/tests/no_en_dash.test.ts +70 -0
package/src/tests/no_h1_in_components.test.ts +48 -0
package/src/tests/pagespeed_best_practices.test.ts +198 -0
package/src/tests/schemas_fulfillment.test.ts +23 -0
package/src/tests/script_density.test.ts +94 -0
package/src/tests/seo_length.test.ts +26 -0
package/src/tests/seo_parity.test.ts +60 -0
package/src/tests/seo_translation_completeness.test.ts +69 -0
package/src/tests/shared-test-helpers.ts +56 -0
package/src/tests/slug_language_code_format.test.ts +23 -0
package/src/tests/slug_uniqueness.test.ts +81 -0
package/src/tests/spanish_leakage.test.ts +175 -0
package/src/tests/title_quality.test.ts +55 -0
package/src/tests/tool_exports.test.ts +34 -0
package/src/tests/tool_validation.test.ts +11 -0
package/src/tests/translation_copy.test.ts +123 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/aquarium-tank-volume-water-change-calculator.css +391 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/bibliography.astro +6 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/bibliography.ts +14 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/component.astro +93 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/controller.ts +147 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/dom-views.ts +64 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/entry.ts +13 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/evaluator.ts +19 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/i18n/en.ts +186 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/index.ts +11 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/logic.test.ts +60 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/logic.ts +132 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/seo.astro +13 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/storage.ts +30 -0
package/src/tool/aquariumTankVolumeWaterChangeCalculator/ui.ts +41 -0
package/src/tools.ts +9 -0
package/src/types.ts +54 -0

package/src/layouts/PreviewLayout.astro ADDED Viewed

@@ -0,0 +1,117 @@
+---
+import "@jjlmoya/utils-shared/theme.css";
+import PreviewToolbar from "../components/PreviewToolbar.astro";
+import type { KnownLocale } from "../types";
+interface Props {
+  title: string;
+  currentLocale?: KnownLocale;
+  localeUrls?: Partial<Record<KnownLocale, string>>;
+  hasSidebar?: boolean;
+}
+const { title, currentLocale = "es", localeUrls = {}, hasSidebar = false } = Astro.props;
+---
+<!doctype html>
+<html lang={currentLocale}>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width" />
+    <title>{title} · preview</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800;900&display=swap"
+      rel="stylesheet"
+    />
+    <script is:inline>
+      (function () {
+        const saved = localStorage.getItem("theme") || "theme-dark";
+        document.documentElement.classList.add(saved);
+      })();
+    </script>
+    <slot name="head" />
+  </head>
+  <body>
+    <PreviewToolbar currentLocale={currentLocale} localeUrls={localeUrls} />
+    <div class:list={["page-wrapper", { "with-sidebar": hasSidebar }]}>
+      {
+        hasSidebar && (
+          <aside class="sidebar-area">
+            <slot name="sidebar" />
+          </aside>
+        )
+      }
+      <main>
+        <slot />
+      </main>
+    </div>
+  </body>
+</html>
+<style is:global>
+  :root {
+    --accent: #f43f5e;
+    --primary-base: #9f1239;
+    --cyan: #06b6d4;
+  }
+  .theme-dark,
+  .theme-light {
+    --text-main: var(--text-base);
+    --border-color: var(--border-base);
+  }
+  *,
+  *::before,
+  *::after {
+    box-sizing: border-box;
+  }
+  body {
+    background-color: var(--bg-page);
+    color: var(--text-base);
+    margin: 0;
+    min-height: 100vh;
+    transition:
+      background-color 0.3s ease,
+      color 0.3s ease;
+    font-family: Inter, sans-serif;}
+  main {
+    padding: 0 2rem;
+  }
+  .page-wrapper {
+    display: flex;
+    flex-direction: column;
+  }
+  .page-wrapper.with-sidebar {
+    display: grid;
+    grid-template-columns: 240px 1fr;
+    min-height: 100vh;
+  }
+  .sidebar-area {
+    position: sticky;
+    top: 0;
+    height: 100vh;
+    overflow-y: auto;
+    border-right: 1px solid var(--border-color);
+    background: var(--bg-page);
+  }
+  @media (max-width: 768px) {
+    .page-wrapper.with-sidebar {
+      grid-template-columns: 1fr;
+    }
+    .sidebar-area {
+      display: none;
+    }
+  }
+</style>

package/src/pages/[locale]/[slug].astro ADDED Viewed

@@ -0,0 +1,65 @@
+---
+import PreviewLayout from '../../layouts/PreviewLayout.astro';
+import PreviewNavSidebar from '../../components/PreviewNavSidebar.astro';
+import { ALL_TOOLS } from '../../index';
+import { UtilityHeader, FAQSection, Bibliography, SEORenderer } from '@jjlmoya/utils-shared';
+import type { KnownLocale, ToolLocaleContent } from '../../types';
+import type { UtilitySEOContent } from '@jjlmoya/utils-shared';
+export async function getStaticPaths() {
+  const paths = [];
+  for (const { entry, Component: lazyComponent } of ALL_TOOLS) {
+    const { default: Component } = await lazyComponent();
+    const localeContents = await Promise.all(Object.entries(entry.i18n).map(async ([locale, loader]) => ({
+      locale: locale as KnownLocale,
+      content: await loader(),
+    })));
+    const localeUrls = Object.fromEntries(localeContents.map(({ locale, content }) => [locale, '/' + locale + '/' + content.slug]));
+    for (const { locale, content } of localeContents) {
+      const allToolsNav = (await Promise.all(ALL_TOOLS.map(async ({ entry: navEntry }) => {
+        const loader = navEntry.i18n[locale] ?? navEntry.i18n.en;
+        if (loader === undefined) return null;
+        const navContent = await loader();
+        return { id: navEntry.id, title: navContent.title, href: '/' + locale + '/' + navContent.slug, isActive: navEntry.id === entry.id };
+      }))).filter((item): item is { id: string; title: string; href: string; isActive: boolean } => item !== null);
+      const englishLoader = entry.i18n.en ?? Object.values(entry.i18n)[0];
+      const englishSlug = englishLoader === undefined ? entry.id : (await englishLoader()).slug;
+      paths.push({ params: { locale, slug: content.slug }, props: { Component, locale, content, localeUrls, allToolsNav, englishSlug } });
+    }
+  }
+  return paths;
+}
+const { Component, locale, content, localeUrls, allToolsNav, englishSlug } = Astro.props as {
+  Component: (_props: Record<string, unknown>) => unknown;
+  locale: KnownLocale;
+  content: ToolLocaleContent;
+  localeUrls: Partial<Record<KnownLocale, string>>;
+  allToolsNav: { id: string; title: string; href: string; isActive?: boolean }[];
+  englishSlug: string;
+};
+const cssFiles = import.meta.glob('../../tool/**' + '/' + '*.css', { query: '?raw', import: 'default' });
+const cssKey = Object.keys(cssFiles).find((key) => key.endsWith('/' + englishSlug + '.css'));
+const cssLoader = cssKey === undefined ? undefined : cssFiles[cssKey];
+const toolCss = cssLoader === undefined ? '' : await cssLoader() as string;
+const seoContent: UtilitySEOContent = { locale, sections: content.seo };
+const words = content.title.split(' ');
+const titleHighlight = words[0] ?? '';
+const titleBase = words.slice(1).join(' ');
+---
+<PreviewLayout title={content.title} currentLocale={locale} localeUrls={localeUrls} hasSidebar={true}>
+  <PreviewNavSidebar slot="sidebar" categoryTitle="Aquarium tools" tools={allToolsNav} />
+  <Fragment slot="head">
+    {toolCss !== '' && <Fragment set:html={'<style is:inline>' + toolCss + '</style>'} />}
+    {content.schemas.map((schema: unknown) => <script is:inline type="application/ld+json" set:html={JSON.stringify(schema)} />)}
+  </Fragment>
+  <div class="tool-page">
+    <UtilityHeader titleHighlight={titleHighlight} titleBase={titleBase} description={content.description} />
+    <section class="section-tool"><Component ui={content.ui} /></section>
+    <section class="section-seo"><SEORenderer content={seoContent} /></section>
+    <section class="section-faq"><FAQSection items={content.faq} /></section>
+    <section class="section-bibliography"><Bibliography links={content.bibliography} /></section>
+  </div>
+</PreviewLayout>

package/src/pages/[locale].astro ADDED Viewed

@@ -0,0 +1,69 @@
+---
+import PreviewLayout from '../layouts/PreviewLayout.astro';
+import PreviewNavSidebar from '../components/PreviewNavSidebar.astro';
+import { aquariumCategory, ALL_TOOLS } from '../index';
+import { Icon } from 'astro-icon/components';
+import type { KnownLocale, ToolLocaleContent } from '../types';
+export async function getStaticPaths() {
+  const locales = ['en'] as KnownLocale[];
+  return locales.map((locale) => ({ params: { locale } }));
+}
+const currentLocale = (Astro.params.locale ?? 'en') as KnownLocale;
+const categoryLoader = aquariumCategory.i18n[currentLocale] ?? aquariumCategory.i18n.en;
+const categoryContent = categoryLoader === undefined ? {
+  slug: 'aquarium',
+  title: 'Aquarium Tools',
+  description: 'Aquarium volume tools',
+  seo: [],
+} : await categoryLoader();
+const toolsWithContent = await Promise.all(
+  ALL_TOOLS.map(async ({ entry, Component }) => {
+    const localeEntries = await Promise.all(
+      Object.entries(entry.i18n).map(async ([locale, loader]) => [locale, await loader()] as const),
+    );
+    const localeContents = Object.fromEntries(localeEntries) as Record<string, ToolLocaleContent>;
+    const locale = localeContents[currentLocale] ?? localeContents.en;
+    const availableLocales: Record<string, string> = {};
+    for (const [localeCode, content] of Object.entries(localeContents)) {
+      availableLocales[localeCode] = '/' + localeCode + '/' + content.slug;
+    }
+    return { entry, Component, locale, availableLocales };
+  }),
+);
+---
+<PreviewLayout title={categoryContent.title} currentLocale={currentLocale} hasSidebar={true}>
+  <PreviewNavSidebar
+    slot="sidebar"
+    categoryTitle={categoryContent.title}
+    tools={toolsWithContent.map(({ entry, locale, availableLocales }) => ({
+      id: entry.id,
+      title: locale?.title ?? entry.id,
+      href: availableLocales[currentLocale] ?? '#',
+    }))}
+  />
+  <div class="dashboard">
+    <header class="preview-header">
+      <span class="badge">preview · @jjlmoya/utils-aquarium</span>
+      <h1>{categoryContent.title}</h1>
+      <p>{categoryContent.description}</p>
+    </header>
+    <div class="tool-list">
+      {toolsWithContent.map(({ entry, locale, availableLocales }) => (
+        <article class="tool-card">
+          <a href={availableLocales[currentLocale] ?? '#'} class="tool-card-link">
+            <div class="tool-icons"><div class="icon-wrapper bg"><Icon name={entry.icons.bg} /></div><div class="icon-wrapper fg"><Icon name={entry.icons.fg} /></div></div>
+            <div class="tool-card-content"><h2 class="tool-title">{locale?.title}</h2><p class="tool-description">{locale?.description}</p></div>
+            <div class="tool-card-meta"><span class="tool-id">{entry.id}</span></div>
+          </a>
+          <div class="tool-locales">
+            {Object.entries(availableLocales).map(([localeCode, url]) => <a href={url} class:list={{ active: localeCode === currentLocale }} class="locale-badge">{localeCode.toUpperCase()}</a>)}
+          </div>
+        </article>
+      ))}
+    </div>
+  </div>
+</PreviewLayout>

package/src/pages/index.astro ADDED Viewed

@@ -0,0 +1,4 @@
+---
+---
+<meta http-equiv="refresh" content="0;url=/es" />

package/src/tests/diacritics_density.test.ts ADDED Viewed

@@ -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 unknown 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/faq_count.test.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+describe('FAQ Content Validation', () => {
+  ALL_TOOLS.forEach(({ entry }) => {
+    it(entry.id + ' has enough FAQ coverage', async () => {
+      const loader = entry.i18n.en;
+      if (loader === undefined) return;
+      const content = await loader();
+      expect(content.faq.length).toBeGreaterThanOrEqual(3);
+    });
+  });
+});

package/src/tests/i18n_coverage.test.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+const EXPECTED_LOCALES = ['en'];
+describe('I18n Coverage Validation', () => {
+  ALL_TOOLS.forEach(({ entry }) => {
+    describe('Tool: ' + entry.id, () => {
+      it('has the current phase locale set', () => {
+        expect(Object.keys(entry.i18n)).toEqual(EXPECTED_LOCALES);
+      });
+    });
+  });
+});

package/src/tests/inverted_punctuation.test.ts ADDED Viewed

@@ -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 unknown 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 ADDED Viewed

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+describe('Locale Completeness and Slug Validation', () => {
+  it('all tools registered in ALL_TOOLS', () => {
+    expect(ALL_TOOLS.length).toBeGreaterThan(0);
+  });
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool entry: ${tool.entry.id}`, () => {
+      it('every registered locale content must have a valid non-empty slug', async () => {
+        const locales = Object.keys(tool.entry.i18n);
+        expect(locales.length).toBeGreaterThan(0);
+        for (const locale of locales) {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          expect(loader).toBeDefined();
+          const content = (await loader?.()) as ToolLocaleContent;
+          expect(content, `Locale "${locale}" for tool "${tool.entry.id}" failed to load content object`).toBeDefined();
+          expect(content.slug, `Locale "${locale}" for tool "${tool.entry.id}" has undefined or empty slug`).toBeDefined();
+          expect(typeof content.slug).toBe('string');
+          expect(content.slug.length).toBeGreaterThan(0);
+          expect(content.title, `Locale "${locale}" for tool "${tool.entry.id}" has undefined title`).toBeDefined();
+        }
+      });
+    });
+  });
+});

package/src/tests/mocks/astro_mock.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export default function () { return null; }
2	+

package/src/tests/no_en_dash.test.ts ADDED Viewed

@@ -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/no_h1_in_components.test.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+const EXCLUDED_DIRS = ['node_modules', 'pages', 'layouts'];
+function findAstroFiles(dir: string): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory() && !EXCLUDED_DIRS.includes(entry.name)) {
+      files.push(...findAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.astro')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function hasH1(content: string): boolean {
+  return /<h1[\s>]/i.test(content);
+}
+const srcDir = join(process.cwd(), 'src');
+const astroFiles = findAstroFiles(srcDir);
+describe('No H1 in Components', () => {
+  if (astroFiles.length === 0) {
+    it('no astro components found', () => {
+      expect(true).toBe(true);
+    });
+  }
+  astroFiles.forEach((file) => {
+    const relativePath = file.replace(process.cwd(), '');
+    it(`${relativePath} should not contain <h1>`, () => {
+      const content = readFileSync(file, 'utf-8');
+      expect(
+        hasH1(content),
+        `File "${relativePath}" contains a <h1> element. Use <h2> or lower inside components — h1 belongs to the page layout.`,
+      ).toBe(false);
+    });
+  });
+});