meno-core 1.0.0

package/lib/shared/slugTranslator.test.ts

@@ -0,0 +1,325 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import {
+  buildSlugIndex,
+  findPageBySlug,
+  translatePath,
+  getLocaleLinks,
+  resolveSlugToPageId,
+  type SlugMap,
+} from './slugTranslator';
+import type { I18nConfig } from './types';
+
+describe('slugTranslator', () => {
+  let slugMappings: SlugMap[];
+  let slugIndex: Map<string, any>;
+
+  beforeEach(() => {
+    slugMappings = [
+      {
+        pageId: 'about',
+        slugs: {
+          en: 'about',
+          pl: 'o-nas',
+          de: 'uber',
+        },
+      },
+      {
+        pageId: 'contact',
+        slugs: {
+          en: 'contact',
+          pl: 'kontakt',
+          de: 'kontakt',
+        },
+      },
+      {
+        pageId: 'index',
+        slugs: {
+          en: '',
+          pl: '',
+          de: '',
+        },
+      },
+    ];
+
+    slugIndex = buildSlugIndex(slugMappings);
+  });
+
+  describe('buildSlugIndex', () => {
+    test('should build index with locale:slug keys', () => {
+      expect(slugIndex.has('en:about')).toBe(true);
+      expect(slugIndex.has('pl:o-nas')).toBe(true);
+      expect(slugIndex.has('de:uber')).toBe(true);
+    });
+
+    test('should store correct pageId for each slug', () => {
+      const aboutEn = slugIndex.get('en:about');
+      expect(aboutEn?.pageId).toBe('about');
+
+      const aboutPl = slugIndex.get('pl:o-nas');
+      expect(aboutPl?.pageId).toBe('about');
+    });
+
+    test('should store all slugs for each entry', () => {
+      const aboutEn = slugIndex.get('en:about');
+      expect(aboutEn?.slugs).toEqual({
+        en: 'about',
+        pl: 'o-nas',
+        de: 'uber',
+      });
+    });
+
+    test('should handle empty slugs', () => {
+      expect(slugIndex.has('en:')).toBe(true);
+      expect(slugIndex.has('pl:')).toBe(true);
+      expect(slugIndex.has('de:')).toBe(true);
+    });
+
+    test('should handle empty mappings array', () => {
+      const emptyIndex = buildSlugIndex([]);
+      expect(emptyIndex.size).toBe(0);
+    });
+
+    test('should handle multiple locales', () => {
+      const mappings: SlugMap[] = [
+        {
+          pageId: 'test',
+          slugs: {
+            en: 'test',
+            fr: 'tester',
+            es: 'prueba',
+            it: 'prova',
+          },
+        },
+      ];
+
+      const index = buildSlugIndex(mappings);
+      expect(index.has('en:test')).toBe(true);
+      expect(index.has('fr:tester')).toBe(true);
+      expect(index.has('es:prueba')).toBe(true);
+      expect(index.has('it:prova')).toBe(true);
+    });
+  });
+
+  describe('findPageBySlug', () => {
+    test('should find page by English slug', () => {
+      const result = findPageBySlug('about', 'en', slugIndex);
+      expect(result?.pageId).toBe('about');
+    });
+
+    test('should find page by Polish slug', () => {
+      const result = findPageBySlug('o-nas', 'pl', slugIndex);
+      expect(result?.pageId).toBe('about');
+    });
+
+    test('should find page by German slug', () => {
+      const result = findPageBySlug('uber', 'de', slugIndex);
+      expect(result?.pageId).toBe('about');
+    });
+
+    test('should return undefined for non-existent slug', () => {
+      const result = findPageBySlug('nonexistent', 'en', slugIndex);
+      expect(result).toBeUndefined();
+    });
+
+    test('should return undefined for wrong locale', () => {
+      const result = findPageBySlug('about', 'fr', slugIndex);
+      expect(result).toBeUndefined();
+    });
+
+    test('should find page with empty slug', () => {
+      const result = findPageBySlug('', 'en', slugIndex);
+      expect(result?.pageId).toBe('index');
+    });
+  });
+
+  describe('translatePath', () => {
+    test('should translate Polish path to English', () => {
+      const result = translatePath('/pl/o-nas', 'en', 'pl', 'en', slugIndex);
+      expect(result).toBe('/about');
+    });
+
+    test('should translate English path to Polish', () => {
+      const result = translatePath('/about', 'pl', 'en', 'en', slugIndex);
+      expect(result).toBe('/pl/o-nas');
+    });
+
+    test('should translate English path to German', () => {
+      const result = translatePath('/about', 'de', 'en', 'en', slugIndex);
+      expect(result).toBe('/de/uber');
+    });
+
+    test('should handle root path translation', () => {
+      const result = translatePath('/', 'pl', 'en', 'en', slugIndex);
+      expect(result).toBe('/pl');
+    });
+
+    test('should handle root path from non-default locale', () => {
+      const result = translatePath('/pl', 'en', 'pl', 'en', slugIndex);
+      expect(result).toBe('/');
+    });
+
+    test('should handle locale-only path', () => {
+      const result = translatePath('/pl', 'de', 'pl', 'en', slugIndex);
+      expect(result).toBe('/de');
+    });
+
+    test('should preserve slug if translation not found', () => {
+      const result = translatePath('/unknown', 'pl', 'en', 'en', slugIndex);
+      expect(result).toBe('/pl/unknown');
+    });
+
+    test('should handle path with leading slash', () => {
+      const result = translatePath('/about', 'pl', 'en', 'en', slugIndex);
+      expect(result).toBe('/pl/o-nas');
+    });
+
+    test('should handle path without leading slash', () => {
+      const result = translatePath('about', 'pl', 'en', 'en', slugIndex);
+      expect(result).toBe('/pl/o-nas');
+    });
+
+    test('should translate to default locale without prefix', () => {
+      const result = translatePath('/pl/kontakt', 'en', 'pl', 'en', slugIndex);
+      expect(result).toBe('/contact');
+    });
+
+    test('should translate from default locale to non-default', () => {
+      const result = translatePath('/contact', 'pl', 'en', 'en', slugIndex);
+      expect(result).toBe('/pl/kontakt');
+    });
+
+    test('should handle same source and target locale', () => {
+      const result = translatePath('/about', 'en', 'en', 'en', slugIndex);
+      expect(result).toBe('/about');
+    });
+
+    test('should fallback to default locale slug if target not found', () => {
+      const mappings: SlugMap[] = [
+        {
+          pageId: 'test',
+          slugs: {
+            en: 'test',
+            pl: 'test-pl',
+            // de missing
+          },
+        },
+      ];
+      const index = buildSlugIndex(mappings);
+      const result = translatePath('/test', 'de', 'en', 'en', index);
+      expect(result).toBe('/de/test'); // Falls back to English slug
+    });
+  });
+
+  describe('getLocaleLinks', () => {
+    const i18nConfig: I18nConfig = {
+      defaultLocale: 'en',
+      locales: [
+        { code: 'en', langTag: 'en-US', nativeName: 'English' },
+        { code: 'pl', langTag: 'pl-PL', nativeName: 'Polski' },
+        { code: 'de', langTag: 'de-DE', nativeName: 'Deutsch' },
+      ],
+    };
+
+    test('should generate locale links for all locales', () => {
+      const links = getLocaleLinks('/about', 'en', i18nConfig, slugIndex);
+      expect(links.length).toBe(3);
+    });
+
+    test('should include correct locale codes', () => {
+      const links = getLocaleLinks('/about', 'en', i18nConfig, slugIndex);
+      const codes = links.map(link => link.locale);
+      expect(codes).toEqual(['en', 'pl', 'de']);
+    });
+
+    test('should include correct native names', () => {
+      const links = getLocaleLinks('/about', 'en', i18nConfig, slugIndex);
+      const names = links.map(link => link.nativeName);
+      expect(names).toEqual(['English', 'Polski', 'Deutsch']);
+    });
+
+    test('should mark current locale correctly', () => {
+      const links = getLocaleLinks('/about', 'pl', i18nConfig, slugIndex);
+      const currentLink = links.find(link => link.locale === 'pl');
+      expect(currentLink?.isCurrent).toBe(true);
+
+      const otherLinks = links.filter(link => link.locale !== 'pl');
+      otherLinks.forEach(link => {
+        expect(link.isCurrent).toBe(false);
+      });
+    });
+
+    test('should translate paths correctly for each locale', () => {
+      const links = getLocaleLinks('/about', 'en', i18nConfig, slugIndex);
+
+      const enLink = links.find(link => link.locale === 'en');
+      expect(enLink?.path).toBe('/about');
+
+      const plLink = links.find(link => link.locale === 'pl');
+      expect(plLink?.path).toBe('/pl/o-nas');
+
+      const deLink = links.find(link => link.locale === 'de');
+      expect(deLink?.path).toBe('/de/uber');
+    });
+
+    test('should handle root path', () => {
+      const links = getLocaleLinks('/', 'en', i18nConfig, slugIndex);
+
+      const enLink = links.find(link => link.locale === 'en');
+      expect(enLink?.path).toBe('/');
+
+      const plLink = links.find(link => link.locale === 'pl');
+      expect(plLink?.path).toBe('/pl');
+
+      const deLink = links.find(link => link.locale === 'de');
+      expect(deLink?.path).toBe('/de');
+    });
+
+    test('should handle Polish path', () => {
+      const links = getLocaleLinks('/pl/o-nas', 'pl', i18nConfig, slugIndex);
+
+      const enLink = links.find(link => link.locale === 'en');
+      expect(enLink?.path).toBe('/about');
+
+      const plLink = links.find(link => link.locale === 'pl');
+      expect(plLink?.path).toBe('/pl/o-nas');
+    });
+  });
+
+  describe('resolveSlugToPageId', () => {
+    test('should resolve English slug to pageId', () => {
+      const result = resolveSlugToPageId('about', 'en', slugIndex);
+      expect(result).toBe('about');
+    });
+
+    test('should resolve Polish slug to pageId', () => {
+      const result = resolveSlugToPageId('o-nas', 'pl', slugIndex);
+      expect(result).toBe('about');
+    });
+
+    test('should resolve German slug to pageId', () => {
+      const result = resolveSlugToPageId('uber', 'de', slugIndex);
+      expect(result).toBe('about');
+    });
+
+    test('should return undefined for non-existent slug', () => {
+      const result = resolveSlugToPageId('nonexistent', 'en', slugIndex);
+      expect(result).toBeUndefined();
+    });
+
+    test('should return undefined for wrong locale', () => {
+      const result = resolveSlugToPageId('about', 'fr', slugIndex);
+      expect(result).toBeUndefined();
+    });
+
+    test('should resolve empty slug to index page', () => {
+      const result = resolveSlugToPageId('', 'en', slugIndex);
+      expect(result).toBe('index');
+    });
+
+    test('should resolve contact page slugs', () => {
+      expect(resolveSlugToPageId('contact', 'en', slugIndex)).toBe('contact');
+      expect(resolveSlugToPageId('kontakt', 'pl', slugIndex)).toBe('contact');
+      expect(resolveSlugToPageId('kontakt', 'de', slugIndex)).toBe('contact');
+    });
+  });
+});

