@hagicode/hagilight-starlight 0.3.2-dev.55.1.1e29eba → 0.3.2-dev.57.1.ee1f17e

package/dist/not-found.js

@@ -0,0 +1,28 @@
+const homeLabels = {
+    de: 'Zur Startseite',
+    en: 'Back to home',
+    es: 'Volver al inicio',
+    fr: 'Retour à l’accueil',
+    ja: 'ホームに戻る',
+    ko: '홈으로 돌아가기',
+    pt: 'Voltar ao início',
+    ru: 'На главную',
+    'zh-cn': '返回首页',
+    'zh-hant': '返回首頁',
+};
+export function isNotFoundEntry(entryId) {
+    return entryId === '404' || entryId.endsWith('/404');
+}
+export function getNotFoundHomeHref({ basePath = '/', locale, trailingSlash = 'ignore' }) {
+    const base = basePath.replace(/\/+$/u, '');
+    const localePath = locale && locale !== 'root' ? `/${locale}` : '';
+    const path = `${base}${localePath}` || '/';
+    if (trailingSlash === 'never') {
+        return path.replace(/\/+$/u, '') || '/';
+    }
+    return `${path.replace(/\/+$/u, '')}/`;
+}
+export function getNotFoundHomeLabel(lang) {
+    const language = lang?.replaceAll('_', '-').toLowerCase() ?? 'en';
+    return homeLabels[language] ?? homeLabels[language.split('-')[0]] ?? homeLabels.en;
+}

package/dist/rss-renderer.d.ts

@@ -0,0 +1,14 @@
+import { type RssLocale } from '@hagicode/hagilight-core/rss';
+import { type ResolvedRssContentOptions, type RssDocsEntry } from './rss-utils.js';
+/** Serialized configuration exposed to the Starlight RSS routes. */
+export interface StarlightRssRuntimeConfig {
+    options: ResolvedRssContentOptions;
+    locales: readonly RssLocale[];
+}
+export interface StarlightRssFeedInput extends StarlightRssRuntimeConfig {
+    site: string | URL | undefined;
+    baseUrl: string;
+    filename: string | undefined;
+    entries: readonly RssDocsEntry[];
+}
+export declare function generateRssFeed({ site, baseUrl, filename, locales, options, entries, }: StarlightRssFeedInput): Promise<Response>;

package/dist/rss-renderer.js

@@ -0,0 +1,30 @@
+import { generateRssFeed as generateCoreRssFeed } from '@hagicode/hagilight-core/rss';
+import { selectRssEntries } from './rss-utils.js';
+export function generateRssFeed({ site, baseUrl, filename, locales, options, entries, }) {
+    if (!site)
+        throw new Error('Hagilight RSS requires the Astro site option.');
+    const locale = locales.find((item) => item.filename === filename);
+    if (!locale && filename !== 'en') {
+        throw new Error(`Hagilight RSS has no configured locale for "${filename}".`);
+    }
+    const items = selectRssEntries(entries, { filename, locales, options }).map(({ id, data }) => {
+        const slug = id.replace(/(?:^|\/)index$/u, '');
+        const lastUpdated = data.lastUpdated;
+        return {
+            title: data.title,
+            description: data.description,
+            ...(lastUpdated instanceof Date && !Number.isNaN(lastUpdated.getTime())
+                ? { date: lastUpdated }
+                : {}),
+            link: slug ? `${slug}/` : '/',
+        };
+    });
+    return generateCoreRssFeed({
+        site,
+        baseUrl,
+        language: locale?.lang ?? 'en',
+        title: 'Documentation',
+        description: 'Recently updated documentation pages',
+        items,
+    });
+}

package/dist/rss-utils.d.ts

@@ -0,0 +1,27 @@
+import type { RssLocale } from '@hagicode/hagilight-core/rss';
+export interface RssContentOptions {
+    /** Include non-blog documentation pages. Defaults to `true`. */
+    includeDocs?: boolean;
+    /** Include pages under `blog/`. Defaults to `true`. */
+    includeBlog?: boolean;
+}
+export type ResolvedRssContentOptions = Required<RssContentOptions>;
+/** The subset of a Starlight docs collection entry used to build feeds. */
+export interface RssDocsEntry {
+    id: string;
+    data: {
+        title: string;
+        description?: string | undefined;
+        draft?: boolean | undefined;
+        rss?: unknown;
+        lastUpdated?: unknown;
+    };
+}
+export interface SelectRssEntriesOptions {
+    filename: string | undefined;
+    locales: readonly RssLocale[];
+    options: ResolvedRssContentOptions;
+}
+export declare function resolveRssOptions(options?: RssContentOptions): ResolvedRssContentOptions;
+export declare function isBlogEntry(id: string): boolean;
+export declare function selectRssEntries<Entry extends RssDocsEntry>(entries: readonly Entry[], { filename, locales, options }: SelectRssEntriesOptions): Entry[];

