@hagicode/hagilight-starlight 0.1.0-dev.148.1.e0c630e

package/dist/seo-utils.js

@@ -0,0 +1,219 @@
+import { buildArticleStructuredData, buildBreadcrumbStructuredData, buildOrganizationStructuredData, } from '@hagicode/hagilight-core/seo';
+import { isBlogEntry } from './rss-utils.js';
+const normalizeSlug = (slug) => slug
+    .replace(/^\/+|\/+$/gu, '')
+    .replace(/(?:^|\/)index$/u, '');
+const publishedLookupCache = new WeakMap();
+export function resolveSeoLocales(locales) {
+    const entries = locales === undefined
+        ? [['root', { lang: 'en' }]]
+        : Object.entries(locales);
+    const usedLanguages = new Map();
+    const resolved = entries.map(([route, config]) => {
+        const lang = typeof config === 'string'
+            ? config
+            : config?.lang ?? (route === 'root' ? undefined : route);
+        if (typeof lang !== 'string' || !lang.trim()) {
+            throw new TypeError(`Hagilight SEO locale "${route}" must have a language tag.`);
+        }
+        let normalizedLang;
+        try {
+            [normalizedLang] = Intl.getCanonicalLocales(lang);
+        }
+        catch {
+            throw new TypeError(`Hagilight SEO locale "${route}" has an invalid language tag "${lang}".`);
+        }
+        const collisionKey = normalizedLang.toLowerCase();
+        const existingRoute = usedLanguages.get(collisionKey);
+        if (existingRoute) {
+            throw new Error(`Hagilight SEO locales "${existingRoute}" and "${route}" use the same language tag "${normalizedLang}".`);
+        }
+        usedLanguages.set(collisionKey, route);
+        return { route, lang: normalizedLang };
+    });
+    if (resolved.length === 0) {
+        throw new Error('Hagilight SEO requires at least one configured Starlight locale.');
+    }
+    return resolved;
+}
+export function resolveSeoPage(entryId, locales) {
+    const id = normalizeSlug(entryId ?? '');
+    const localizedRoutes = locales
+        .filter(({ route }) => route !== 'root')
+        .sort((left, right) => right.route.length - left.route.length);
+    const localized = localizedRoutes.find(({ route }) => id === route || id.startsWith(`${route}/`));
+    if (localized) {
+        return {
+            route: localized.route,
+            slug: normalizeSlug(id.slice(localized.route.length)),
+        };
+    }
+    return { route: 'root', slug: id };
+}
+export function createPublishedDocsLookup(entries, locales) {
+    const localeKey = JSON.stringify(locales);
+    let lookups = publishedLookupCache.get(entries);
+    const cached = lookups?.get(localeKey);
+    if (cached)
+        return cached;
+    const pages = new Map();
+    for (const entry of entries) {
+        if (!entry || entry.data?.draft === true)
+            continue;
+        const page = resolveSeoPage(entry.id, locales);
+        pages.set(`${page.route}\u0000${page.slug}`, entry);
+    }
+    const lookup = {
+        get(route, slug) {
+            return pages.get(`${route}\u0000${normalizeSlug(slug)}`);
+        },
+        has(route, slug) {
+            return pages.has(`${route}\u0000${normalizeSlug(slug)}`);
+        },
+    };
+    if (!lookups) {
+        lookups = new Map();
+        publishedLookupCache.set(entries, lookups);
+    }
+    lookups.set(localeKey, lookup);
+    return lookup;
+}
+function parseCandidatePage(href, { locales, basePath }) {
+    let pathname;
+    try {
+        pathname = new URL(href).pathname;
+    }
+    catch {
+        return undefined;
+    }
+    const base = `/${(basePath ?? '/').replace(/^\/+|\/+$/gu, '')}`;
+    if (base !== '/' && pathname !== base && !pathname.startsWith(`${base}/`))
+        return undefined;
+    if (base !== '/')
+        pathname = pathname.slice(base.length) || '/';
+    const segments = pathname.split('/').filter(Boolean);
+    const last = segments.at(-1);
+    if (last === 'index.html')
+        segments.pop();
+    else if (last?.endsWith('.html')) {
+        segments[segments.length - 1] = last.slice(0, -5);
+    }
+    const routes = locales
+        .filter(({ route }) => route !== 'root')
+        .sort((left, right) => right.route.length - left.route.length);
+    let route = 'root';
+    const first = segments[0];
+    if (first?.endsWith('.html')) {
+        const matched = routes.find((locale) => locale.route === first.slice(0, -5));
+        if (matched) {
+            route = matched.route;
+            segments.shift();
+        }
+    }
+    else {
+        const matched = routes.find(({ route: localeRoute }) => first === localeRoute);
+        if (matched) {
+            route = matched.route;
+            segments.shift();
+        }
+    }
+    return { route, slug: normalizeSlug(segments.join('/')) };
+}
+function isAlternateLink(entry) {
+    return entry?.tag === 'link'
+        && entry.attrs?.rel === 'alternate'
+        && typeof entry.attrs.hreflang === 'string'
+        && typeof entry.attrs.href === 'string';
+}
+function explicitAlternateKeys(heads) {
+    return new Set(heads.flatMap((head) => (Array.isArray(head) ? head : [])
+        .filter(isAlternateLink)
+        .map(({ attrs }) => `${attrs.hreflang.toLowerCase()}\u0000${attrs.href}`)));
+}
+export function filterPublishedLocaleAlternates(head, { entryId, locales, lookup, basePath = '/', explicitHead = [], }) {
+    const page = resolveSeoPage(entryId, locales);
+    const explicit = explicitAlternateKeys(explicitHead);
+    const routesByLanguage = new Map(locales.map(({ route, lang }) => [lang.toLowerCase(), route]));
+    return head.filter((entry) => {
+        if (!isAlternateLink(entry))
+            return true;
+        const { href, hreflang } = entry.attrs;
+        if (explicit.has(`${hreflang.toLowerCase()}\u0000${href}`))
+            return true;
+        const candidate = parseCandidatePage(href, { locales, basePath });
+        if (!candidate || candidate.slug !== page.slug)
+            return true;
+        if (hreflang.toLowerCase() === 'x-default') {
+            return lookup.has(candidate.route, candidate.slug);
+        }
+        const configuredRoute = routesByLanguage.get(hreflang.toLowerCase());
+        if (!configuredRoute || configuredRoute !== candidate.route)
+            return true;
+        return lookup.has(configuredRoute, candidate.slug);
+    });
+}
+function normalizeBasePath(basePath = '/') {
+    const normalized = `/${basePath.replace(/^\/+|\/+$/gu, '')}`;
+    return normalized === '/' ? '' : normalized;
+}
+export function buildDocsPageUrl(route, slug, { site, basePath = '/', format = 'directory', trailingSlash = 'always', }) {
+    const id = [route === 'root' ? '' : route, normalizeSlug(slug)].filter(Boolean).join('/');
+    let pagePath;
+    if (format === 'file') {
+        pagePath = `/${id ? `${id}.html` : 'index.html'}`;
+    }
+    else if (!id) {
+        pagePath = '/';
+    }
+    else {
+        pagePath = `/${id}${trailingSlash === 'never' ? '' : '/'}`;
+    }
+    const base = normalizeBasePath(basePath);
+    return new URL(`${base}${pagePath}`, site).href;
+}
+export function buildStructuredData({ entry, entryId, canonicalUrl, site, siteTitle, pageSeo = {}, organization, locales, defaultLocale = 'root', lookup, basePath = '/', format = 'directory', trailingSlash = 'always', }) {
+    if (!entry || entry.data?.draft === true || !canonicalUrl)
+        return [];
+    const page = resolveSeoPage(entryId, locales);
+    if (!lookup.has(page.route, page.slug))
+        return [];
+    const data = entry.data ?? {};
+    const structuredData = [];
+    if (isBlogEntry(page.slug)) {
+        structuredData.push(buildArticleStructuredData({
+            url: canonicalUrl,
+            title: data.title,
+            description: pageSeo.description ?? data.description,
+            author: pageSeo.author ?? data.author,
+            publishedDate: pageSeo.publishedDate ?? data.publishedDate,
+            modifiedDate: data.lastUpdated,
+        }));
+    }
+    const slugParts = page.slug.split('/').filter(Boolean);
+    const crumbs = [];
+    for (let index = 0; index <= slugParts.length; index += 1) {
+        const ancestorSlug = slugParts.slice(0, index).join('/');
+        const ancestor = lookup.get(page.route, ancestorSlug);
+        if (!ancestor)
+            continue;
+        const url = ancestorSlug === page.slug
+            ? canonicalUrl
+            : buildDocsPageUrl(page.route, ancestorSlug, {
+                site,
+                basePath,
+                format,
+                trailingSlash,
+            });
+        crumbs.push({ name: ancestor.data.title, url });
+    }
+    if (crumbs.length > 0) {
+        structuredData.push(buildBreadcrumbStructuredData(crumbs));
+    }
+    if (organization && page.route === defaultLocale && page.slug === '') {
+        structuredData.push(buildOrganizationStructuredData({
+            ...organization,
+            ...(siteTitle === undefined ? {} : { alternateName: siteTitle }),
+        }));
+    }
+    return structuredData;
+}

