@hagicode/hagilight-core 0.1.0

package/dist/links.js

@@ -0,0 +1,406 @@
+import docsRelatedSites from './related-sites.json' with { type: 'json' };
+const translations = {
+    home: {
+        'zh-CN': '首页', 'zh-Hant': '首頁', 'en-US': 'Home', 'ja-JP': 'ホーム',
+        'ko-KR': '홈', 'de-DE': 'Startseite', 'fr-FR': 'Accueil', 'es-ES': 'Inicio',
+        'pt-BR': 'Início', 'ru-RU': 'Главная',
+    },
+    blog: {
+        'zh-CN': '博客', 'zh-Hant': '部落格', 'en-US': 'Blog', 'ja-JP': 'ブログ',
+        'ko-KR': '블로그', 'de-DE': 'Blog', 'fr-FR': 'Blog', 'es-ES': 'Blog',
+        'pt-BR': 'Blog', 'ru-RU': 'Блог',
+    },
+    support: {
+        'zh-CN': '获取技术支持', 'zh-Hant': '獲取技術支援', 'en-US': 'Get Support',
+        'ja-JP': 'サポート', 'ko-KR': '기술 지원', 'de-DE': 'Support',
+        'fr-FR': 'Assistance', 'es-ES': 'Soporte', 'pt-BR': 'Suporte', 'ru-RU': 'Поддержка',
+    },
+    downloadClient: {
+        'zh-CN': '下载 Hagicode', 'zh-Hant': '下載 Hagicode', 'en-US': 'Download Hagicode',
+        'ja-JP': 'Hagicode をダウンロード', 'ko-KR': 'Hagicode 다운로드',
+        'de-DE': 'Hagicode herunterladen', 'fr-FR': 'Télécharger Hagicode',
+        'es-ES': 'Descargar Hagicode', 'pt-BR': 'Baixar Hagicode', 'ru-RU': 'Скачать Hagicode',
+    },
+    about: {
+        'zh-CN': '关于 HagiCode', 'zh-Hant': '關於 HagiCode', 'en-US': 'About HagiCode',
+        'ja-JP': 'HagiCode について', 'ko-KR': 'HagiCode 소개', 'de-DE': 'Über HagiCode',
+        'fr-FR': 'À propos de HagiCode', 'es-ES': 'Acerca de HagiCode',
+        'pt-BR': 'Sobre a HagiCode', 'ru-RU': 'О HagiCode',
+    },
+    dockerCompose: {
+        'zh-CN': 'Docker Compose 安装', 'zh-Hant': 'Docker Compose 安裝',
+        'en-US': 'Docker Compose Installation', 'ja-JP': 'Docker Compose インストール',
+        'ko-KR': 'Docker Compose 설치', 'de-DE': 'Docker-Compose-Installation',
+        'fr-FR': 'Installation de Docker Compose', 'es-ES': 'Instalación de Docker Compose',
+        'pt-BR': 'Instalação do Docker Compose', 'ru-RU': 'Установка Docker Compose',
+    },
+    productDocs: {
+        'zh-CN': '产品文档', 'zh-Hant': '產品文件', 'en-US': 'Product Docs',
+        'ja-JP': '製品ドキュメント', 'ko-KR': '제품 문서', 'de-DE': 'Produktdokumentation',
+        'fr-FR': 'Documentation produit', 'es-ES': 'Documentación del producto',
+        'pt-BR': 'Documentação do produto', 'ru-RU': 'Документация продукта',
+    },
+    blogPosts: {
+        'zh-CN': '博客文章', 'zh-Hant': '部落格文章', 'en-US': 'Blog Posts',
+        'ja-JP': 'ブログ記事', 'ko-KR': '블로그 글', 'de-DE': 'Blogbeiträge',
+        'fr-FR': 'Articles du blog', 'es-ES': 'Artículos del blog',
+        'pt-BR': 'Posts do blog', 'ru-RU': 'Статьи блога',
+    },
+    sitemap: {
+        'zh-CN': '站点地图', 'zh-Hant': '網站地圖', 'en-US': 'Sitemap',
+        'ja-JP': 'サイトマップ', 'ko-KR': '사이트맵', 'de-DE': 'Sitemap',
+        'fr-FR': 'Plan du site', 'es-ES': 'Mapa del sitio',
+        'pt-BR': 'Mapa do site', 'ru-RU': 'Карта сайта',
+    },
+    rss: {
+        'zh-CN': 'RSS 订阅', 'zh-Hant': 'RSS 訂閱', 'en-US': 'RSS Feed',
+        'ja-JP': 'RSS 配信', 'ko-KR': 'RSS 구독', 'de-DE': 'RSS-Feed',
+        'fr-FR': 'Flux RSS', 'es-ES': 'RSS', 'pt-BR': 'Feed RSS', 'ru-RU': 'RSS-лента',
+    },
+    rssLocale: {
+        'zh-CN': '当前语言 RSS', 'zh-Hant': '目前語言 RSS', 'en-US': 'Current language RSS',
+        'ja-JP': '現在の言語 RSS', 'ko-KR': '현재 언어 RSS', 'de-DE': 'RSS der aktuellen Sprache',
+        'fr-FR': 'Flux RSS de la langue actuelle', 'es-ES': 'RSS del idioma actual',
+        'pt-BR': 'Feed RSS do idioma atual', 'ru-RU': 'RSS для текущего языка',
+    },
+    costCalculator: {
+        'zh-CN': '算一算，AI会不会淘汰我', 'zh-Hant': '算一算，AI 會不會淘汰我',
+        'en-US': 'Will AI Replace Me?', 'ja-JP': 'AI に置き換えられるか診断',
+        'ko-KR': 'AI가 나를 대체할까?', 'de-DE': 'Wird KI mich ersetzen?',
+        'fr-FR': "L'IA va-t-elle me remplacer ?", 'es-ES': 'Me reemplazará la IA?',
+        'pt-BR': 'A IA vai me substituir?', 'ru-RU': 'Заменит ли меня ИИ?',
+    },
+    github: {
+        'zh-CN': 'GitHub', 'zh-Hant': 'GitHub', 'en-US': 'GitHub', 'ja-JP': 'GitHub',
+        'ko-KR': 'GitHub', 'de-DE': 'GitHub', 'fr-FR': 'GitHub', 'es-ES': 'GitHub',
+        'pt-BR': 'GitHub', 'ru-RU': 'GitHub',
+    },
+    discord: {
+        'zh-CN': 'Discord', 'zh-Hant': 'Discord', 'en-US': 'Discord', 'ja-JP': 'Discord',
+        'ko-KR': 'Discord', 'de-DE': 'Discord', 'fr-FR': 'Discord', 'es-ES': 'Discord',
+        'pt-BR': 'Discord', 'ru-RU': 'Discord',
+    },
+    issueFeedback: {
+        'zh-CN': '问题反馈', 'zh-Hant': '問題回饋', 'en-US': 'Issue Feedback',
+        'ja-JP': '問題の報告', 'ko-KR': '문제 신고', 'de-DE': 'Probleme melden',
+        'fr-FR': 'Signaler un problème', 'es-ES': 'Reportar un problema',
+        'pt-BR': 'Relatar problema', 'ru-RU': 'Сообщить о проблеме',
+    },
+    contactEmail: {
+        'zh-CN': '联系邮箱', 'zh-Hant': '聯絡信箱', 'en-US': 'Contact Email',
+        'ja-JP': '連絡先メール', 'ko-KR': '문의 이메일', 'de-DE': 'Kontakt-E-Mail',
+        'fr-FR': 'E-mail de contact', 'es-ES': 'Correo de contacto',
+        'pt-BR': 'E-mail de contato', 'ru-RU': 'Контактный email',
+    },
+    qqGroup: {
+        'zh-CN': 'QQ 群 610394020', 'zh-Hant': 'QQ 群 610394020',
+        'en-US': 'QQ Group 610394020', 'ja-JP': 'QQ グループ 610394020',
+        'ko-KR': 'QQ 그룹 610394020', 'de-DE': 'QQ-Gruppe 610394020',
+        'fr-FR': 'Groupe QQ 610394020', 'es-ES': 'Grupo QQ 610394020',
+        'pt-BR': 'Grupo QQ 610394020', 'ru-RU': 'Группа QQ 610394020',
+    },
+    microsoftStore: {
+        'zh-CN': '下载 Hagicode Windows 版本', 'zh-Hant': '下載 Hagicode Windows 版本',
+        'en-US': 'Download Hagicode for Windows', 'ja-JP': 'Hagicode for Windows をダウンロード',
+        'ko-KR': 'Windows용 Hagicode 다운로드', 'de-DE': 'Hagicode für Windows herunterladen',
+        'fr-FR': 'Télécharger Hagicode pour Windows', 'es-ES': 'Descargar Hagicode para Windows',
+        'pt-BR': 'Baixar Hagicode para Windows', 'ru-RU': 'Скачать Hagicode для Windows',
+    },
+    icpFiling: {
+        'zh-CN': '闽ICP备2026004153号-1',
+        'zh-Hant': '闽ICP备2026004153号-1',
+        'en-US': 'ICP Filing 闽ICP备2026004153号-1',
+        'ja-JP': 'ICP届出 闽ICP备2026004153号-1',
+        'ko-KR': 'ICP 신고 闽ICP备2026004153号-1',
+        'de-DE': 'ICP-Registrierung 闽ICP备2026004153号-1',
+        'fr-FR': 'Dépôt ICP 闽ICP备2026004153号-1',
+        'es-ES': 'Registro ICP 闽ICP备2026004153号-1',
+        'pt-BR': 'Registro ICP 闽ICP备2026004153号-1',
+        'ru-RU': 'ICP регистрация 闽ICP备2026004153号-1',
+    },
+    publicSecurityFiling: {
+        'zh-CN': '闽公网安备35011102351148号',
+        'zh-Hant': '闽公网安备35011102351148号',
+        'en-US': 'Public Security Filing 闽公网安备35011102351148号',
+        'ja-JP': '公安届出 闽公网安备35011102351148号',
+        'ko-KR': '공안 신고 闽公网安备35011102351148号',
+        'de-DE': 'Sicherheitsregistrierung 闽公网安备35011102351148号',
+        'fr-FR': 'Dépôt de sécurité publique 闽公网安备35011102351148号',
+        'es-ES': 'Registro de seguridad pública 闽公网安备35011102351148号',
+        'pt-BR': 'Registro de segurança pública 闽公网安备35011102351148号',
+        'ru-RU': 'Регистрация в органах общественной безопасности 闽公网安备35011102351148号',
+    },
+};
+const defaultLinks = {
+    home: { label: translations.home, href: (locale) => marketingPath(locale, '/') },
+    blog: { label: translations.blog, href: (locale) => docsPath(locale, '/blog/') },
+    support: { label: translations.support, href: (locale) => marketingPath(locale, '/about/') },
+    downloadClient: { label: translations.downloadClient, href: (locale) => marketingPath(locale, '/desktop/') },
+    about: { label: translations.about, href: (locale) => marketingPath(locale, '/about/') },
+    dockerCompose: { label: translations.dockerCompose, href: (locale) => docsPath(locale, '/installation/docker-compose/') },
+    productDocs: { label: translations.productDocs, href: (locale) => docsPath(locale, '/product-overview/') },
+    blogPosts: { label: translations.blogPosts, href: (locale) => docsPath(locale, '/blog/') },
+    sitemap: { label: translations.sitemap, href: '/sitemap-index.xml' },
+    rss: { label: translations.rss, href: '' },
+    rssLocale: { label: translations.rssLocale, href: '' },
+    costCalculator: { label: translations.costCalculator, href: 'https://cost.hagicode.com', external: true },
+    github: { label: translations.github, href: 'https://github.com/HagiCode-org/site', external: true },
+    discord: { label: translations.discord, href: 'https://discord.gg/qY662sJK', external: true },
+    issueFeedback: { label: translations.issueFeedback, href: 'https://github.com/HagiCode-org/site/issues', external: true },
+    contactEmail: { label: translations.contactEmail, href: 'mailto:support@hagicode.com' },
+    qqGroup: { label: translations.qqGroup, href: 'https://qm.qq.com/q/Fwb0o094kw', external: true },
+    microsoftStore: {
+        label: translations.microsoftStore,
+        href: 'https://apps.microsoft.com/detail/9N3PM0N3SVDW',
+        external: true,
+    },
+    icpFiling: {
+        label: translations.icpFiling,
+        href: 'https://beian.miit.gov.cn/',
+        external: true,
+        ariaLabel: {
+            'zh-CN': '查看 ICP 备案信息', 'zh-Hant': '查看 ICP 備案資訊',
+            'en-US': 'View ICP filing information', 'ja-JP': 'ICP 登録情報を表示',
+            'ko-KR': 'ICP 등록 정보 보기', 'de-DE': 'ICP-Registrierungsinformationen anzeigen',
+            'fr-FR': 'Voir les informations de dépôt ICP', 'es-ES': 'Ver la información de registro ICP',
+            'pt-BR': 'Ver informações de registro ICP', 'ru-RU': 'Показать информацию о регистрации ICP',
+        },
+    },
+    publicSecurityFiling: {
+        label: translations.publicSecurityFiling,
+        href: 'http://www.beian.gov.cn/portal/registerSystemInfo',
+        external: true,
+        ariaLabel: {
+            'zh-CN': '查看公安备案信息', 'zh-Hant': '查看公安備案資訊',
+            'en-US': 'View public security filing information', 'ja-JP': '公安登録情報を表示',
+            'ko-KR': '공안 등록 정보 보기', 'de-DE': 'Informationen zur Sicherheitsregistrierung anzeigen',
+            'fr-FR': 'Voir les informations de dépôt de sécurité publique',
+            'es-ES': 'Ver la información de registro de seguridad pública',
+            'pt-BR': 'Ver informações de registro de segurança pública',
+            'ru-RU': 'Показать информацию о регистрации в органах общественной безопасности',
+        },
+    },
+};
+const groups = {
+    header: ['home', 'blog', 'support'],
+    quick: [
+        'downloadClient', 'microsoftStore', 'dockerCompose', 'productDocs', 'blogPosts',
+        'rss', 'rssLocale', 'sitemap', 'about',
+    ],
+    community: ['github', 'discord', 'issueFeedback', 'contactEmail', 'qqGroup'],
+    filings: ['icpFiling', 'publicSecurityFiling'],
+};
+function normalizeLocale(locale) {
+    const normalized = locale?.trim().replaceAll('_', '-').toLowerCase();
+    if (normalized === 'zh' || normalized === 'zh-cn' || normalized === 'zh-hans' || normalized === 'root') {
+        return 'zh-CN';
+    }
+    if (normalized === 'zh-hant' || normalized === 'zh-tw' || normalized === 'zh-hk') {
+        return 'zh-Hant';
+    }
+    if (normalized === 'en' || normalized === 'en-us' || !normalized) {
+        return 'en-US';
+    }
+    const canonical = ['ja-JP', 'ko-KR', 'de-DE', 'fr-FR', 'es-ES', 'pt-BR', 'ru-RU']
+        .find((candidate) => candidate.toLowerCase() === normalized);
+    if (canonical)
+        return canonical;
+    return 'en-US';
+}
+function docsPath(locale, pathname) {
+    const routePrefix = locale === 'zh-CN' ? '' : `/${locale}`;
+    return `https://docs.hagicode.com${routePrefix}${pathname}`;
+}
+function marketingPath(locale, pathname) {
+    return `https://www.hagicode.com/${locale}${pathname}`;
+}
+function resolveLocalized(value, locale, fallback) {
+    if (typeof value === 'string')
+        return value;
+    for (const candidate of [locale, ...(locale === 'zh-Hant' ? ['zh-CN', 'en-US'] : ['en-US'])]) {
+        const text = value[candidate];
+        if (typeof text === 'string' && text.trim())
+            return text;
+    }
+    const firstValue = Object.values(value).find((text) => typeof text === 'string' && text.trim());
+    return firstValue ?? fallback;
+}
+function normalizeUrl(value) {
+    const input = value.trim();
+    if (!input)
+        throw new TypeError('Link destinations must not be empty.');
+    const url = new URL(input, 'https://hagilight.invalid');
+    if (!['http:', 'https:', 'mailto:', 'tel:'].includes(url.protocol)) {
+        throw new TypeError(`Unsupported link protocol: ${url.protocol}`);
+    }
+    url.hash = '';
+    url.search = '';
+    url.pathname = url.pathname.replace(/\/+$/u, '') || '/';
+    return url.origin === 'https://hagilight.invalid' ? url.pathname : url.toString();
+}
+function resolveLink(key, locale, definition, override) {
+    const defaultHref = typeof definition.href === 'function' ? definition.href(locale) : definition.href;
+    const href = override?.href === undefined ? defaultHref : resolveLocalized(override.href, locale, defaultHref);
+    const label = override?.label === undefined
+        ? resolveLocalized(definition.label, locale, key)
+        : resolveLocalized(override.label, locale, resolveLocalized(definition.label, locale, key));
+    normalizeUrl(href);
+    const external = override?.external ?? definition.external ?? false;
+    return {
+        id: key,
+        label,
+        href,
+        ...(definition.ariaLabel
+            ? { ariaLabel: resolveLocalized(definition.ariaLabel, locale, label) }
+            : {}),
+        ...(external ? { target: '_blank', rel: 'noopener noreferrer' } : {}),
+    };
+}
+export function resolveSiteLinks(localeInput, options = {}) {
+    const locale = normalizeLocale(localeInput);
+    if (options.rssFeedUrl !== undefined && typeof options.rssFeedUrl !== 'string') {
+        throw new TypeError('RSS feed URL must be a string.');
+    }
+    const resolvedGroups = Object.fromEntries(Object.keys(groups).map((group) => {
+        const catalogLinks = groups[group].map((key) => {
+            if (key === 'rss' && options.rssFeedUrl === undefined
+                && options.overrides?.rss?.href === undefined) {
+                return undefined;
+            }
+            if (key === 'rssLocale' && options.rssLocaleFeedUrl === undefined) {
+                return undefined;
+            }
+            if ((group === 'quick' || group === 'community')
+                && (options.removeLinks?.[group]?.includes(key)
+                    || key === 'rssLocale' && options.removeLinks?.quick?.includes('rss'))) {
+                return undefined;
+            }
+            const override = options.overrides?.[key]
+                ?? (key === 'blogPosts' ? options.overrides?.blog : undefined);
+            const definition = key === 'rss'
+                ? { ...defaultLinks[key], href: options.rssFeedUrl ?? '' }
+                : key === 'rssLocale'
+                    ? { ...defaultLinks[key], href: options.rssLocaleFeedUrl ?? '' }
+                    : defaultLinks[key];
+            return resolveLink(key, locale, definition, override);
+        });
+        const extraLinks = (options.extraLinks?.[group] ?? []).map((entry, index) => {
+            const definition = {
+                label: entry.label,
+                href: resolveLocalized(entry.href, locale, ''),
+                external: entry.external,
+            };
+            const id = entry.id ?? `${group}-custom-${index + 1}`;
+            if (typeof id !== 'string' || !id.trim()) {
+                throw new TypeError('Extra link IDs must be non-empty strings.');
+            }
+            return resolveLink(id, locale, definition);
+        });
+        const links = [...catalogLinks, ...extraLinks].filter((link) => link !== undefined);
+        if (group !== 'quick' && group !== 'community')
+            return [group, links];
+        const ids = new Set();
+        const urls = new Set();
+        const uniqueLinks = links.filter((link) => {
+            const url = normalizeUrl(link.href);
+            if (ids.has(link.id) || urls.has(url))
+                return false;
+            ids.add(link.id);
+            urls.add(url);
+            return true;
+        });
+        return [group, uniqueLinks];
+    }));
+    const renderedUrls = new Set([...resolvedGroups.quick, ...resolvedGroups.community, ...resolvedGroups.filings]
+        .map((link) => normalizeUrl(link.href)));
+    if (options.siteUrl)
+        renderedUrls.add(normalizeUrl(options.siteUrl));
+    const relatedIds = new Set();
+    const relatedUrls = new Set();
+    const bundledOrReplacementSites = (options.relatedSites ?? docsRelatedSites)
+        .filter((site) => !options.removeLinks?.relatedSites?.includes(site.id));
+    const relatedSites = [...bundledOrReplacementSites, ...(options.extraLinks?.relatedSites ?? [])]
+        .flatMap((site) => {
+        if (typeof site.id !== 'string' || !site.id.trim()) {
+            throw new TypeError('Related site IDs must be non-empty strings.');
+        }
+        const href = site.supportsLocalePath
+            ? new URL(`${locale}/`, site.url.endsWith('/') ? site.url : `${site.url}/`).toString()
+            : site.url;
+        const normalizedUrl = normalizeUrl(href);
+        if (site.id === options.siteId || renderedUrls.has(normalizedUrl)
+            || relatedIds.has(site.id) || relatedUrls.has(normalizedUrl)) {
+            return [];
+        }
+        relatedIds.add(site.id);
+        relatedUrls.add(normalizedUrl);
+        return [{
+                id: site.id,
+                name: resolveLocalized(site.name, locale, site.id),
+                description: site.description
+                    ? resolveLocalized(site.description, locale, '')
+                    : undefined,
+                href,
+                target: '_blank',
+                rel: 'noopener noreferrer',
+            }];
+    });
+    return {
+        locale,
+        labels: {
+            relatedSites: resolveLocalized({
+                'zh-CN': '生态站点', 'zh-Hant': '生態站點', 'en-US': 'Ecosystem Sites',
+                'ja-JP': 'エコシステムサイト', 'ko-KR': '에코시스템 사이트',
+                'de-DE': 'Ökosystem-Seiten', 'fr-FR': "Sites de l'écosystème",
+                'es-ES': 'Sitios del ecosistema', 'pt-BR': 'Sites do ecossistema',
+                'ru-RU': 'Сайты экосистемы',
+            }, locale, 'Ecosystem Sites'),
+            quickLinks: resolveLocalized({
+                'zh-CN': '快速链接', 'zh-Hant': '快速連結', 'en-US': 'Quick Links',
+                'ja-JP': 'クイックリンク', 'ko-KR': '빠른 링크', 'de-DE': 'Schnellzugriffe',
+                'fr-FR': 'Liens rapides', 'es-ES': 'Enlaces rápidos',
+                'pt-BR': 'Links rápidos', 'ru-RU': 'Быстрые ссылки',
+            }, locale, 'Quick Links'),
+            community: resolveLocalized({
+                'zh-CN': '社区', 'zh-Hant': '社群', 'en-US': 'Community',
+                'ja-JP': 'コミュニティ', 'ko-KR': '커뮤니티', 'de-DE': 'Community',
+                'fr-FR': 'Communauté', 'es-ES': 'Comunidad',
+                'pt-BR': 'Comunidade', 'ru-RU': 'Сообщество',
+            }, locale, 'Community'),
+            navigation: {
+                relatedSites: resolveLocalized({
+                    'zh-CN': '生态站点链接', 'zh-Hant': '生態站點連結', 'en-US': 'Ecosystem site links',
+                    'ja-JP': 'エコシステムサイトへのリンク', 'ko-KR': '에코시스템 사이트 링크',
+                    'de-DE': 'Links zu Ökosystem-Seiten', 'fr-FR': "Liens vers les sites de l'écosystème",
+                    'es-ES': 'Enlaces de sitios del ecosistema', 'pt-BR': 'Links dos sites do ecossistema',
+                    'ru-RU': 'Ссылки на сайты экосистемы',
+                }, locale, 'Ecosystem site links'),
+                quickLinks: resolveLocalized({
+                    'zh-CN': '快速链接', 'zh-Hant': '快速連結', 'en-US': 'Quick links',
+                    'ja-JP': 'クイックリンク', 'ko-KR': '빠른 링크', 'de-DE': 'Schnellzugriffe',
+                    'fr-FR': 'Liens rapides', 'es-ES': 'Enlaces rápidos',
+                    'pt-BR': 'Links rápidos', 'ru-RU': 'Быстрые ссылки',
+                }, locale, 'Quick links'),
+                community: resolveLocalized({
+                    'zh-CN': '社区链接', 'zh-Hant': '社群連結', 'en-US': 'Community links',
+                    'ja-JP': 'コミュニティリンク', 'ko-KR': '커뮤니티 링크',
+                    'de-DE': 'Community-Links', 'fr-FR': 'Liens communautaires',
+                    'es-ES': 'Enlaces de la comunidad', 'pt-BR': 'Links da comunidade',
+                    'ru-RU': 'Ссылки сообщества',
+                }, locale, 'Community links'),
+                filings: resolveLocalized({
+                    'zh-CN': '查看备案信息', 'zh-Hant': '查看備案資訊',
+                    'en-US': 'View filing information', 'ja-JP': '登録情報を表示',
+                    'ko-KR': '등록 정보 보기', 'de-DE': 'Registrierungsinformationen anzeigen',
+                    'fr-FR': 'Voir les informations de dépôt', 'es-ES': 'Ver información de registro',
+                    'pt-BR': 'Ver informações de registro', 'ru-RU': 'Показать информацию о регистрации',
+                }, locale, 'View filing information'),
+            },
+        },
+        header: resolvedGroups.header,
+        quick: resolvedGroups.quick,
+        community: resolvedGroups.community,
+        filings: resolvedGroups.filings,
+        relatedSites,
+    };
+}