package/dist/rss-utils.js

@@ -0,0 +1,65 @@
+export function resolveRssOptions(options = {}) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new TypeError('Hagilight rss options must be an object.');
+    }
+    for (const key of ['includeDocs', 'includeBlog']) {
+        if (options[key] !== undefined && typeof options[key] !== 'boolean') {
+            throw new TypeError(`Hagilight rss ${key} option must be a boolean.`);
+        }
+    }
+    return {
+        includeDocs: options.includeDocs ?? true,
+        includeBlog: options.includeBlog ?? true,
+    };
+}
+function getLocaleForEntry(id, locales) {
+    const localized = locales
+        .filter(({ route }) => route !== 'root')
+        .sort((a, b) => b.route.length - a.route.length)
+        .find(({ route }) => id === route || id.startsWith(`${route}/`));
+    if (localized)
+        return { locale: localized, relativeId: id.slice(localized.route.length).replace(/^\/+/, '') };
+    const root = locales.find(({ route }) => route === 'root');
+    if (root)
+        return { locale: root, relativeId: id };
+    return undefined;
+}
+export function isBlogEntry(id) {
+    const segments = id.split('/').filter(Boolean);
+    if (segments.at(-1) === 'index')
+        segments.pop();
+    return segments[0] === 'blog' && segments.length > 1;
+}
+function timestamp(value) {
+    return value instanceof Date ? value.getTime() : undefined;
+}
+export function selectRssEntries(entries, { filename, locales, options }) {
+    const locale = locales.find((item) => item.filename === filename);
+    if (!locale) {
+        if (filename === 'en')
+            return [];
+        throw new Error(`Hagilight RSS has no configured locale for "${filename}".`);
+    }
+    return entries
+        .filter(({ id, data }) => {
+        if (data.rss !== undefined && typeof data.rss !== 'boolean') {
+            throw new TypeError(`Hagilight RSS frontmatter field "rss" for "${id}" must be a boolean.`);
+        }
+        if (data.draft || data.rss === false)
+            return false;
+        const entryLocale = getLocaleForEntry(id, locales);
+        if (!entryLocale || entryLocale.locale.filename !== filename)
+            return false;
+        const isBlog = isBlogEntry(entryLocale.relativeId);
+        return isBlog ? options.includeBlog : options.includeDocs;
+    })
+        .sort((a, b) => {
+        const aDate = timestamp(a.data.lastUpdated);
+        const bDate = timestamp(b.data.lastUpdated);
+        if (aDate === undefined || Number.isNaN(aDate))
+            return bDate === undefined || Number.isNaN(bDate) ? 0 : 1;
+        if (bDate === undefined || Number.isNaN(bDate))
+            return -1;
+        return bDate - aDate;
+    });
+}

