md2x 0.1.0

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

@@ -0,0 +1,142 @@
+/**
+ * Messaging Type Definitions
+ *
+ * NOTE: This file defines the type-level contract only.
+ * Runtime implementations live under src/messaging/.
+ */
+import type { FileState } from './core';
+import type { RendererThemeConfig, RenderResult } from './render';
+export declare const RenderMessageType: {
+    readonly RENDER_DIAGRAM: "RENDER_DIAGRAM";
+    readonly SET_THEME_CONFIG: "SET_THEME_CONFIG";
+    readonly PING: "PING";
+    readonly READY: "READY";
+    readonly READY_ACK: "READY_ACK";
+};
+export type RenderMessageType = typeof RenderMessageType[keyof typeof RenderMessageType];
+export declare const ServiceMessageType: {
+    readonly STORAGE_GET: "STORAGE_GET";
+    readonly STORAGE_SET: "STORAGE_SET";
+    readonly STORAGE_REMOVE: "STORAGE_REMOVE";
+    readonly OFFSCREEN_READY: "OFFSCREEN_READY";
+    readonly OFFSCREEN_DOM_READY: "OFFSCREEN_DOM_READY";
+    readonly OFFSCREEN_ERROR: "OFFSCREEN_ERROR";
+    readonly LOCALE_CHANGED: "LOCALE_CHANGED";
+    readonly THEME_CHANGED: "THEME_CHANGED";
+    readonly CACHE_OPERATION: "CACHE_OPERATION";
+    readonly FILE_STATE_OPERATION: "FILE_STATE_OPERATION";
+    readonly SCROLL_OPERATION: "SCROLL_OPERATION";
+    readonly UPLOAD_OPERATION: "UPLOAD_OPERATION";
+    readonly DOCX_DOWNLOAD_FINALIZE: "DOCX_DOWNLOAD_FINALIZE";
+    readonly FETCH_ASSET: "FETCH_ASSET";
+    readonly INJECT_CONTENT_SCRIPT: "INJECT_CONTENT_SCRIPT";
+    readonly READ_LOCAL_FILE: "READ_LOCAL_FILE";
+    readonly DOWNLOAD_FILE: "DOWNLOAD_FILE";
+};
+export type ServiceMessageType = typeof ServiceMessageType[keyof typeof ServiceMessageType];
+export declare const CommonMessageType: {
+    readonly RESPONSE: "RESPONSE";
+};
+export type CommonMessageType = typeof CommonMessageType[keyof typeof CommonMessageType];
+export type AnyMessageType = RenderMessageType | ServiceMessageType | CommonMessageType;
+export type RenderPayloadMap = {
+    RENDER_DIAGRAM: {
+        renderType: string;
+        input: string | object;
+        themeConfig?: RendererThemeConfig | null;
+    };
+    SET_THEME_CONFIG: {
+        config: RendererThemeConfig;
+    };
+    PING: Record<string, never>;
+    READY: Record<string, never>;
+    READY_ACK: Record<string, never>;
+};
+export type ServicePayloadMap = {
+    STORAGE_GET: {
+        keys: string | string[];
+    };
+    STORAGE_SET: {
+        items: Record<string, unknown>;
+    };
+    STORAGE_REMOVE: {
+        keys: string | string[];
+    };
+    OFFSCREEN_READY: Record<string, never>;
+    OFFSCREEN_DOM_READY: Record<string, never>;
+    OFFSCREEN_ERROR: {
+        error: string;
+        filename?: string;
+        lineno?: number;
+    };
+    LOCALE_CHANGED: {
+        locale: string;
+    };
+    THEME_CHANGED: {
+        themeId: string;
+    };
+    CACHE_OPERATION: {
+        operation: 'get' | 'set' | 'clear' | 'getStats' | 'delete';
+        key?: string;
+        value?: unknown;
+        dataType?: string;
+    };
+    FILE_STATE_OPERATION: {
+        operation: 'get' | 'set' | 'clear';
+        url: string;
+        state?: FileState;
+    };
+    SCROLL_OPERATION: {
+        operation: 'get' | 'clear';
+        url: string;
+    };
+    UPLOAD_OPERATION: {
+        operation: 'init' | 'chunk' | 'finalize' | 'abort';
+        purpose?: string;
+        encoding?: 'text' | 'base64';
+        expectedSize?: number;
+        metadata?: Record<string, unknown>;
+        chunkSize?: number;
+        token?: string;
+        chunk?: string;
+    };
+    DOCX_DOWNLOAD_FINALIZE: {
+        token: string;
+    };
+    FETCH_ASSET: {
+        path: string;
+    };
+    INJECT_CONTENT_SCRIPT: {
+        url: string;
+    };
+    READ_LOCAL_FILE: {
+        filePath: string;
+        binary?: boolean;
+    };
+    DOWNLOAD_FILE: {
+        filename: string;
+        data: string;
+        mimeType?: string;
+    };
+};
+export type RequestEnvelope<TType extends AnyMessageType, TPayload> = {
+    id: string;
+    type: TType;
+    payload: TPayload;
+    timestamp: number;
+    source?: string;
+};
+export type ResponseEnvelope = {
+    type: 'RESPONSE';
+    requestId: string;
+    ok: boolean;
+    data?: unknown;
+    error?: {
+        code?: string;
+        message: string;
+        details?: unknown;
+    };
+};
+export type RenderRequestEnvelope<T extends RenderMessageType> = RequestEnvelope<T, T extends keyof RenderPayloadMap ? RenderPayloadMap[T] : unknown>;
+export type ServiceRequestEnvelope<T extends ServiceMessageType> = RequestEnvelope<T, T extends keyof ServicePayloadMap ? ServicePayloadMap[T] : unknown>;
+export type RenderResponseData = RenderResult;

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