package/dist/promotions.d.ts

@@ -0,0 +1,44 @@
+type FetchLike = typeof fetch;
+export interface PromotionImage {
+    src: string;
+    alt: string;
+    variant?: string;
+    width?: number;
+    height?: number;
+}
+export interface PromotionCard {
+    id: string;
+    title: string;
+    description: string;
+    ctaLabel: string;
+    link: string;
+    image?: PromotionImage;
+}
+interface PromotionFlag {
+    id: string;
+    on: boolean;
+    startTime?: string;
+    endTime?: string;
+}
+interface PromotionContent {
+    id: string;
+    title: Record<string, string>;
+    description: Record<string, string>;
+    cta?: Record<string, string>;
+    link: string;
+    image?: PromotionImage;
+}
+export declare function parsePromotionFlags(payload: unknown): PromotionFlag[];
+export declare function parsePromotionContent(payload: unknown): PromotionContent[];
+export declare function normalizeActivePromotions(flags: PromotionFlag[], content: PromotionContent[], locale?: string | null, now?: number): PromotionCard[];
+export declare function resolvePromotionDocumentUrls(fetchImpl?: FetchLike): Promise<{
+    flagsUrl: string;
+    contentUrl: string;
+    source: 'catalog' | 'fallback';
+}>;
+export declare function loadActivePromotions(options?: {
+    locale?: string | null;
+    fetchImpl?: FetchLike;
+    now?: number;
+}): Promise<PromotionCard[]>;
+export {};

