md2x 0.1.0

package/dist/types/src/types/theme.d.ts

@@ -0,0 +1,234 @@
+/**
+ * Theme Type Definitions
+ * Types for theme system
+ */
+/**
+ * Color scheme configuration
+ * Manages all color-related settings for a theme
+ */
+export interface ColorScheme {
+    id: string;
+    name: string;
+    name_en: string;
+    description: string;
+    description_en?: string;
+    text: {
+        primary: string;
+        secondary: string;
+        muted: string;
+    };
+    accent: {
+        link: string;
+        linkHover: string;
+    };
+    background: {
+        code: string;
+    };
+    blockquote: {
+        border: string;
+    };
+    table: {
+        border: string;
+        headerBackground: string;
+        headerText: string;
+        zebraEven: string;
+        zebraOdd: string;
+    };
+    /** Optional per-heading colors for colorful themes like rainbow */
+    headings?: {
+        h1?: string;
+        h2?: string;
+        h3?: string;
+        h4?: string;
+        h5?: string;
+        h6?: string;
+    };
+}
+/**
+ * Heading style configuration (font-related properties only)
+ * Layout properties (fontSize, alignment, spacing) are in LayoutScheme
+ */
+export interface HeadingConfig {
+    fontFamily?: string;
+    fontWeight?: string;
+}
+/**
+ * Font scheme configuration (font-related properties only)
+ * Layout properties (fontSize, lineHeight, spacing) are in LayoutScheme
+ * Color properties are in ColorScheme
+ */
+export interface FontScheme {
+    body: {
+        fontFamily: string;
+    };
+    headings: HeadingsConfig;
+    code: {
+        fontFamily: string;
+    };
+}
+/**
+ * Headings font configuration
+ * Top-level fontFamily/fontWeight apply to all headings (h1-h6)
+ * Individual h1-h6 configs can override the defaults
+ */
+export interface HeadingsConfig {
+    /** Default font family for all headings (h1-h6) */
+    fontFamily?: string;
+    /** Default font weight for all headings (h1-h6) */
+    fontWeight?: string;
+    /** Individual heading overrides */
+    h1?: HeadingConfig;
+    h2?: HeadingConfig;
+    h3?: HeadingConfig;
+    h4?: HeadingConfig;
+    h5?: HeadingConfig;
+    h6?: HeadingConfig;
+    /** Allow dynamic access by level name */
+    [key: string]: HeadingConfig | string | undefined;
+}
+/**
+ * Border configuration (layout properties only)
+ * Color is from ColorScheme
+ */
+export interface BorderConfig {
+    style: string;
+    width: string;
+}
+/**
+ * Table style configuration (layout properties only)
+ * Color properties are in ColorScheme
+ */
+export interface TableStyleConfig {
+    border?: {
+        all?: BorderConfig;
+        headerTop?: BorderConfig;
+        headerBottom?: BorderConfig;
+        rowBottom?: BorderConfig;
+        lastRowBottom?: BorderConfig;
+    };
+    header: {
+        fontWeight?: string;
+    };
+    cell: {
+        padding: string;
+    };
+    zebra?: {
+        enabled: boolean;
+    };
+}
+/**
+ * Code theme color configuration
+ */
+export interface CodeThemeConfig {
+    colors: Record<string, string>;
+    foreground?: string;
+}
+/**
+ * Layout scheme heading configuration
+ */
+export interface LayoutHeadingConfig {
+    fontSize: string;
+    spacingBefore: string;
+    spacingAfter: string;
+    alignment?: 'left' | 'center' | 'right';
+}
+/**
+ * Layout scheme block configuration
+ */
+export interface LayoutBlockConfig {
+    spacingBefore?: string;
+    spacingAfter?: string;
+    paddingVertical?: string;
+    paddingHorizontal?: string;
+}
+/**
+ * Layout scheme configuration (absolute pt values)
+ */
+export interface LayoutScheme {
+    id: string;
+    name: string;
+    name_en: string;
+    description: string;
+    description_en?: string;
+    body: {
+        fontSize: string;
+        lineHeight: number;
+    };
+    headings: {
+        h1: LayoutHeadingConfig;
+        h2: LayoutHeadingConfig;
+        h3: LayoutHeadingConfig;
+        h4: LayoutHeadingConfig;
+        h5: LayoutHeadingConfig;
+        h6: LayoutHeadingConfig;
+    };
+    code: {
+        fontSize: string;
+    };
+    blocks: {
+        paragraph: LayoutBlockConfig;
+        list: LayoutBlockConfig;
+        listItem: LayoutBlockConfig;
+        blockquote: LayoutBlockConfig;
+        codeBlock: LayoutBlockConfig;
+        table: LayoutBlockConfig;
+        horizontalRule: LayoutBlockConfig;
+    };
+}
+/**
+ * Complete theme definition (loaded from theme files)
+ */
+export interface Theme {
+    id: string;
+    name: string;
+    name_en?: string;
+    description?: string;
+    description_en?: string;
+    author?: string;
+    version?: string;
+    fontScheme: FontScheme;
+    layoutScheme: string;
+    colorScheme: string;
+    tableStyle: string;
+    codeTheme: string;
+}
+/**
+ * Theme definition from registry
+ */
+export interface ThemeDefinition {
+    id: string;
+    name: string;
+    name_en: string;
+    description?: string;
+    description_en?: string;
+    category: string;
+    featured?: boolean;
+}
+/**
+ * Theme category info
+ */
+export interface ThemeCategoryInfo {
+    name: string;
+    name_en: string;
+    order?: number;
+}
+/**
+ * Theme registry structure
+ */
+export interface ThemeRegistry {
+    categories: Record<string, ThemeCategoryInfo>;
+    themes: Array<{
+        id: string;
+        file: string;
+        category: string;
+        featured?: boolean;
+    }>;
+}
+/**
+ * Theme registry info (cached version)
+ */
+export interface ThemeRegistryInfo {
+    id: string;
+    name: string;
+    category: string;
+}