@@ -0,0 +1,203 @@
+/**
+ * Platform Type Definitions
+ * Types for platform abstraction layer
+ */
+import type { RendererThemeConfig, RenderResult } from './render';
+import type { CacheStats, SimpleCacheStats } from './cache';
+import type { FileState } from './core';
+export type PlatformType = 'chrome' | 'firefox' | 'mobile' | 'vscode' | 'node';
+/**
+ * Platform message API
+ */
+export interface PlatformMessageAPI {
+    send(message: Record<string, unknown>): Promise<unknown>;
+    addListener(handler: (message: unknown) => void): void;
+}
+/**
+ * Platform storage API
+ */
+export interface PlatformStorageAPI {
+    get(keys: string[]): Promise<Record<string, unknown>>;
+    set(items: Record<string, unknown>): Promise<void>;
+}
+/**
+ * Platform resource API
+ */
+export interface PlatformResourceAPI {
+    fetch(path: string): Promise<string>;
+    getURL(path: string): string;
+}
+/**
+ * Platform i18n API
+ */
+export interface PlatformI18nAPI {
+    translate(key: string, substitutions?: string | string[]): string;
+    getUILanguage(): string;
+}
+/**
+ * Platform bridge API (mobile WebView ↔ host)
+ */
+export interface PlatformBridgeAPI {
+    sendRequest<T = unknown>(type: string, payload: unknown): Promise<T>;
+    postMessage(type: string, payload: unknown): void;
+    addListener(handler: (message: unknown) => void): () => void;
+}
+/**
+ * Download options
+ */
+export interface DownloadOptions {
+    saveAs?: boolean;
+    mimeType?: string;
+    onProgress?: (progress: {
+        uploaded: number;
+        total: number;
+    }) => void;
+}
+/**
+ * Cache service interface
+ */
+export interface CacheService {
+    init(): Promise<void>;
+    calculateHash(text: string): Promise<string>;
+    generateKey(content: string, type: string, themeConfig?: RendererThemeConfig | null): Promise<string>;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown, type?: string): Promise<boolean>;
+    clear(): Promise<boolean>;
+    getStats(): Promise<CacheStats | SimpleCacheStats | null>;
+}
+/**
+ * Renderer service interface
+ */
+export interface RendererService {
+    init(): Promise<void>;
+    setThemeConfig(config: RendererThemeConfig): void;
+    getThemeConfig(): RendererThemeConfig | null;
+    render(type: string, content: string | object): Promise<RenderResult>;
+}
+/**
+ * Storage service interface
+ */
+export interface StorageService {
+    get(keys: string[]): Promise<Record<string, unknown>>;
+    set(data: Record<string, unknown>): Promise<void>;
+    remove(keys: string[]): Promise<void>;
+}
+/**
+ * File service interface
+ */
+export interface FileService {
+    download(blob: Blob | string, filename: string, options?: DownloadOptions): Promise<void>;
+}
+/**
+ * File state service interface
+ */
+export interface FileStateService {
+    get(url: string): Promise<FileState>;
+    set(url: string, state: FileState): void;
+    clear(url: string): Promise<void>;
+}
+/**
+ * Resource service interface
+ */
+export interface ResourceService {
+    fetch(path: string): Promise<string>;
+    getURL(path: string): string;
+}
+/**
+ * I18n service interface
+ */
+export interface I18nService {
+    translate(key: string, substitutions?: string | string[]): string;
+    getUILanguage(): string;
+    setLocale?(locale: string): Promise<void>;
+}
+/**
+ * Message service interface
+ */
+export interface MessageService {
+    send(message: Record<string, unknown>): Promise<unknown>;
+    addListener(handler: (message: unknown) => void): void;
+}
+/**
+ * Read file options
+ */
+export interface ReadFileOptions {
+    /** If true, returns base64-encoded content for binary files */
+    binary?: boolean;
+}
+/**
+ * Unified document service for file operations and document context.
+ * Replaces scattered platform detection and file reading logic.
+ *
+ * Platform implementations:
+ * - Chrome/Firefox: Uses window.location.href as base, READ_LOCAL_FILE message
+ * - VS Code: Uses host-provided paths, READ_LOCAL_FILE/FETCH_REMOTE_IMAGE messages
+ * - Mobile: Uses Flutter bridge, READ_RELATIVE_FILE message
+ */
+export interface DocumentService {
+    /** Absolute path to the current document (e.g., /Users/x/doc.md) */
+    readonly documentPath: string;
+    /** Directory containing the document (e.g., /Users/x/) */
+    readonly documentDir: string;
+    /** Base URL for resolving relative paths (platform-specific) */
+    readonly baseUrl: string;
+    /** Whether relative image paths need URI rewriting (VS Code only) */
+    readonly needsUriRewrite: boolean;
+    /**
+     * Read a local file by absolute path.
+     * @param absolutePath - Full path to the file
+     * @param options - Read options (binary mode, etc.)
+     * @returns File content (string or base64 if binary)
+     */
+    readFile(absolutePath: string, options?: ReadFileOptions): Promise<string>;
+    /**
+     * Read a file relative to the current document.
+     * @param relativePath - Path relative to documentDir
+     * @param options - Read options (binary mode, etc.)
+     * @returns File content (string or base64 if binary)
+     */
+    readRelativeFile(relativePath: string, options?: ReadFileOptions): Promise<string>;
+    /**
+     * Fetch a remote resource (HTTP/HTTPS).
+     * On VS Code, this bypasses CSP by proxying through the host.
+     * @param url - Remote URL
+     * @returns Binary content as Uint8Array
+     */
+    fetchRemote(url: string): Promise<Uint8Array>;
+    /**
+     * Resolve a relative path to an absolute path.
+     * @param relativePath - Path relative to documentDir
+     * @returns Absolute file path
+     */
+    resolvePath(relativePath: string): string;
+    /**
+     * Convert a local file path to a URL suitable for the current platform.
+     * - Chrome/Firefox: file:// URL
+     * - VS Code: vscode-webview-resource:// URL
+     * - Mobile: file:// URL
+     */
+    toResourceUrl(absolutePath: string): string;
+    /**
+     * Set the current document path.
+     * Called by the platform when a new document is opened.
+     * @param path - Absolute path to the document
+     * @param baseUrl - Optional base URL for resource loading (VS Code)
+     */
+    setDocumentPath(path: string, baseUrl?: string): void;
+}
+/**
+ * Complete platform API interface
+ */
+export interface PlatformAPI {
+    platform: PlatformType;
+    cache: CacheService;
+    renderer: RendererService;
+    storage: StorageService;
+    file: FileService;
+    fileState: FileStateService;
+    resource: ResourceService;
+    i18n: I18nService;
+    message: MessageService;
+    /** Unified document service for file operations (Phase 1) */
+    document?: DocumentService;
+}

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