package/dist/promotions.js

@@ -0,0 +1,216 @@
+const INDEX_ORIGIN = 'https://index.hagicode.com';
+const CATALOG_URL = `${INDEX_ORIGIN}/index-catalog.json`;
+const FLAGS_URL = `${INDEX_ORIGIN}/promote.json`;
+const CONTENT_URL = `${INDEX_ORIGIN}/promote_content.json`;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function parseLocalizedMap(value) {
+    if (!isRecord(value))
+        return null;
+    const entries = Object.entries(value).filter((entry) => nonEmptyString(entry[0]) && nonEmptyString(entry[1]));
+    return entries.length ? Object.fromEntries(entries.map(([key, text]) => [key.trim(), text.trim()])) : null;
+}
+function parseImage(value, record) {
+    const image = isRecord(value) ? value : {};
+    const src = nonEmptyString(value)
+        ? value.trim()
+        : nonEmptyString(image.src)
+            ? image.src.trim()
+            : nonEmptyString(image.url)
+                ? image.url.trim()
+                : nonEmptyString(record.imageUrl)
+                    ? record.imageUrl.trim()
+                    : nonEmptyString(record.imageURL)
+                        ? record.imageURL.trim()
+                        : '';
+    if (!src)
+        return undefined;
+    const width = typeof image.width === 'number' && Number.isFinite(image.width) && image.width > 0
+        ? Math.round(image.width)
+        : undefined;
+    const height = typeof image.height === 'number' && Number.isFinite(image.height) && image.height > 0
+        ? Math.round(image.height)
+        : undefined;
+    let normalizedSrc;
+    try {
+        const url = new URL(src, INDEX_ORIGIN);
+        if (!['http:', 'https:'].includes(url.protocol))
+            return undefined;
+        normalizedSrc = url.toString();
+    }
+    catch {
+        return undefined;
+    }
+    return {
+        src: normalizedSrc,
+        alt: nonEmptyString(image.alt)
+            ? image.alt.trim()
+            : nonEmptyString(record.imageAlt)
+                ? record.imageAlt.trim()
+                : '',
+        variant: nonEmptyString(image.variant) ? image.variant.trim() : undefined,
+        width,
+        height,
+    };
+}
+function isSafeLink(value) {
+    try {
+        return ['http:', 'https:'].includes(new URL(value, INDEX_ORIGIN).protocol);
+    }
+    catch {
+        return false;
+    }
+}
+export function parsePromotionFlags(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload.promotes))
+        return [];
+    return payload.promotes.flatMap((item) => {
+        if (!isRecord(item) || !nonEmptyString(item.id) || typeof item.on !== 'boolean')
+            return [];
+        return [{
+                id: item.id.trim(),
+                on: item.on,
+                startTime: nonEmptyString(item.startTime) ? item.startTime.trim() : undefined,
+                endTime: nonEmptyString(item.endTime) ? item.endTime.trim() : undefined,
+            }];
+    });
+}
+export function parsePromotionContent(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload.contents))
+        return [];
+    return payload.contents.flatMap((item) => {
+        if (!isRecord(item) || !nonEmptyString(item.id) || !nonEmptyString(item.link) || !isSafeLink(item.link)) {
+            return [];
+        }
+        const title = parseLocalizedMap(item.title);
+        const description = parseLocalizedMap(item.description);
+        if (!title || !description)
+            return [];
+        const cta = parseLocalizedMap(item.cta);
+        const image = parseImage(item.image, item);
+        return [{
+                id: item.id.trim(),
+                title,
+                description,
+                cta: cta ?? undefined,
+                link: item.link.trim(),
+                image,
+            }];
+    });
+}
+function localeCandidates(locale) {
+    let canonical = 'en-US';
+    if (locale?.trim()) {
+        try {
+            canonical = Intl.getCanonicalLocales(locale.trim().replace(/_/g, '-'))[0] ?? 'en-US';
+        }
+        catch {
+            canonical = 'en-US';
+        }
+    }
+    const normalized = canonical.toLowerCase();
+    const candidates = [normalized, normalized.split('-')[0] ?? normalized];
+    if (normalized.startsWith('zh-hant') || ['zh-tw', 'zh-hk', 'zh-mo'].includes(normalized)) {
+        candidates.push('zh-hant', 'zh-cn', 'zh');
+    }
+    else if (normalized.startsWith('zh')) {
+        candidates.push('zh-cn', 'zh-hant', 'zh');
+    }
+    candidates.push('en-us', 'en');
+    return [...new Set(candidates)];
+}
+function localized(value, locale) {
+    const values = new Map(Object.entries(value).map(([key, text]) => [key.toLowerCase(), text]));
+    for (const candidate of localeCandidates(locale)) {
+        const result = values.get(candidate);
+        if (result)
+            return result;
+    }
+    return Object.values(value)[0] ?? null;
+}
+function isActive(flag, now) {
+    if (!flag.on)
+        return false;
+    const start = flag.startTime ? Date.parse(flag.startTime) : null;
+    const end = flag.endTime ? Date.parse(flag.endTime) : null;
+    if ((start !== null && !Number.isFinite(start)) || (end !== null && !Number.isFinite(end)))
+        return false;
+    if (start !== null && end !== null && start >= end)
+        return false;
+    return (start === null || now >= start) && (end === null || now < end);
+}
+export function normalizeActivePromotions(flags, content, locale, now = Date.now()) {
+    const contentById = new Map(content.map((item) => [item.id, item]));
+    return flags.flatMap((flag) => {
+        const item = contentById.get(flag.id);
+        if (!isActive(flag, now) || !item)
+            return [];
+        const title = localized(item.title, locale);
+        const description = localized(item.description, locale);
+        if (!title || !description)
+            return [];
+        return [{
+                id: item.id,
+                title,
+                description,
+                ctaLabel: (item.cta && localized(item.cta, locale)) || 'Learn more',
+                link: item.link,
+                image: item.image ? { ...item.image, alt: item.image.alt || title } : undefined,
+            }];
+    });
+}
+async function readJson(fetchImpl, url) {
+    const response = await fetchImpl(url, { headers: { accept: 'application/json' }, cache: 'no-store' });
+    if (!response.ok)
+        throw new Error(`Failed to load promotion data (${response.status})`);
+    const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
+    if (!contentType.includes('json'))
+        throw new Error(`Expected JSON promotion data, received ${contentType || 'no content type'}`);
+    return response.json();
+}
+export async function resolvePromotionDocumentUrls(fetchImpl = fetch) {
+    try {
+        const catalog = await readJson(fetchImpl, CATALOG_URL);
+        if (isRecord(catalog) && Array.isArray(catalog.entries)) {
+            const entries = catalog.entries.filter(isRecord);
+            const flags = entries.find((entry) => entry.id === 'promotion-flags' && nonEmptyString(entry.path));
+            const content = entries.find((entry) => entry.id === 'promotion-content' && nonEmptyString(entry.path));
+            const flagsPath = flags?.path;
+            const contentPath = content?.path;
+            if (nonEmptyString(flagsPath) && nonEmptyString(contentPath)) {
+                const flagsUrl = new URL(flagsPath, INDEX_ORIGIN);
+                const contentUrl = new URL(contentPath, INDEX_ORIGIN);
+                if (flagsUrl.origin !== INDEX_ORIGIN || contentUrl.origin !== INDEX_ORIGIN) {
+                    return { flagsUrl: FLAGS_URL, contentUrl: CONTENT_URL, source: 'fallback' };
+                }
+                return {
+                    flagsUrl: flagsUrl.toString(),
+                    contentUrl: contentUrl.toString(),
+                    source: 'catalog',
+                };
+            }
+        }
+    }
+    catch {
+        // The stable canonical endpoints remain available when catalog discovery fails.
+    }
+    return { flagsUrl: FLAGS_URL, contentUrl: CONTENT_URL, source: 'fallback' };
+}
+export async function loadActivePromotions(options = {}) {
+    const { locale, fetchImpl = fetch, now = Date.now() } = options;
+    try {
+        const urls = await resolvePromotionDocumentUrls(fetchImpl);
+        const [flags, content] = await Promise.all([
+            readJson(fetchImpl, urls.flagsUrl),
+            readJson(fetchImpl, urls.contentUrl),
+        ]);
+        return normalizeActivePromotions(parsePromotionFlags(flags), parsePromotionContent(content), locale, now);
+    }
+    catch {
+        return [];
+    }
+}