package/lib/shared/slugTranslator.ts

@@ -0,0 +1,177 @@
+/**
+ * Slug Translation Service
+ * Handles translation of URL slugs between locales
+ */
+
+import type { I18nConfig } from './types';
+
+/**
+ * Slug mapping for a single page
+ */
+export interface SlugMap {
+  pageId: string;
+  slugs: Record<string, string>;
+}
+
+/**
+ * Index entry for reverse lookup (slug+locale → pageId)
+ */
+interface SlugIndexEntry {
+  pageId: string;
+  slugs: Record<string, string>;
+}
+
+/**
+ * Build reverse lookup index: "locale:slug" → SlugIndexEntry
+ * This allows quick lookup of pageId from any locale's slug
+ */
+export function buildSlugIndex(mappings: SlugMap[]): Map<string, SlugIndexEntry> {
+  const index = new Map<string, SlugIndexEntry>();
+
+  for (const mapping of mappings) {
+    for (const [locale, slug] of Object.entries(mapping.slugs)) {
+      // Key format: "locale:slug" (e.g., "pl:o-nas" or "en:about")
+      const key = `${locale}:${slug}`;
+      index.set(key, {
+        pageId: mapping.pageId,
+        slugs: mapping.slugs,
+      });
+    }
+  }
+
+  return index;
+}
+
+/**
+ * Find page by slug and locale
+ * @returns The SlugIndexEntry if found, undefined otherwise
+ */
+export function findPageBySlug(
+  slug: string,
+  locale: string,
+  index: Map<string, SlugIndexEntry>
+): SlugIndexEntry | undefined {
+  const key = `${locale}:${slug}`;
+  return index.get(key);
+}
+
+/**
+ * Translate a path to another locale
+ *
+ * @param currentPath - Current URL path (e.g., "/pl/o-nas" or "/about")
+ * @param targetLocale - Target locale (e.g., "en")
+ * @param currentLocale - Current locale (e.g., "pl")
+ * @param defaultLocale - Default locale that doesn't use prefix (e.g., "en")
+ * @param index - Slug index from buildSlugIndex()
+ * @returns Translated path (e.g., "/about" for en default, "/de/uber" for de)
+ */
+export function translatePath(
+  currentPath: string,
+  targetLocale: string,
+  currentLocale: string,
+  defaultLocale: string,
+  index: Map<string, SlugIndexEntry>
+): string {
+  // Extract slug from current path (remove locale prefix if present)
+  let slug = currentPath;
+
+  // Remove leading slash
+  if (slug.startsWith('/')) {
+    slug = slug.substring(1);
+  }
+
+  // Remove locale prefix if present (e.g., "pl/o-nas" → "o-nas")
+  // Also handle case where slug IS the locale (e.g., "pl" for Polish homepage)
+  if (currentLocale !== defaultLocale) {
+    if (slug.startsWith(`${currentLocale}/`)) {
+      slug = slug.substring(currentLocale.length + 1);
+    } else if (slug === currentLocale) {
+      // Path is just the locale prefix (e.g., "/pl" → index page)
+      slug = '';
+    }
+  }
+
+  // Handle root path
+  if (slug === '' || slug === '/') {
+    slug = '';
+  }
+
+  // Look up page by current slug and locale
+  let entry = findPageBySlug(slug, currentLocale, index);
+
+  // If not found for current locale, try default locale
+  // This handles cases like /de/about where German uses the English slug
+  if (!entry && currentLocale !== defaultLocale) {
+    entry = findPageBySlug(slug, defaultLocale, index);
+  }
+
+  if (!entry) {
+    // No translation found - return path with just locale prefix change
+    if (targetLocale === defaultLocale) {
+      return slug === '' ? '/' : `/${slug}`;
+    }
+    return slug === '' ? `/${targetLocale}` : `/${targetLocale}/${slug}`;
+  }
+
+  // Get translated slug for target locale
+  const targetSlug = entry.slugs[targetLocale] ?? entry.slugs[defaultLocale] ?? slug;
+
+  // Build target path
+  if (targetLocale === defaultLocale) {
+    return targetSlug === '' ? '/' : `/${targetSlug}`;
+  }
+  return targetSlug === '' ? `/${targetLocale}` : `/${targetLocale}/${targetSlug}`;
+}
+
+/**
+ * Locale link information for locale switcher
+ */
+export interface LocaleLink {
+  locale: string;      // Locale code (e.g., "pl")
+  langTag: string;     // BCP 47 language tag (e.g., "pl-PL")
+  nativeName: string;  // Display name in native language (e.g., "Polski")
+  path: string;        // Translated path for this locale
+  isCurrent: boolean;  // Whether this is the current locale
+}
+
+/**
+ * Get all available locales with their translated paths for the current page
+ * Useful for rendering locale switcher
+ *
+ * @param currentPath - Current URL path
+ * @param currentLocale - Current locale
+ * @param i18nConfig - i18n configuration with locales
+ * @param index - Slug index
+ * @returns Array of LocaleLink objects
+ */
+export function getLocaleLinks(
+  currentPath: string,
+  currentLocale: string,
+  i18nConfig: I18nConfig,
+  index: Map<string, SlugIndexEntry>
+): LocaleLink[] {
+  return i18nConfig.locales.map(localeConfig => ({
+    locale: localeConfig.code,
+    langTag: localeConfig.langTag,
+    nativeName: localeConfig.nativeName,
+    path: translatePath(currentPath, localeConfig.code, currentLocale, i18nConfig.defaultLocale, index),
+    isCurrent: localeConfig.code === currentLocale,
+  }));
+}
+
+/**
+ * Resolve a slug to its pageId (for server-side page loading)
+ *
+ * @param slug - URL slug (e.g., "o-nas")
+ * @param locale - Current locale (e.g., "pl")
+ * @param index - Slug index
+ * @returns pageId if found (e.g., "about"), undefined otherwise
+ */
+export function resolveSlugToPageId(
+  slug: string,
+  locale: string,
+  index: Map<string, SlugIndexEntry>
+): string | undefined {
+  const entry = findPageBySlug(slug, locale, index);
+  return entry?.pageId;
+}