package/dist/showcase.d.ts

@@ -0,0 +1,6 @@
+import { getArticlePromotionCopy } from './article-promotion.js';
+export type { ArticlePromotionCopy as ShowcaseCopy, ArticlePromotionFeature as ShowcaseFeature, ArticlePromotionGalleryItem as ShowcaseGalleryItem, } from './article-promotion.js';
+/** Returns the read-only showcase copy for a locale, or the English copy when the locale has none. */
+export declare const getShowcaseCopy: typeof getArticlePromotionCopy;
+/** Locales that have their own showcase copy. */
+export declare const showcaseLocales: readonly string[];

package/dist/showcase.js

@@ -0,0 +1,5 @@
+import { COPY, getArticlePromotionCopy } from './article-promotion.js';
+/** Returns the read-only showcase copy for a locale, or the English copy when the locale has none. */
+export const getShowcaseCopy = getArticlePromotionCopy;
+/** Locales that have their own showcase copy. */
+export const showcaseLocales = Object.freeze(Object.keys(COPY));

package/dist/site-metadata.d.ts

@@ -0,0 +1,38 @@
+import type { AstroIntegration } from 'astro';
+import type { BuildInfo } from '@hagicode/hagilight-core/build-info';
+import { type SiteMetadataAnalytics, type SiteMetadataFeatures } from '@hagicode/hagilight-core/site-metadata';
+import { type SiteMetadataLogger } from '@hagicode/hagilight-core/site-metadata-writer';
+export interface StarlightSiteMetadataSetup {
+    enabled: boolean;
+    /** Explicit `metadata.name`, when set. */
+    name?: string | undefined;
+    /** Explicit `metadata.description`, when set. */
+    description?: string | undefined;
+    /** Starlight `title`: a string or a localized record. */
+    title: unknown;
+    /** Starlight `description`, when the site configures one. */
+    siteDescription?: unknown;
+    /** Starlight `locales` map, for example `{ root: { lang: 'en' } }`. */
+    locales: unknown;
+    /** Starlight `defaultLocale`. */
+    defaultLocale: unknown;
+    site: unknown;
+    base: string | undefined;
+    publicDir: URL;
+    analytics: SiteMetadataAnalytics;
+    features: SiteMetadataFeatures;
+}
+export interface WriteStarlightSiteMetadataInput {
+    outDir: string;
+    setup: StarlightSiteMetadataSetup;
+    build: BuildInfo;
+    logger: SiteMetadataLogger;
+}
+/** Build and write the metadata file for a Starlight build. Skips with a warning when no absolute site URL exists. */
+export declare function writeStarlightSiteMetadata({ outDir, setup, build, logger }: WriteStarlightSiteMetadataInput): void;
+/**
+ * Integration appended after this plugin's sitemap, so the write runs after
+ * `@astrojs/sitemap` has written its index. The owner's write also waits for any
+ * deferring plain-Astro peer that reported before it.
+ */
+export declare function createStarlightMetadataFinalizer(setup: StarlightSiteMetadataSetup, buildInfo: () => BuildInfo | undefined): AstroIntegration;