@@ -0,0 +1,101 @@
+/**
+ * Plugin Type Definitions
+ * Types for plugin system and async task queue
+ */
+import type { TranslateFunction } from './core';
+/**
+ * Task status enumeration
+ */
+export type TaskStatus = 'ready' | 'fetching' | 'error' | 'completed';
+/**
+ * Task data
+ */
+export interface TaskData {
+    id: string;
+    code?: string;
+    sourceHash: string;
+    [key: string]: unknown;
+}
+/**
+ * Async task object
+ */
+export interface AsyncTaskObject {
+    id: string;
+    callback: (data: TaskData) => Promise<void>;
+    data: TaskData;
+    type: string;
+    status: TaskStatus;
+    error: Error | null;
+    setReady: () => void;
+    setError: (error: Error) => void;
+}
+/**
+ * Placeholder result for async task
+ */
+export interface PlaceholderResult {
+    type: 'html';
+    value: string;
+}
+/**
+ * Async task registration result
+ */
+export interface AsyncTaskResult {
+    task: AsyncTaskObject;
+    placeholder: PlaceholderResult;
+}
+/**
+ * Async task plugin interface
+ */
+export interface AsyncTaskPlugin {
+    type: string;
+    isInline: () => boolean;
+}
+/**
+ * Async task queue manager interface
+ */
+export interface AsyncTaskQueueManager {
+    asyncTask: (callback: (data: TaskData) => Promise<void>, data?: Record<string, unknown>, plugin?: AsyncTaskPlugin | null, translate?: TranslateFunction | null, initialStatus?: TaskStatus) => AsyncTaskResult;
+    processAsyncTasks: (translate: TranslateFunction, showProcessingIndicator: () => void, hideProcessingIndicator: () => void, updateProgress: (completed: number, total: number) => void) => Promise<void>;
+    getQueueLength: () => number;
+}
+/**
+ * AST Node for markdown processing
+ */
+export interface ASTNode {
+    type: string;
+    value?: string;
+    lang?: string;
+    meta?: string;
+    url?: string;
+    alt?: string;
+    title?: string;
+    children?: ASTNode[];
+    data?: unknown;
+}
+/**
+ * Plugin interface
+ */
+export interface IPlugin {
+    type: string;
+    match(node: ASTNode): boolean;
+    transform(node: ASTNode, context: unknown): string;
+    render?(data: unknown): Promise<string>;
+    isInline?(): boolean;
+    createTaskData?(content: string): TaskData;
+}
+/**
+ * Renderer interface used by plugins
+ */
+export interface PluginRenderer {
+    render(type: string, content: string | object): Promise<PluginRenderResult | null>;
+}
+/**
+ * Render result from plugin renderer
+ */
+export interface PluginRenderResult {
+    base64?: string;
+    width: number;
+    height: number;
+    format: string;
+    error?: string;
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Render Type Definitions
+ * Types for rendering system (diagrams, charts, SVG, etc.)
+ */
+/**
+ * Render result from renderers
+ */
+export interface RenderResult {
+    base64?: string;
+    width: number;
+    height: number;
+    format: string;
+    success?: boolean;
+    error?: string;
+}
+/**
+ * Render result type enumeration
+ */
+export type RenderResultType = 'image' | 'text' | 'error' | 'empty';
+/**
+ * Unified render result content
+ */
+export interface RenderResultContent {
+    data?: Uint8Array;
+    base64?: string;
+    text?: string;
+    width?: number;
+    height?: number;
+    format?: string;
+}
+/**
+ * Unified render result display options
+ */
+export interface RenderResultDisplay {
+    inline: boolean;
+    alignment: 'left' | 'center' | 'right';
+}
+/**
+ * Unified render result (used by plugin system)
+ */
+export interface UnifiedRenderResult {
+    type: RenderResultType;
+    content: RenderResultContent;
+    display: RenderResultDisplay;
+}
+/**
+ * Theme configuration for renderers
+ * This is a simplified config passed to render workers
+ */
+export interface RendererThemeConfig {
+    fontFamily?: string;
+    fontSize?: number;
+    background?: string;
+    foreground?: string;
+    /** Diagram rendering style: 'normal' or 'handDrawn' */
+    diagramStyle?: 'normal' | 'handDrawn';
+}