package/dist/types/src/types/toolbar.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Toolbar Type Definitions
+ * Types for UI toolbar
+ */
+import type { TranslateFunction, EscapeHtmlFunction, FileState } from './core';
+import type { DocxExporter } from './docx';
+/**
+ * Layout configuration
+ */
+export interface LayoutConfig {
+    maxWidth: string;
+    icon: string;
+    title: string;
+}
+/**
+ * Toolbar manager options
+ */
+export interface ToolbarManagerOptions {
+    translate: TranslateFunction;
+    escapeHtml: EscapeHtmlFunction;
+    saveFileState: (state: FileState) => void;
+    getFileState: () => Promise<FileState>;
+    rawMarkdown: string;
+    docxExporter: DocxExporter;
+    cancelScrollRestore: () => void;
+    updateActiveTocItem: () => void;
+    toolbarPrintDisabledTitle: string;
+    /** Called before zoom changes to lock scroll position */
+    onBeforeZoom?: () => void;
+}
+/**
+ * Generate toolbar HTML options
+ */
+export interface GenerateToolbarHTMLOptions {
+    translate: TranslateFunction;
+    escapeHtml: EscapeHtmlFunction;
+    initialTocClass: string;
+    initialMaxWidth: string;
+    initialZoom: number;
+}
+/**
+ * Toolbar manager instance interface
+ */
+export interface ToolbarManagerInstance {
+    layoutIcons: Record<string, string>;
+    layoutConfigs: Record<string, LayoutConfig>;
+    applyZoom: (newLevel: number, saveState?: boolean) => void;
+    getZoomLevel: () => number;
+    setInitialZoom: (level: number) => void;
+    initializeToolbar: () => void;
+    setupToolbarButtons: () => Promise<void>;
+    setupKeyboardShortcuts: () => void;
+}

package/dist/types/src/ui/popup/i18n-helpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Internationalization helpers for popup
+ */
+/**
+ * Translate a key to localized string
+ * @param key - Translation key
+ * @param substitutions - Optional substitutions
+ * @returns Translated string
+ */
+export declare const translate: (key: string, substitutions?: string | string[]) => string;
+/**
+ * Get the current UI locale
+ * @returns Locale code (e.g., 'en', 'zh-CN')
+ */
+export declare const getUiLocale: () => string;
+/**
+ * Apply internationalized text to DOM elements
+ * Elements with data-i18n attribute will have their text content replaced
+ * Elements with data-i18n-attr attribute will have specified attributes set
+ */
+export declare const applyI18nText: () => void;