package/dist/site-metadata.js

@@ -0,0 +1,109 @@
+/**
+ * Facts for `.well-known/hagilight.metadata.json` from a Starlight build. The
+ * Starlight plugin owns the file when it is enabled, so this module collects the
+ * title, locales and resolved feature flags from its own configuration.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildSiteMetadata, SITE_METADATA_PATH, } from '@hagicode/hagilight-core/site-metadata';
+import { findDiscoveryOutputs, writeSiteMetadata } from '@hagicode/hagilight-core/site-metadata-writer';
+import { completeSiteMetadataOwnerBuild } from '@hagicode/hagilight-core/site-metadata-ownership';
+import { resolveSeoLocales } from './seo-utils.js';
+const STARLIGHT_PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function absoluteSite(site) {
+    try {
+        const parsed = new URL(site);
+        return ['http:', 'https:'].includes(parsed.protocol) && !parsed.username && !parsed.password ? parsed.href : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function trimmedText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+/** Starlight locale routes become metadata locales. The root route uses its language tag as the code. */
+function toMetadataLocales(locales) {
+    const routes = new Map();
+    const entries = locales.map(({ route, lang }) => {
+        const code = route === 'root' ? lang : route;
+        routes.set(route, code);
+        return { code, lang, path: route === 'root' ? '/' : `/${route}/` };
+    });
+    return { locales: entries, routes };
+}
+/** Starlight's default locale is the route named in `defaultLocale`, or `root`. */
+function defaultRoute(defaultLocale, locales) {
+    const configured = isRecord(defaultLocale) ? defaultLocale.locale ?? defaultLocale.lang : defaultLocale;
+    if (typeof configured !== 'string' || !configured.trim())
+        return locales.find(({ route }) => route === 'root')?.route ?? locales[0]?.route ?? 'root';
+    const match = locales.find(({ route, lang }) => route === configured || lang === configured);
+    return match?.route ?? configured;
+}
+/** Starlight's title, read for the default locale. A localized record uses `root` or its first entry. */
+function siteTitle(title, route) {
+    if (typeof title === 'string')
+        return trimmedText(title);
+    if (!isRecord(title))
+        return undefined;
+    return trimmedText(title[route] ?? title.root ?? Object.values(title)[0]);
+}
+/** Build and write the metadata file for a Starlight build. Skips with a warning when no absolute site URL exists. */
+export function writeStarlightSiteMetadata({ outDir, setup, build, logger }) {
+    const siteUrl = absoluteSite(setup.site);
+    if (!siteUrl) {
+        logger.warn(`${SITE_METADATA_PATH} requires an absolute Astro site URL, so it was not generated.`);
+        return;
+    }
+    const seoLocales = resolveSeoLocales(setup.locales);
+    const { locales, routes } = toMetadataLocales(seoLocales);
+    const defaultCode = routes.get(defaultRoute(setup.defaultLocale, seoLocales));
+    const route = defaultRoute(setup.defaultLocale, seoLocales);
+    const base = `${setup.base || '/'}`.replace(/\/?$/u, '/');
+    const metadata = buildSiteMetadata({
+        generator: { name: '@hagicode/hagilight-starlight', version: STARLIGHT_PACKAGE_VERSION },
+        site: {
+            name: setup.name ?? siteTitle(setup.title, route),
+            url: siteUrl,
+            base,
+            description: setup.description ?? trimmedText(setup.siteDescription),
+        },
+        locales,
+        defaultLocale: defaultCode,
+        fallbackLang: seoLocales.find((entry) => entry.route === route)?.lang,
+        build,
+        discovery: findDiscoveryOutputs(outDir),
+        analytics: setup.analytics,
+        features: setup.features,
+    });
+    writeSiteMetadata({
+        outDir,
+        metadata,
+        siteOwnedFiles: [join(fileURLToPath(setup.publicDir), SITE_METADATA_PATH)],
+        logger,
+    });
+}
+/**
+ * Integration appended after this plugin's sitemap, so the write runs after
+ * `@astrojs/sitemap` has written its index. The owner's write also waits for any
+ * deferring plain-Astro peer that reported before it.
+ */
+export function createStarlightMetadataFinalizer(setup, buildInfo) {
+    return {
+        name: '@hagicode/hagilight-starlight:metadata',
+        hooks: {
+            'astro:build:done'({ dir, logger }) {
+                completeSiteMetadataOwnerBuild(() => {
+                    const build = buildInfo();
+                    if (!build)
+                        return;
+                    writeStarlightSiteMetadata({ outDir: fileURLToPath(dir), setup, build, logger });
+                });
+            },
+        },
+    };
+}