package/lib/shared/styleNodeUtils.test.ts

@@ -0,0 +1,132 @@
+import { describe, test, expect } from 'bun:test';
+import { applyStylesToNode, mergeNodeStyles, extractStylesFromNode } from './styleNodeUtils';
+import type { HtmlNode, ComponentInstanceNode } from './types';
+import { NODE_TYPE } from './constants';
+
+describe('styleNodeUtils', () => {
+  describe('applyStylesToNode', () => {
+    test('should apply styles to HTML node', () => {
+      const node: HtmlNode = { type: NODE_TYPE.NODE, tag: 'div', children: [] };
+      const styles = { color: 'red', fontSize: '16px' };
+      const result = applyStylesToNode(node, styles);
+      expect(result.style).toEqual(styles);
+    });
+
+    test('should apply styles to component instance in props.style', () => {
+      const node: ComponentInstanceNode = { type: NODE_TYPE.COMPONENT, component: 'Button', props: {} };
+      const styles = { padding: '10px' };
+      const result = applyStylesToNode(node, styles);
+      expect(result.props?.style).toEqual(styles);
+    });
+
+    test('should handle null styles', () => {
+      const node: HtmlNode = { type: NODE_TYPE.NODE, tag: 'div', children: [] };
+      const result = applyStylesToNode(node, null);
+      expect(result).toEqual(node);
+    });
+
+    test('should handle undefined styles', () => {
+      const node: HtmlNode = { type: NODE_TYPE.NODE, tag: 'div', children: [] };
+      const result = applyStylesToNode(node, undefined);
+      expect(result).toEqual(node);
+    });
+
+    test('should apply styles to embed node', () => {
+      const node = { type: NODE_TYPE.EMBED, url: 'https://example.com' };
+      const styles = { width: '100%' };
+      const result = applyStylesToNode(node as any, styles);
+      expect(result.style).toEqual(styles);
+    });
+  });
+
+  describe('mergeNodeStyles', () => {
+    test('should merge styles for HTML node', () => {
+      const node: HtmlNode = {
+        type: NODE_TYPE.NODE,
+        tag: 'div',
+        children: [],
+        style: { color: 'blue' }
+      };
+      const instanceStyles = { fontSize: '16px' };
+      const result = mergeNodeStyles(node, instanceStyles);
+      expect(result.style).toEqual({ color: 'blue', fontSize: '16px' });
+    });
+
+    test('should merge styles for component instance', () => {
+      const node: ComponentInstanceNode = {
+        type: NODE_TYPE.COMPONENT,
+        component: 'Button',
+        props: { style: { color: 'blue' } }
+      };
+      const instanceStyles = { padding: '10px' };
+      const result = mergeNodeStyles(node, instanceStyles);
+      expect(result.props?.style).toEqual({ color: 'blue', padding: '10px' });
+    });
+
+    test('should override existing styles', () => {
+      const node: HtmlNode = {
+        type: NODE_TYPE.NODE,
+        tag: 'div',
+        children: [],
+        style: { color: 'blue', fontSize: '14px' }
+      };
+      const instanceStyles = { fontSize: '16px' };
+      const result = mergeNodeStyles(node, instanceStyles);
+      expect(result.style).toEqual({ color: 'blue', fontSize: '16px' });
+    });
+
+    test('should handle null instance styles', () => {
+      const node: HtmlNode = { type: NODE_TYPE.NODE, tag: 'div', children: [] };
+      const result = mergeNodeStyles(node, null);
+      expect(result).toEqual(node);
+    });
+
+    test('should create props object if not exists for component', () => {
+      const node: ComponentInstanceNode = { type: NODE_TYPE.COMPONENT, component: 'Button' };
+      const instanceStyles = { padding: '10px' };
+      const result = mergeNodeStyles(node, instanceStyles);
+      expect(result.props?.style).toEqual(instanceStyles);
+    });
+  });
+
+  describe('extractStylesFromNode', () => {
+    test('should extract styles from HTML node', () => {
+      const node: HtmlNode = {
+        type: NODE_TYPE.NODE,
+        tag: 'div',
+        children: [],
+        style: { color: 'red', fontSize: '16px' }
+      };
+      const styles = extractStylesFromNode(node);
+      expect(styles).toEqual({ color: 'red', fontSize: '16px' });
+    });
+
+    test('should extract styles from component instance', () => {
+      const node: ComponentInstanceNode = {
+        type: NODE_TYPE.COMPONENT,
+        component: 'Button',
+        props: { style: { padding: '10px' } }
+      };
+      const styles = extractStylesFromNode(node);
+      expect(styles).toEqual({ padding: '10px' });
+    });
+
+    test('should return empty object when no styles', () => {
+      const node: HtmlNode = { type: NODE_TYPE.NODE, tag: 'div', children: [] };
+      const styles = extractStylesFromNode(node);
+      expect(styles).toEqual({});
+    });
+
+    test('should handle component without props', () => {
+      const node: ComponentInstanceNode = { type: NODE_TYPE.COMPONENT, component: 'Button' };
+      const styles = extractStylesFromNode(node);
+      expect(styles).toEqual({});
+    });
+
+    test('should extract styles from embed node', () => {
+      const node = { type: NODE_TYPE.EMBED, url: 'https://example.com', style: { width: '100%' } };
+      const styles = extractStylesFromNode(node as any);
+      expect(styles).toEqual({ width: '100%' });
+    });
+  });
+});