package/dist/types/src/ui/popup/settings-tab.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Settings Tab Manager
+ * Manages settings panel functionality including themes and cache settings
+ */
+import type { EmojiStyle } from '../../types/docx.js';
+/**
+ * Supported file extensions
+ */
+interface SupportedExtensions {
+    mermaid: boolean;
+    vega: boolean;
+    vegaLite: boolean;
+    dot: boolean;
+    infographic: boolean;
+}
+/**
+ * Frontmatter display mode
+ */
+export type FrontmatterDisplay = 'hide' | 'table' | 'raw';
+/**
+ * User settings structure
+ */
+interface Settings {
+    maxCacheItems: number;
+    preferredLocale: string;
+    docxHrAsPageBreak: boolean;
+    docxEmojiStyle?: EmojiStyle;
+    supportedExtensions?: SupportedExtensions;
+    frontmatterDisplay?: FrontmatterDisplay;
+}
+/**
+ * Settings tab manager options
+ */
+interface SettingsTabManagerOptions {
+    showMessage: (message: string, type: 'success' | 'error' | 'info') => void;
+    showConfirm: (title: string, message: string) => Promise<boolean>;
+    onReloadCacheData?: () => void;
+}
+/**
+ * Settings tab manager interface
+ */
+export interface SettingsTabManager {
+    loadSettings: () => Promise<void>;
+    loadSettingsUI: () => void;
+    saveSettings: () => Promise<void>;
+    resetSettings: () => Promise<void>;
+    getSettings: () => Settings;
+    loadThemes: () => Promise<void>;
+}
+/**
+ * Create a settings tab manager
+ * @param options - Configuration options
+ * @returns Settings tab manager instance
+ */
+export declare function createSettingsTabManager({ showMessage, showConfirm, onReloadCacheData }: SettingsTabManagerOptions): SettingsTabManager;
+export {};

package/dist/types/src/ui/popup/storage-helper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Storage helper using message channel to background
+ * Works with both Chrome (MV3) and Firefox (MV2)
+ */
+/**
+ * Get items from local storage via background
+ */
+export declare function storageGet(keys: string[]): Promise<Record<string, unknown>>;
+/**
+ * Set items to local storage via background
+ */
+export declare function storageSet(items: Record<string, unknown>): Promise<void>;

package/dist/types/src/utils/fetch-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Fetch JSON from asset path
+ * @param path - Asset path (can be URL or relative path)
+ * @returns Parsed JSON
+ */
+export declare function fetchJSON<T = unknown>(path: string): Promise<T>;
+/**
+ * Fetch text content from asset path
+ * @param path - Asset path (can be URL or relative path)
+ * @returns Text content
+ */
+export declare function fetchText(path: string): Promise<string>;

package/dist/types/src/utils/hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Simple hash utilities for content-based identification
+ */
+/**
+ * Generate a simple hash code from a string.
+ * Uses djb2 algorithm - fast and produces good distribution.
+ * @param str - String to hash
+ * @returns Hash code as hex string
+ */
+export declare function hashCode(str: string): string;
+/**
+ * Generate a content hash combining type and content.
+ * @param type - Plugin type (e.g., 'mermaid', 'vega')
+ * @param content - Source content
+ * @returns Combined hash string
+ */
+export declare function generateContentHash(type: string, content: string): string;

package/dist/types/src/utils/html-sanitizer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * HTML Sanitizer
+ *
+ * Shared utility for sanitizing HTML content and checking if it has meaningful content
+ */
+/**
+ * Sanitize HTML content to remove dangerous elements and attributes
+ * @param html - Raw HTML content
+ * @returns Sanitized HTML
+ */
+export declare function sanitizeHtml(html: string): string;
+/**
+ * Check if sanitized HTML has any meaningful content
+ * @param sanitizedHtml - Sanitized HTML string
+ * @returns True if has content, false if empty or only whitespace
+ */
+export declare function hasHtmlContent(sanitizedHtml: string): boolean;
+/**
+ * Sanitize HTML and check if it has content in one step
+ * @param html - Raw HTML content
+ * @returns Sanitized HTML and content check result
+ */
+export declare function sanitizeAndCheck(html: string): {
+    sanitized: string;
+    hasContent: boolean;
+};

package/dist/types/src/utils/localization.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Localization manager providing user-selectable locales.
+ * Note: Comments in English per instructions.
+ */
+/**
+ * Locale message entry structure
+ */
+interface LocaleMessageEntry {
+    message: string;
+    description?: string;
+    placeholders?: Record<string, {
+        content: string;
+        example?: string;
+    }>;
+}
+/**
+ * Locale messages object
+ */
+interface LocaleMessages {
+    [key: string]: LocaleMessageEntry;
+}
+/**
+ * Storage settings structure
+ */
+interface StorageSettings {
+    preferredLocale?: string;
+    [key: string]: unknown;
+}
+declare const DEFAULT_SETTING_LOCALE = "auto";
+declare class LocalizationManager {
+    private messages;
+    private locale;
+    private ready;
+    private loadingPromise;
+    private fallbackMessages;
+    constructor();
+    init(): Promise<void>;
+    getStorageSettings(): Promise<StorageSettings | null>;
+    setPreferredLocale(locale: string): Promise<void>;
+    ensureFallbackMessages(): Promise<void>;
+    loadLocale(locale: string): Promise<void>;
+    fetchLocaleData(locale: string): Promise<LocaleMessages | null>;
+    translate(key: string, substitutions?: string | string[]): string;
+    lookupMessage(source: LocaleMessages | null, key: string, substitutions?: string | string[]): string | null;
+    getLocale(): string;
+}
+declare const Localization: LocalizationManager;
+export default Localization;
+export { DEFAULT_SETTING_LOCALE };