package/dist/schema.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'astro/zod';
+/** Per-page AI disclosure flags that override the plugin `aiDisclosures` defaults. */
+export declare const aiDisclosureSchema: z.ZodObject<{
+    isAITranslation: z.ZodOptional<z.ZodBoolean>;
+    isAIAuthor: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Per-page switch for the end-of-article HagiCode introduction. */
+export declare const articlePromotionSchema: z.ZodObject<{
+    hagicodePromotion: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Per-page switch that excludes a page from generated RSS feeds when `false`. */
+export declare const rssSchema: z.ZodObject<{
+    rss: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Every frontmatter field read by the Hagilight Starlight plugin, including the
+ * shared `seo` object. Pass it to Starlight as `docsSchema({ extend: hagilightSchema })`.
+ */
+export declare const hagilightSchema: z.ZodObject<{
+    seo: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+        author: z.ZodOptional<z.ZodString>;
+        publishedDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    }, z.core.$strip>>;
+    rss: z.ZodOptional<z.ZodBoolean>;
+    hagicodePromotion: z.ZodOptional<z.ZodBoolean>;
+    isAITranslation: z.ZodOptional<z.ZodBoolean>;
+    isAIAuthor: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type HagilightFrontmatter = z.infer<typeof hagilightSchema>;

package/dist/schema.js

@@ -0,0 +1,25 @@
+import { z } from 'astro/zod';
+import { seoSchema } from '@hagicode/hagilight-core/seo-schema';
+/** Per-page AI disclosure flags that override the plugin `aiDisclosures` defaults. */
+export const aiDisclosureSchema = z.object({
+    isAITranslation: z.boolean().optional(),
+    isAIAuthor: z.boolean().optional(),
+});
+/** Per-page switch for the end-of-article HagiCode introduction. */
+export const articlePromotionSchema = z.object({
+    hagicodePromotion: z.boolean().optional(),
+});
+/** Per-page switch that excludes a page from generated RSS feeds when `false`. */
+export const rssSchema = z.object({
+    rss: z.boolean().optional(),
+});
+/**
+ * Every frontmatter field read by the Hagilight Starlight plugin, including the
+ * shared `seo` object. Pass it to Starlight as `docsSchema({ extend: hagilightSchema })`.
+ */
+export const hagilightSchema = z.object({
+    ...aiDisclosureSchema.shape,
+    ...articlePromotionSchema.shape,
+    ...rssSchema.shape,
+    ...seoSchema.shape,
+});

package/dist/seo-utils.d.ts

@@ -0,0 +1,74 @@
+import { type HeadEntry, type StructuredData } from '@hagicode/hagilight-core/seo';
+import type { TrailingSlash } from './not-found.js';
+export interface SeoLocale {
+    route: string;
+    lang: string;
+}
+export interface SeoPage {
+    route: string;
+    slug: string;
+}
+export interface SeoDocsEntry {
+    id: string;
+    body?: string | undefined;
+    data: {
+        title: string;
+        description?: string | undefined;
+        draft?: boolean | undefined;
+        author?: string | undefined;
+        publishedDate?: Date | string | number | undefined;
+        lastUpdated?: Date | string | number | undefined | unknown;
+        [key: string]: unknown;
+    };
+}
+export interface PublishedDocsLookup<Entry extends SeoDocsEntry = SeoDocsEntry> {
+    get(route: string, slug: string): Entry | undefined;
+    has(route: string, slug: string): boolean;
+}
+export type BuildFormat = 'directory' | 'file' | 'preserve';
+export interface SeoOrganization {
+    name: string;
+    url: string;
+    logo?: string;
+}
+export type SeoLocalesInput = Readonly<Record<string, string | {
+    lang?: string | undefined;
+} | undefined>>;
+export declare function resolveSeoLocales(locales: SeoLocalesInput | undefined): SeoLocale[];
+export declare function resolveSeoPage(entryId: string | undefined, locales: readonly SeoLocale[]): SeoPage;
+export declare function createPublishedDocsLookup<Entry extends SeoDocsEntry>(entries: readonly Entry[], locales: readonly SeoLocale[]): PublishedDocsLookup<Entry>;
+export interface FilterAlternatesOptions {
+    entryId: string;
+    locales: readonly SeoLocale[];
+    lookup: PublishedDocsLookup<SeoDocsEntry>;
+    basePath?: string;
+    explicitHead?: readonly (readonly HeadEntry[] | undefined)[];
+}
+export declare function filterPublishedLocaleAlternates<Entry extends HeadEntry>(head: readonly Entry[], { entryId, locales, lookup, basePath, explicitHead, }: FilterAlternatesOptions): Entry[];
+export interface DocsPageUrlOptions {
+    site: string | URL;
+    basePath?: string;
+    format?: BuildFormat;
+    trailingSlash?: TrailingSlash;
+}
+export declare function buildDocsPageUrl(route: string, slug: string, { site, basePath, format, trailingSlash, }: DocsPageUrlOptions): string;
+export interface BuildStructuredDataOptions {
+    entry: SeoDocsEntry | undefined;
+    entryId: string;
+    canonicalUrl: string | undefined;
+    site: string | URL;
+    siteTitle?: string | undefined;
+    pageSeo?: {
+        description?: string | undefined;
+        author?: string | undefined;
+        publishedDate?: Date | string | number | undefined;
+    };
+    organization?: SeoOrganization | undefined;
+    locales: readonly SeoLocale[];
+    defaultLocale?: string;
+    lookup: PublishedDocsLookup<SeoDocsEntry>;
+    basePath?: string;
+    format?: BuildFormat;
+    trailingSlash?: TrailingSlash;
+}
+export declare function buildStructuredData({ entry, entryId, canonicalUrl, site, siteTitle, pageSeo, organization, locales, defaultLocale, lookup, basePath, format, trailingSlash, }: BuildStructuredDataOptions): StructuredData[];

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/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@hagicode/hagilight-starlight",
-  "version": "0.3.2-dev.55.1.1e29eba",
+  "version": "0.3.2-dev.57.1.ee1f17e",
   "type": "module",
-  "description": "Starlight customizations for HagiCode documentation",
+  "description": "Starlight plugin and components for HagiCode documentation",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/HagiCode-org/hagilight.git",
@@ -12,30 +12,22 @@
     "access": "public",
     "provenance": true
   },
+  "scripts": {
+    "build": "tsc -b",
+    "prepack": "tsc -b"
+  },
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "default": "./index.mjs"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./locales": {
-      "types": "./locales.d.ts",
-      "default": "./locales.mjs"
-    },
-    "./article-promotion-schema": {
-      "types": "./article-promotion-schema.d.ts",
-      "default": "./article-promotion-schema.mjs"
-    },
-    "./ai-disclosure-schema": {
-      "types": "./ai-disclosure-schema.d.ts",
-      "default": "./ai-disclosure-schema.mjs"
+      "types": "./dist/locales.d.ts",
+      "default": "./dist/locales.js"
     },
-    "./rss-schema": {
-      "types": "./rss-schema.d.ts",
-      "default": "./rss-schema.mjs"
-    },
-    "./seo-schema": {
-      "types": "./seo-schema.d.ts",
-      "default": "./seo-schema.mjs"
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "default": "./dist/schema.js"
     },
     "./ContentLayoutToggle": "./ContentLayoutToggle.astro",
     "./Header": "./Header.astro",
@@ -47,27 +39,30 @@
     "./PromotoFooter": "./PromotoFooter.astro"
   },
   "files": [
-    "index.mjs",
-    "index.d.ts",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "*.astro",
     "*.css",
-    "*.mjs",
-    "*.d.ts",
     "rss*.xml.ts",
-    "*.astro",
     "assets/*.png"
   ],
   "dependencies": {
-    "@hagicode/hagilight": "0.3.2-dev.55.1.1e29eba"
+    "@hagicode/hagilight-core": "0.3.2-dev.57.1.ee1f17e"
   },
   "peerDependencies": {
     "@astrojs/starlight": "^0.42.4",
     "astro": "^7.3.5"
   },