package/dist/themes.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Hagilight theme picker: four themes (the Starlight default plus Ocean, Sakura, and Forest),
+ * each with a light and a dark appearance, plus a "default" choice that follows the system
+ * color scheme and renders the Forest palette. The palette in use is exposed to CSS through the
+ * `data-hagilight-theme` attribute on `<html>`; light/dark mode keeps using Starlight's
+ * `data-theme` attribute and `starlight-theme` storage so Starlight's pre-paint script
+ * continues to apply the correct mode.
+ */
+export type ThemeId = 'default' | 'ocean' | 'sakura' | 'forest';
+export type ThemeMode = 'light' | 'dark';
+export type ThemeChoice = 'default' | 'default-light' | 'default-dark' | 'ocean-light' | 'ocean-dark' | 'sakura-light' | 'sakura-dark' | 'forest-light' | 'forest-dark';
+/** Themes beyond the Starlight default; each must have light and dark palettes in `themes.css`. */
+export declare const EXTRA_THEME_IDS: readonly ["ocean", "sakura", "forest"];
+/** The palette the "default" choice renders, so first-visit users always see the same theme. */
+export declare const DEFAULT_PALETTE_THEME_ID: Exclude<ThemeId, 'default'>;
+export declare const DEFAULT_THEME_CHOICE: ThemeChoice;
+export declare const THEME_CHOICES: readonly ["default", "default-light", "default-dark", "ocean-light", "ocean-dark", "sakura-light", "sakura-dark", "forest-light", "forest-dark"];
+export declare const THEME_STORAGE_KEY = "hagilight-theme";
+/** Starlight's own storage key; kept in sync with the picker so its pre-paint script applies the right mode. */
+export declare const STARLIGHT_THEME_STORAGE_KEY = "starlight-theme";
+export declare function parseThemeChoice(value: unknown): ThemeChoice;
+export declare function splitThemeChoice(choice: ThemeChoice): {
+    themeId: ThemeId;
+    mode?: ThemeMode;
+};
+/** The theme id a choice renders as: the theme itself, or the Forest palette for "default". */
+export declare function resolveThemeId(choice: ThemeChoice): ThemeId;
+export declare function readStoredThemeChoice(): ThemeChoice;
+/** Apply a choice to the document, persist it, and keep Starlight's mode storage in sync. */
+export declare function applyThemeChoice(choice: ThemeChoice, root?: HTMLElement): void;
+/**
+ * Inline pre-paint bootstrap run from `<head>`: it must stay dependency-free because it
+ * executes before any module script. Keep the behavior identical to `applyThemeChoice`.
+ */
+export declare const THEME_BOOTSTRAP: string;
+export interface ThemePickerLabels {
+    /** Label of the "default" choice: follows the system color scheme and renders the Forest theme. */
+    defaultOption: string;
+    /** Label of the option group holding the built-in theme's light and dark appearances. */
+    defaultThemeGroup: string;
+    themes: Record<Exclude<ThemeId, 'default'>, string>;
+}
+export declare function getThemePickerLabels(lang: string | undefined): ThemePickerLabels;

