@coffic/cosy-ui 0.4.7 → 0.5.2

package/dist/utils/language.ts

@@ -4,168 +4,172 @@
  * 提供语言相关的工具函数，用于多语言支持
  */
 
+import { getRelativeLocaleUrl } from 'astro:i18n';
+import { logger } from './logger';
+import { LinkUtil } from './link';
+import type { AstroGlobal } from 'astro';
+
 // 支持的语言列表
 export const SUPPORTED_LANGUAGES = ['en', 'zh-cn', 'zh'] as const;
 export type SupportedLanguage = typeof SUPPORTED_LANGUAGES[number];
 
-// 语言来源枚举
-export enum LanguageSource {
-    USER = 'user',           // 用户指定
-    URL = 'url',             // 从URL获取
-    BROWSER = 'browser',     // 从浏览器设置获取
-    DEFAULT = 'default'      // 默认语言
-}
-
-// 语言信息接口
-export interface LanguageInfo {
-    code: SupportedLanguage;  // 语言代码
-    source: LanguageSource;   // 语言来源
-}
-
 // 默认语言
 export const DEFAULT_LANGUAGE: SupportedLanguage = 'en';
 
-/**
- * 检查语言是否被支持
- * @param lang 要检查的语言代码
- * @returns 如果语言被支持返回true，否则返回false
- */
-export function isLanguageSupported(lang?: string): lang is SupportedLanguage {
-    if (!lang) return false;
-    return SUPPORTED_LANGUAGES.includes(lang as SupportedLanguage);
-}
-
-/**
- * 获取有效的语言代码
- * @param lang 用户提供的语言代码
- * @returns 有效的语言代码，如果提供的语言不支持则返回默认语言
- */
-export function getValidLanguage(lang?: string): SupportedLanguage {
-    if (lang && isLanguageSupported(lang)) {
-        return lang;
-    }
-    return DEFAULT_LANGUAGE;
-}
+export class LanguageUtil {
+    static getRelativeLink(locale: string, astro: AstroGlobal): string {
+        const debug = false;
+        const currentLocale = astro.currentLocale;
+        const originalPath = astro.originPathname;
+        const result = getRelativeLocaleUrl(locale, originalPath.replaceAll("/" + currentLocale, ""));
 
-/**
- * 从URL中提取语言代码
- * @param url 当前URL（可选）
- * @returns 从URL中提取的语言代码，如果无法提取则返回undefined
- */
-function getLanguageFromURL(url?: string): string | undefined {
-    let currentUrl = url;
+        if (debug) {
+            logger.debug(`getRelativeLink: locale=${locale}, currentPath=${originalPath}, currentLocale=${currentLocale}, result=${result}`);
+        }
 
-    if (currentUrl === undefined) {
-        if (typeof window === 'undefined') return undefined;
-        currentUrl = window.location.href;
+        return result;
     }
 
-    // 尝试从路径中提取语言代码
-    // 例如: /zh-cn/components/button
-    const pathMatch = currentUrl.match(/^\/([\w-]+)\//);
-    if (pathMatch && isLanguageSupported(pathMatch[1])) {
-        return pathMatch[1];
+    static getLanguageName(code: string | undefined): string {
+        switch (code) {
+            case 'en':
+                return 'English';
+            case 'zh-cn':
+                return '简体中文';
+            case 'zh':
+                return '中文';
+            case undefined:
+            default:
+                return 'not known';
+        }
     }
 
-    // 如果网站运行在二级目录，则从路径中提取语言代码
-    // 例如: /docs/zh-cn/components/button
-    const pathMatch2 = currentUrl.match(/^\/([^\/]+)\/([\w-]+)\//);
-    if (pathMatch2 && isLanguageSupported(pathMatch2[2])) {
-        return pathMatch2[2];
+    /**
+     * 检查语言是否被支持
+     * @param lang 要检查的语言代码
+     * @returns 如果语言被支持返回true，否则返回false
+     */
+    static isLanguageSupported(lang?: string): lang is SupportedLanguage {
+        if (!lang) return false;
+        return SUPPORTED_LANGUAGES.includes(lang as SupportedLanguage);
     }
 
-    // 尝试从查询参数中提取语言代码
-    // 例如: ?lang=zh-cn
-    const urlParams = new URLSearchParams(currentUrl.split('?')[1]);
-    const langParam = urlParams.get('lang');
-    if (langParam && isLanguageSupported(langParam)) {
-        return langParam;
+    /**
+     * 获取有效的语言代码
+     * @param lang 用户提供的语言代码
+     * @returns 有效的语言代码，如果提供的语言不支持则返回默认语言
+     */
+    static getValidLanguage(lang?: string): SupportedLanguage {
+        if (lang && this.isLanguageSupported(lang)) {
+            return lang;
+        }
+        return DEFAULT_LANGUAGE;
     }
 
-    return undefined;
-}
+    /**
+     * 从URL中提取语言代码
+     * @param url 当前URL（可选）
+     * @returns 从URL中提取的语言代码，如果无法提取则返回undefined
+     */
+    static getLanguageFromURL(url?: string): string | undefined {
+        let currentUrl = url;
+
+        if (currentUrl === undefined) {
+            if (typeof window === 'undefined') return undefined;
+            currentUrl = window.location.href;
+        }
 
-/**
- * 从浏览器设置中获取首选语言
- * @returns 从浏览器设置中获取的语言代码，如果无法获取则返回undefined
- */
-function getLanguageFromBrowser(): string | undefined {
-    if (typeof navigator === 'undefined') return undefined;
+        // 尝试从路径中提取语言代码
+        // 例如: /zh-cn/components/button
+        const pathMatch = currentUrl.match(/^\/([\w-]+)\//);
+        if (pathMatch && this.isLanguageSupported(pathMatch[1])) {
+            return pathMatch[1];
+        }
+
+        // 如果网站运行在二级目录，则从路径中提取语言代码
+        // 例如: /docs/zh-cn/components/button
+        const pathMatch2 = currentUrl.match(/^\/([^\/]+)\/([\w-]+)\//);
+        if (pathMatch2 && this.isLanguageSupported(pathMatch2[2])) {
+            return pathMatch2[2];
+        }
 
-    // 获取浏览器语言
-    const browserLang = navigator.language.toLowerCase();
+        // 尝试从查询参数中提取语言代码
+        // 例如: ?lang=zh-cn
+        const urlParams = new URLSearchParams(currentUrl.split('?')[1]);
+        const langParam = urlParams.get('lang');
+        if (langParam && this.isLanguageSupported(langParam)) {
+            return langParam;
+        }
 
-    // 检查完整匹配
-    if (isLanguageSupported(browserLang)) {
-        return browserLang;
+        return undefined;
     }
 
-    // 检查语言前缀匹配
-    // 例如: zh-TW -> zh-cn
-    const langPrefix = browserLang.split('-')[0];
-    for (const lang of SUPPORTED_LANGUAGES) {
-        if (lang.startsWith(langPrefix)) {
-            return lang;
+    /**
+     * 从浏览器设置中获取首选语言
+     * @returns 从浏览器设置中获取的语言代码，如果无法获取则返回undefined
+     */
+    static getLanguageFromBrowser(): string | undefined {
+        if (typeof navigator === 'undefined') return undefined;
+
+        // 获取浏览器语言
+        const browserLang = navigator.language.toLowerCase();
+
+        // 检查完整匹配
+        if (this.isLanguageSupported(browserLang)) {
+            return browserLang;
         }
-    }
 
-    return undefined;
-}
+        // 检查语言前缀匹配
+        // 例如: zh-TW -> zh-cn
+        const langPrefix = browserLang.split('-')[0];
+        for (const lang of SUPPORTED_LANGUAGES) {
+            if (lang.startsWith(langPrefix)) {
+                return lang;
+            }
+        }
 
-/**
- * 自动检测当前语言
- * @param url 当前URL（可选）
- * @returns 检测到的语言信息，包括语言代码和来源
- */
-function detectLanguage(url?: string): LanguageInfo {
-    // 尝试从URL中获取语言
-    const urlLang = getLanguageFromURL(url);
-    if (urlLang) {
-        return {
-            code: urlLang as SupportedLanguage,
-            source: LanguageSource.URL
-        };
+        return undefined;
     }
+    /**
+     * 获取当前语言
+     * @param userLang 用户指定的语言（可选）
+     * @param url 当前URL（可选）
+     * @returns 当前应使用的语言信息，包括语言代码和来源
+     */
+    static getCurrentLanguage(userLang?: string, url?: string): string {
+        // 如果用户指定了语言，优先使用用户指定的语言
+        if (userLang) {
+            if (this.isLanguageSupported(userLang)) {
+                return userLang as SupportedLanguage;
+            } else {
+                // 用户指定的语言不支持，使用默认语言
+                return DEFAULT_LANGUAGE;
+            }
+        }
 
-    // 尝试从浏览器设置中获取语言
-    const browserLang = getLanguageFromBrowser();
-    if (browserLang) {
-        return {
-            code: browserLang as SupportedLanguage,
-            source: LanguageSource.BROWSER
-        };
+        // 否则自动检测语言
+        return this.detectLanguage();
     }
 
-    // 如果无法检测，返回默认语言
-    return {
-        code: DEFAULT_LANGUAGE,
-        source: LanguageSource.DEFAULT
-    };
-}
+    /**
+     * 自动检测当前语言
+     * @param url 当前URL（可选）
+     * @returns 检测到的语言信息，包括语言代码和来源
+     */
+    static detectLanguage(url?: string): string {
+        // 尝试从URL中获取语言
+        const urlLang = this.getLanguageFromURL(url);
+        if (urlLang) {
+            return urlLang as SupportedLanguage;
+        }
 
-/**
- * 获取当前语言
- * @param userLang 用户指定的语言（可选）
- * @param url 当前URL（可选）
- * @returns 当前应使用的语言信息，包括语言代码和来源
- */
-export function getCurrentLanguage(userLang?: string, url?: string): LanguageInfo {
-    // 如果用户指定了语言，优先使用用户指定的语言
-    if (userLang) {
-        if (isLanguageSupported(userLang)) {
-            return {
-                code: userLang as SupportedLanguage,
-                source: LanguageSource.USER
-            };
-        } else {
-            // 用户指定的语言不支持，使用默认语言
-            return {
-                code: DEFAULT_LANGUAGE,
-                source: LanguageSource.DEFAULT
-            };
+        // 尝试从浏览器设置中获取语言
+        const browserLang = this.getLanguageFromBrowser();
+        if (browserLang) {
+            return browserLang as SupportedLanguage;
         }
-    }
 
-    // 否则自动检测语言
-    return detectLanguage();
-} 
+        // 如果无法检测，返回默认语言
+        return DEFAULT_LANGUAGE;
+    }
+}

package/dist/utils/link.ts

@@ -1,6 +1,22 @@
 import { logger } from "./logger";
 
-export default class LinkUtil {
+export class LinkUtil {
+    // 从 astro.config.ts 中获取基础路径
+    static getBaseUrl = (): string => {
+        return import.meta.env.BASE_URL
+    };
+
+    // 生成带基础路径的完整 URL
+    static createUrl = (path: string): string => {
+        const baseUrl = LinkUtil.getBaseUrl();
+        // 如果路径以 '/' 开头，去除开头的 '/'
+        if (path.startsWith('/')) {
+            path = path.substring(1);
+        }
+
+        return `${baseUrl}${path}`;
+    };
+
     /**
      * 规范化语言代码
      * @param lang - 语言代码
@@ -16,7 +32,7 @@ export default class LinkUtil {
     }
 
     static getHomeLink(lang: string): string {
-        return `/${lang}`;
+        return `${this.getBaseUrl}/${lang}`;
     }
 
     static getLessonsLink(lang: string): string {
@@ -213,4 +229,14 @@ export default class LinkUtil {
     static getLoginLink(currentOrigin: string): string {
         return `${currentOrigin}/api/login`;
     }
-}
+
+    static getActiveLink(currentLink: string, links: string[]): string {
+        let activeLink = '';
+        for (const link of links) {
+            if (currentLink.startsWith(link) && link.length > activeLink.length) {
+                activeLink = link;
+            }
+        }
+        return activeLink;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@coffic/cosy-ui",
-    "version": "0.4.7",
+    "version": "0.5.2",
     "description": "An astro component library",
     "author": {
         "name": "nookery",

package/dist/database/MetaDB.ts

@@ -1,75 +0,0 @@
-import MetaDoc from "@/models/MetaDoc";
-import { logger } from "@/utils/logger";
-import { type CollectionEntry } from "astro:content";
-import BaseDB from "./BaseDB";
-
-export const COLLECTION_NAME = 'meta' as const;
-export type MetaEntry = CollectionEntry<typeof COLLECTION_NAME>;
-
-/**
- * 元数据数据库类，用于管理网站的元数据内容集合（如"关于我们"等页面）
- * 
- * 目录结构：
- * ```
- * meta/
- * ├── zh-cn/                          # 中文内容
- * │   ├── about.md                    # 关于我们
- * │   ├── advice.md                   # 建议
- * └── en/                             # 英文内容
- *     ├── about.md
- *     ├── privacy.md
- *     └── terms.md
- * ```
- */
-class MetaDB extends BaseDB<typeof COLLECTION_NAME, MetaEntry, MetaDoc> {
-    protected collectionName = COLLECTION_NAME;
-
-    protected createDoc(entry: MetaEntry): MetaDoc {
-        return new MetaDoc(entry);
-    }
-
-    /**
-     * 获取指定文档的兄弟文档
-     * 例如：对于 'zh-cn/about'，会返回 'zh-cn' 下的文档
-     * 
-     * @param targetId - 目标文档ID
-     * @returns 返回兄弟文档数组（包括目标文档本身）
-     */
-    async getSiblings(targetId: string): Promise<MetaDoc[]> {
-        const target = await this.find(targetId);
-        if (!target) {
-            return [];
-        }
-        const docs = await this.getDocsByDepth(2);
-        return docs.filter(doc => doc.getLang() === target.getLang());
-    }
-
-    /**
-     * 获取用于 Astro 静态路由生成的路径参数，专门配合 [lang]/meta/[slug].astro 使用
-     * 
-     * @returns 返回路径参数数组
-     */
-    async getStaticPaths() {
-        const debug = false;
-        const docs = await this.getDescendantDocs('');
-
-        const paths = docs.map((doc) => {
-            return {
-                params: {
-                    lang: doc.getLang(),
-                    slug: doc.getSlug(),
-                },
-            };
-        });
-
-        if (debug) {
-            logger.array('所有元数据文档的路径', paths);
-        }
-
-        return paths;
-    }
-}
-
-// 创建并导出单例实例
-const metaDB = new MetaDB();
-export default metaDB;

package/dist/i18n/Language.ts

@@ -1,25 +0,0 @@
-export type LangCode = 'zh-cn' | 'en';
-
-export default class Language {
-    code: LangCode;
-
-    constructor(code: LangCode) {
-        this.code = code;
-    }
-
-    static fromString(lang: string): Language {
-        return new Language(lang as LangCode);
-    }
-
-    isChinese(): boolean {
-        return this.code === 'zh-cn';
-    }
-
-    isEnglish(): boolean {
-        return this.code === 'en';
-    }
-
-    static isCodeValid(code: string): boolean {
-        return code === 'zh-cn' || code === 'en';
-    }
-}

package/dist/i18n/ui.ts

@@ -1,18 +0,0 @@
-export const languages = {
-    en: 'English',
-    'zh-cn': '简体中文',
-};
-
-export const defaultLang = 'zh-cn';
-
-export const ui = {
-    en: {
-        'nav.home': 'Home',
-        'nav.about': 'About',
-        'nav.twitter': 'Twitter',
-    },
-    'zh-cn': {
-        'nav.home': '首页',
-        'nav.about': '关于',
-    },
-} as const;

package/dist/i18n/utils.ts

@@ -1,54 +0,0 @@
-import { ui, defaultLang } from './ui';
-
-export function getLangFromUrl(url: URL) {
-    const [, lang] = url.pathname.split('/');
-    if (lang in ui) return lang as keyof typeof ui;
-    return defaultLang;
-}
-
-export function t(lang: string, key: keyof typeof ui[typeof defaultLang]) {
-    return ui[lang in ui ? lang as keyof typeof ui : defaultLang][key];
-}
-
-export const normalizeLang = (lang: string) => {
-    if (lang === 'zh-CN') {
-        return 'zh-cn';
-    }
-    return lang;
-}
-
-export const getLangFromSlug = (slug: string) => {
-    let lang = slug.split('/')[0];
-
-    return normalizeLang(lang);
-}
-
-export const getLangFromPathname = (pathname: string) => {
-    // 去除开头的 /
-    pathname = pathname.slice(1);
-
-    let lang = pathname.split('/')[0];
-
-    return normalizeLang(lang);
-}
-
-export const isValidLang = (lang: string) => {
-    return ['zh-cn', 'en'].includes(lang);
-}
-
-export const getLang = (...args: string[]) => {
-    const debug = false
-
-    if (debug) {
-        // eslint-disable-next-line no-console
-        console.log('getLang', args);
-    }
-
-    for (const arg of args) {
-        let normalizedLang = normalizeLang(arg);
-        if (isValidLang(normalizedLang)) {
-            return normalizedLang;
-        }
-    }
-    return 'zh-cn';
-}