package/dist/types/src/utils/theme-manager.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Theme Manager for Markdown Viewer Extension
+ * Handles loading, applying, and managing themes
+ */
+import type { Theme } from '../types/theme';
+/**
+ * Font configuration for a single font
+ */
+interface FontConfig {
+    webFallback: string;
+    docx?: {
+        ascii: string;
+        eastAsia: string;
+    };
+}
+/**
+ * Font configuration file structure
+ */
+export interface FontConfigFile {
+    fonts: Record<string, FontConfig>;
+}
+/**
+ * DOCX font configuration
+ */
+interface DocxFont {
+    ascii: string;
+    eastAsia: string;
+    hAnsi: string;
+    cs: string;
+}
+/**
+ * Category info in registry
+ */
+interface CategoryInfo {
+    name: string;
+    name_en?: string;
+    description?: string;
+}
+/**
+ * Theme metadata
+ */
+interface ThemeMetadata {
+    id: string;
+    name: string;
+    name_en?: string;
+    description?: string;
+    description_en?: string;
+    category: string;
+    featured: boolean;
+}
+/**
+ * Category with themes
+ */
+interface CategoryWithThemes extends CategoryInfo {
+    themes: ThemeMetadata[];
+}
+/**
+ * Theme Manager Class
+ */
+declare class ThemeManager {
+    private currentTheme;
+    private fontConfig;
+    private registry;
+    private initialized;
+    constructor();
+    /**
+     * Initialize theme manager with data from Flutter
+     * Used on mobile platform where Flutter loads assets and sends to WebView
+     * @param fontConfig - Font configuration object
+     * @param theme - Theme object
+     */
+    initializeWithData(fontConfig: FontConfigFile, theme?: Theme | null): void;
+    /**
+     * Initialize theme manager by loading font config and registry
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get font config for a given font name
+     * @param fontName - Font name (e.g., 'SimSun', 'Times New Roman')
+     * @returns Font fallback chain (CSS font-family string)
+     */
+    getFontFallback(fontName: string): string;
+    /**
+     * Build complete font family stack
+     * @param fontName - Font name
+     * @returns Complete CSS font-family string
+     */
+    buildFontFamily(fontName: string): string;
+    /**
+     * Get DOCX font configuration for a given font name
+     * @param fontName - Font name
+     * @returns Complete DOCX font object with ascii, eastAsia, hAnsi, cs properties
+     */
+    getDocxFont(fontName: string): DocxFont;
+    /**
+     * Load a theme configuration from a JSON file
+     * @param themeId - Theme ID (e.g., 'default', 'academic')
+     * @returns Theme configuration object
+     */
+    loadTheme(themeId: string): Promise<Theme>;
+    /**
+     * Load theme from storage
+     * @returns Theme ID
+     */
+    loadSelectedTheme(): Promise<string>;
+    /**
+     * Save selected theme to storage
+     * @param themeId - Theme ID to save
+     */
+    saveSelectedTheme(themeId: string): Promise<void>;
+    /**
+     * Get current theme configuration
+     * @returns Current theme object
+     */
+    getCurrentTheme(): Theme | null;
+    /**
+     * Convert point size to pixels (for CSS)
+     * @param ptSize - Size in points (e.g., '12pt')
+     * @returns Size in pixels (e.g., '16px')
+     */
+    ptToPx(ptSize: string): string;
+    /**
+     * Convert point size to half-points (for DOCX)
+     * @param ptSize - Size in points (e.g., '12pt')
+     * @returns Size in half-points (e.g., 24)
+     */
+    ptToHalfPt(ptSize: string): number;
+    /**
+     * Convert point size to twips (for DOCX spacing)
+     * @param ptSize - Size in points (e.g., '13pt')
+     * @returns Size in twips (e.g., 260)
+     */
+    ptToTwips(ptSize: string): number;
+    /**
+     * Get all available themes from registry
+     * @returns List of theme metadata
+     */
+    getAvailableThemes(): Promise<ThemeMetadata[]>;
+    /**
+     * Get themes grouped by category
+     * @returns Themes grouped by category
+     */
+    getThemesByCategory(): Promise<Record<string, CategoryWithThemes>>;
+    /**
+     * Switch to a different theme
+     * @param themeId - Theme ID to switch to
+     * @returns The loaded theme
+     */
+    switchTheme(themeId: string): Promise<Theme>;
+}
+declare const themeManager: ThemeManager;
+export default themeManager;