+  "devDependencies": {
+    "@astrojs/starlight": "^0.42.4",
+    "astro": "^7.3.5"
+  },
   "keywords": [
     "astro-component",
     "withastro",
     "astro-seo",
     "starlight",
+    "starlight-plugin",
     "multilingual-documentation",
     "hreflang",
     "structured-data"

package/rss.[language].xml.ts

@@ -1,7 +1,7 @@
 import { getCollection } from 'astro:content';
 import type { APIRoute, GetStaticPaths } from 'astro';
 import rssConfig from 'virtual:hagilight-starlight/rss-config';
-import { generateRssFeed } from './rss-renderer.mjs';
+import { generateRssFeed } from './dist/rss-renderer.js';
 
 export const getStaticPaths: GetStaticPaths = () => {
   const filenames = new Set(['en', ...rssConfig.locales.map(({ filename }) => filename)]);

package/rss.xml.ts

@@ -1,7 +1,7 @@
 import { getCollection } from 'astro:content';
 import type { APIRoute } from 'astro';
 import rssConfig from 'virtual:hagilight-starlight/rss-config';
-import { generateRssFeed } from './rss-renderer.mjs';
+import { generateRssFeed } from './dist/rss-renderer.js';
 
 export const GET: APIRoute = async ({ site }) => {
   const entries = await getCollection('docs');

package/ai-disclosure-schema.d.ts

@@ -1,8 +0,0 @@
-import type { ZodBoolean, ZodObject, ZodOptional } from "astro/zod";
-
-export const aiDisclosureSchema: ZodObject<{
-  isAITranslation: ZodOptional<ZodBoolean>;
-  isAIAuthor: ZodOptional<ZodBoolean>;
-}>;
-
-export { aiDisclosureSchema as default };

package/ai-disclosure-schema.mjs

@@ -1,9 +0,0 @@
-import { z } from 'astro/zod';
-
-const aiDisclosureSchema = z.object({
-  isAITranslation: z.boolean().optional(),
-  isAIAuthor: z.boolean().optional(),
-});
-
-export { aiDisclosureSchema };
-export default aiDisclosureSchema;