package/dist/themes.js

@@ -0,0 +1,156 @@
+/**
+ * Hagilight theme picker: four themes (the Starlight default plus Ocean, Sakura, and Forest),
+ * each with a light and a dark appearance, plus a "default" choice that follows the system
+ * color scheme and renders the Forest palette. The palette in use is exposed to CSS through the
+ * `data-hagilight-theme` attribute on `<html>`; light/dark mode keeps using Starlight's
+ * `data-theme` attribute and `starlight-theme` storage so Starlight's pre-paint script
+ * continues to apply the correct mode.
+ */
+/** Themes beyond the Starlight default; each must have light and dark palettes in `themes.css`. */
+export const EXTRA_THEME_IDS = ['ocean', 'sakura', 'forest'];
+/** The palette the "default" choice renders, so first-visit users always see the same theme. */
+export const DEFAULT_PALETTE_THEME_ID = 'forest';
+export const DEFAULT_THEME_CHOICE = 'default';
+export const THEME_CHOICES = [
+    'default',
+    'default-light',
+    'default-dark',
+    'ocean-light',
+    'ocean-dark',
+    'sakura-light',
+    'sakura-dark',
+    'forest-light',
+    'forest-dark',
+];
+export const THEME_STORAGE_KEY = 'hagilight-theme';
+/** Starlight's own storage key; kept in sync with the picker so its pre-paint script applies the right mode. */
+export const STARLIGHT_THEME_STORAGE_KEY = 'starlight-theme';
+const THEME_CHOICE_SET = new Set(THEME_CHOICES);
+export function parseThemeChoice(value) {
+    return THEME_CHOICE_SET.has(value) ? value : DEFAULT_THEME_CHOICE;
+}
+export function splitThemeChoice(choice) {
+    if (choice === DEFAULT_THEME_CHOICE)
+        return { themeId: 'default' };
+    const separator = choice.lastIndexOf('-');
+    return {
+        themeId: choice.slice(0, separator),
+        mode: choice.slice(separator + 1),
+    };
+}
+function readStorage(key) {
+    try {
+        return globalThis.localStorage?.getItem(key) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeStorage(key, value) {
+    try {
+        globalThis.localStorage?.setItem(key, value);
+    }
+    catch {
+        return;
+    }
+}
+/** The theme id a choice renders as: the theme itself, or the Forest palette for "default". */
+export function resolveThemeId(choice) {
+    const { themeId, mode } = splitThemeChoice(choice);
+    return mode === undefined ? DEFAULT_PALETTE_THEME_ID : themeId;
+}
+export function readStoredThemeChoice() {
+    return parseThemeChoice(readStorage(THEME_STORAGE_KEY));
+}
+/** Apply a choice to the document, persist it, and keep Starlight's mode storage in sync. */
+export function applyThemeChoice(choice, root = document.documentElement) {
+    const { mode } = splitThemeChoice(choice);
+    root.dataset.hagilightTheme = resolveThemeId(choice);
+    if (mode !== undefined)
+        root.dataset.theme = mode;
+    writeStorage(THEME_STORAGE_KEY, choice);
+    writeStorage(STARLIGHT_THEME_STORAGE_KEY, mode ?? '');
+}
+/**
+ * Inline pre-paint bootstrap run from `<head>`: it must stay dependency-free because it
+ * executes before any module script. Keep the behavior identical to `applyThemeChoice`.
+ */
+export const THEME_BOOTSTRAP = `(function () {
+  var choices = ${JSON.stringify(THEME_CHOICES)};
+  var choiceKey = ${JSON.stringify(THEME_STORAGE_KEY)};
+  var choice = 'default';
+  try {
+    var stored = localStorage.getItem(choiceKey);
+    if (choices.includes(stored)) choice = stored;
+  } catch (error) {}
+  var themeId = choice === 'default'
+    ? ${JSON.stringify(DEFAULT_PALETTE_THEME_ID)}
+    : choice.slice(0, choice.lastIndexOf('-'));
+  document.documentElement.dataset.hagilightTheme = themeId;
+})();`;
+const labels = {
+    'de-de': {
+        defaultOption: 'Standard',
+        defaultThemeGroup: 'Standard-Design',
+        themes: { ocean: 'Ozean', sakura: 'Sakura', forest: 'Wald' },
+    },
+    'en-us': {
+        defaultOption: 'Default',
+        defaultThemeGroup: 'Default theme',
+        themes: { ocean: 'Ocean', sakura: 'Sakura', forest: 'Forest' },
+    },
+    'es-es': {
+        defaultOption: 'Predeterminado',
+        defaultThemeGroup: 'Tema predeterminado',
+        themes: { ocean: 'Océano', sakura: 'Sakura', forest: 'Bosque' },
+    },
+    'fr-fr': {
+        defaultOption: 'Par défaut',
+        defaultThemeGroup: 'Thème par défaut',
+        themes: { ocean: 'Océan', sakura: 'Sakura', forest: 'Forêt' },
+    },
+    'ja-jp': {
+        defaultOption: 'デフォルト',
+        defaultThemeGroup: 'デフォルトテーマ',
+        themes: { ocean: '海', sakura: '桜', forest: '森' },
+    },
+    'ko-kr': {
+        defaultOption: '기본값',
+        defaultThemeGroup: '기본 테마',
+        themes: { ocean: '바다', sakura: '벚꽃', forest: '숲' },
+    },
+    'pt-br': {
+        defaultOption: 'Padrão',
+        defaultThemeGroup: 'Tema padrão',
+        themes: { ocean: 'Oceano', sakura: 'Sakura', forest: 'Floresta' },
+    },
+    'ru-ru': {
+        defaultOption: 'По умолчанию',
+        defaultThemeGroup: 'Стандартная тема',
+        themes: { ocean: 'Океан', sakura: 'Сакура', forest: 'Лес' },
+    },
+    'zh-cn': {
+        defaultOption: '默认',
+        defaultThemeGroup: '默认主题',
+        themes: { ocean: '海洋', sakura: '樱花', forest: '森林' },
+    },
+    'zh-hant': {
+        defaultOption: '預設',
+        defaultThemeGroup: '預設主題',
+        themes: { ocean: '海洋', sakura: '櫻花', forest: '森林' },
+    },
+};
+const enLabels = labels['en-us'];
+export function getThemePickerLabels(lang) {
+    if (lang !== undefined) {
+        const key = lang.toLowerCase();
+        const exact = labels[key];
+        if (exact)
+            return exact;
+        const prefix = key.split('-')[0];
+        const prefixed = Object.entries(labels).find(([id]) => id.split('-')[0] === prefix);
+        if (prefixed)
+            return prefixed[1];
+    }
+    return enLabels;
+}

package/dist/windows-download.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_WINDOWS_STORE_PRODUCT_ID = "9N3PM0N3SVDW";
+/** Same rule as the Docs site: the product id is the path segment after `detail/` in the Store URL. */
+export declare function resolveMicrosoftStoreProductId(href?: string): string;
+export declare function resolveMicrosoftStoreBadgeLanguage(locale?: string): string;

package/dist/windows-download.js

@@ -0,0 +1,22 @@
+export const DEFAULT_WINDOWS_STORE_PRODUCT_ID = '9N3PM0N3SVDW';
+/** Microsoft Store badge language for each showcase locale; `repos/docs` only maps zh and en. */
+const BADGE_LANGUAGES = {
+    'en-US': 'en-us',
+    'zh-CN': 'zh-cn',
+    'zh-Hant': 'zh-tw',
+    'ja-JP': 'ja',
+    'ko-KR': 'ko',
+    'de-DE': 'de',
+    'fr-FR': 'fr',
+    'es-ES': 'es',
+    'pt-BR': 'pt-br',
+    'ru-RU': 'ru',
+};
+/** Same rule as the Docs site: the product id is the path segment after `detail/` in the Store URL. */
+export function resolveMicrosoftStoreProductId(href) {
+    const match = href?.match(/(?:detail|store\/detail)\/([a-z0-9]+)/i);
+    return match?.[1]?.toUpperCase() ?? DEFAULT_WINDOWS_STORE_PRODUCT_ID;
+}
+export function resolveMicrosoftStoreBadgeLanguage(locale) {
+    return (locale === undefined ? undefined : BADGE_LANGUAGES[locale]) ?? 'en-us';
+}