@eternalheart/angular-file-preview 1.6.5

package/lib/renderers/Msg/index.d.ts

@@ -0,0 +1,47 @@
+import type { FieldsData } from '@kenjiuno/msgreader';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class MsgRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly sanitizer;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    protected readonly userIcon: import("lucide-angular").LucideIconData;
+    protected readonly usersIcon: import("lucide-angular").LucideIconData;
+    protected readonly paperclipIcon: import("lucide-angular").LucideIconData;
+    protected readonly calendarIcon: import("lucide-angular").LucideIconData;
+    protected readonly mailIcon: import("lucide-angular").LucideIconData;
+    protected readonly tagIcon: import("lucide-angular").LucideIconData;
+    protected readonly clockIcon: import("lucide-angular").LucideIconData;
+    protected readonly hashIcon: import("lucide-angular").LucideIconData;
+    protected readonly unknownFileLabel = "\u672A\u77E5\u6587\u4EF6";
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly fields: import("@angular/core").WritableSignal<FieldsData | null>;
+    readonly subject: import("@angular/core").Signal<string>;
+    readonly sender: import("@angular/core").Signal<string>;
+    readonly toStr: import("@angular/core").Signal<string>;
+    readonly ccStr: import("@angular/core").Signal<string>;
+    readonly bccStr: import("@angular/core").Signal<string>;
+    readonly sentDate: import("@angular/core").Signal<string>;
+    readonly receivedDate: import("@angular/core").Signal<string>;
+    readonly createdDate: import("@angular/core").Signal<string>;
+    readonly lastModified: import("@angular/core").Signal<string>;
+    readonly attachments: import("@angular/core").Signal<FieldsData[]>;
+    readonly bodyHtml: import("@angular/core").Signal<string>;
+    readonly messageClass: import("@angular/core").Signal<string>;
+    readonly messageId: import("@angular/core").Signal<string>;
+    readonly importance: import("@angular/core").Signal<number | undefined>;
+    readonly importanceLabel: import("@angular/core").Signal<"" | "High" | "Low">;
+    readonly sensitivity: import("@angular/core").Signal<number | undefined>;
+    readonly sensitivityLabel: import("@angular/core").Signal<string>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    protected trust(html: string): import("@angular/platform-browser").SafeHtml;
+    protected formatAttachmentSize(size: number | undefined): string;
+    private loadMsg;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MsgRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MsgRenderer, "afp-msg-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Pdf/index.d.ts

@@ -0,0 +1,55 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+interface PdfOutlineItem {
+    title: string;
+    dest: unknown;
+    items?: PdfOutlineItem[];
+}
+export declare class PdfRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly sanitizer;
+    private readonly destroyRef;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    protected readonly xIcon: import("lucide-angular").LucideIconData;
+    readonly zoom: import("@angular/core").WritableSignal<number>;
+    readonly currentPage: import("@angular/core").WritableSignal<number>;
+    readonly showOutline: import("@angular/core").WritableSignal<boolean>;
+    readonly numPages: import("@angular/core").WritableSignal<number>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly outline: import("@angular/core").WritableSignal<PdfOutlineItem[]>;
+    readonly activeOutlineItem: import("@angular/core").WritableSignal<string | null>;
+    private readonly scrollContainerRef;
+    private readonly outlinePageMap;
+    private pdfDoc;
+    private readonly pageStates;
+    private observer;
+    private zoomWatchReady;
+    readonly outlineHtml: import("@angular/core").Signal<string>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    protected trust(html: string): import("@angular/platform-browser").SafeHtml;
+    protected onOutlineClick(e: Event): void;
+    private handleZoomIn;
+    private handleZoomOut;
+    private handleReset;
+    private handlePrevPage;
+    private handleNextPage;
+    private handleToggleOutline;
+    private buildOutlinePageMap;
+    private updateActiveOutlineByPage;
+    private handleOutlineClick;
+    private renderOutlineItemsHtml;
+    private renderPage;
+    private clearPageCanvas;
+    private initPagePlaceholders;
+    private loadPdf;
+    private handleScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PdfRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PdfRenderer, "afp-pdf-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/renderers/Ppt/index.d.ts

@@ -0,0 +1,19 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class PptRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly sanitizer;
+    private readonly t;
+    readonly html: import("@angular/core").WritableSignal<string>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    protected trust(html: string): import("@angular/platform-browser").SafeHtml;
+    private loadPpt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PptRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PptRenderer, "afp-ppt-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Pptx/index.d.ts

@@ -0,0 +1,29 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class PptxRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    tiled: import("@angular/core").InputSignal<boolean>;
+    private readonly locale;
+    private readonly request;
+    private readonly destroyRef;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly slideCount: import("@angular/core").WritableSignal<number>;
+    private readonly containerRef;
+    private previewer;
+    private resizeObserver;
+    private arrayBufferRef;
+    private resizeTimeout;
+    private lastDimensions;
+    private slideRatio;
+    private urlWatchReady;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    private calculateDimensions;
+    private reinitializePreviewer;
+    private loadPptx;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PptxRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PptxRenderer, "afp-pptx-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "tiled": { "alias": "tiled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/RendererError.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class RendererError {
+    message: import("@angular/core").InputSignal<string>;
+    detail: import("@angular/core").InputSignal<string | undefined>;
+    showIcon: import("@angular/core").InputSignal<boolean>;
+    protected readonly alertCircle: import("lucide-angular").LucideIconData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RendererError, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RendererError, "afp-renderer-error", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "detail": { "alias": "detail"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/RendererLoading.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class RendererLoading {
+    private readonly locale;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RendererLoading, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RendererLoading, "afp-renderer-loading", never, {}, {}, never, never, true, never>;
+}

package/lib/renderers/Subtitle/index.d.ts

@@ -0,0 +1,25 @@
+import { formatSubtitleTime, type SubtitleParseResult } from '../../fp-core';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class SubtitleRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileName: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    readonly text: import("@angular/core").WritableSignal<string>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly parsed: import("@angular/core").Signal<SubtitleParseResult | null>;
+    readonly isLyric: import("@angular/core").Signal<boolean>;
+    readonly meta: import("@angular/core").Signal<Record<string, string>>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    protected readonly formatSubtitleTime: typeof formatSubtitleTime;
+    protected wordTimeShort(time: number): string;
+    private static getFormat;
+    private load;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubtitleRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SubtitleRenderer, "afp-subtitle-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Text/index.d.ts

@@ -0,0 +1,29 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class TextRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileName: import("@angular/core").InputSignal<string>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly request;
+    private readonly sanitizer;
+    private readonly t;
+    readonly wordWrap: import("@angular/core").WritableSignal<boolean>;
+    readonly htmlPreview: import("@angular/core").WritableSignal<boolean>;
+    readonly content: import("@angular/core").WritableSignal<string>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly language: import("@angular/core").Signal<string>;
+    readonly isHtml: import("@angular/core").Signal<boolean>;
+    readonly lines: import("@angular/core").Signal<string[]>;
+    private readonly shiki;
+    readonly lineHtmls: import("@angular/core").Signal<string[]>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    protected trust(html: string): import("@angular/platform-browser").SafeHtml;
+    private loadText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextRenderer, "afp-text-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Unsupported/index.d.ts

@@ -0,0 +1,15 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class UnsupportedRenderer implements RendererHandle {
+    fileName: import("@angular/core").InputSignal<string>;
+    fileType: import("@angular/core").InputSignal<string>;
+    download: import("@angular/core").OutputEmitterRef<void>;
+    protected readonly fileQuestion: import("lucide-angular").LucideIconData;
+    protected readonly downloadIcon: import("lucide-angular").LucideIconData;
+    private readonly locale;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    getToolbarGroups(): ToolbarGroup[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsupportedRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UnsupportedRenderer, "afp-unsupported-renderer", never, { "fileName": { "alias": "fileName"; "required": true; "isSignal": true; }; "fileType": { "alias": "fileType"; "required": true; "isSignal": true; }; }, { "download": "download"; }, never, never, true, never>;
+}

package/lib/renderers/Video/index.d.ts

@@ -0,0 +1,28 @@
+import 'video.js/dist/video-js.css';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+interface ErrorState {
+    title: string;
+    detail: string;
+}
+export declare class VideoRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileName: import("@angular/core").InputSignal<string | undefined>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly destroyRef;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    readonly error: import("@angular/core").WritableSignal<ErrorState | null>;
+    readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    private readonly videoContainerRef;
+    private player;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    private getVideoExt;
+    private initPlayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VideoRenderer, "afp-video-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/renderers/Xlsx/index.d.ts

@@ -0,0 +1,25 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class XlsxRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly destroyRef;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    private readonly containerRef;
+    private sheetData;
+    private resizeObserver;
+    private resizeTimeout;
+    private lastDimensions;
+    private urlWatchReady;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    private calculateDimensions;
+    private mountSpreadsheet;
+    private loadExcel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XlsxRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<XlsxRenderer, "afp-xlsx-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Xml/index.d.ts

@@ -0,0 +1,26 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class XmlRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileName: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly sanitizer;
+    private readonly t;
+    readonly content: import("@angular/core").WritableSignal<string>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly xmlLang: import("@angular/core").WritableSignal<string>;
+    private readonly shiki;
+    readonly lineHtmls: import("@angular/core").Signal<string[]>;
+    readonly lines: import("@angular/core").Signal<string[]>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    protected trust(html: string): import("@angular/platform-browser").SafeHtml;
+    private indentXml;
+    private prettyPrintXml;
+    private load;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XmlRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<XmlRenderer, "afp-xml-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Zip/index.d.ts

@@ -0,0 +1,58 @@
+import type JSZip from 'jszip';
+import { type ZipTreeNode, type PreviewFileInput } from '../../fp-core';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export interface ZipToolbarStats {
+    files: number;
+    dirs: number;
+    size: number;
+}
+interface SelectedPreview {
+    path: string;
+    name: string;
+    size: number;
+    blobUrl: string;
+}
+interface HoverTipState {
+    text: string;
+    x: number;
+    y: number;
+}
+export declare class ZipRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    nestingDepth: import("@angular/core").InputSignal<number>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly request;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    private readonly splitRef;
+    readonly zip: import("@angular/core").WritableSignal<JSZip | null>;
+    readonly tree: import("@angular/core").WritableSignal<ZipTreeNode | null>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly expanded: import("@angular/core").WritableSignal<Set<string>>;
+    readonly selected: import("@angular/core").WritableSignal<SelectedPreview | null>;
+    readonly previewLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly previewError: import("@angular/core").WritableSignal<string | null>;
+    readonly hoverTip: import("@angular/core").WritableSignal<HoverTipState | null>;
+    readonly totalStats: import("@angular/core").Signal<ZipToolbarStats | null>;
+    readonly previewFiles: import("@angular/core").Signal<PreviewFileInput[]>;
+    private tipEl;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    handleToggle(path: string): void;
+    handleHover(payload: {
+        text: string;
+        rect: DOMRect;
+    }): void;
+    handleLeave(): void;
+    handleSelect(node: ZipTreeNode): Promise<void>;
+    private revokeCurrent;
+    private syncTip;
+    private load;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZipRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ZipRenderer, "afp-zip-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "nestingDepth": { "alias": "nestingDepth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/renderers/Zip/tree-item.d.ts

@@ -0,0 +1,29 @@
+import type { LucideIconData } from 'lucide-angular';
+import { formatFileSize, type ZipTreeNode } from '../../fp-core';
+import * as i0 from "@angular/core";
+export declare class ZipTreeItem {
+    node: import("@angular/core").InputSignal<ZipTreeNode>;
+    depth: import("@angular/core").InputSignal<number>;
+    selectedPath: import("@angular/core").InputSignal<string | null>;
+    expanded: import("@angular/core").InputSignal<Set<string>>;
+    toggle: import("@angular/core").OutputEmitterRef<string>;
+    select: import("@angular/core").OutputEmitterRef<ZipTreeNode>;
+    hover: import("@angular/core").OutputEmitterRef<{
+        text: string;
+        rect: DOMRect;
+    }>;
+    leave: import("@angular/core").OutputEmitterRef<void>;
+    protected readonly chevronRight: LucideIconData;
+    protected readonly folder: LucideIconData;
+    protected readonly folderOpen: LucideIconData;
+    protected readonly formatFileSize: typeof formatFileSize;
+    readonly padStyle: import("@angular/core").Signal<{
+        paddingLeft: string;
+    }>;
+    readonly isOpen: import("@angular/core").Signal<boolean>;
+    readonly isSelected: import("@angular/core").Signal<boolean>;
+    readonly fileIcon: import("@angular/core").Signal<LucideIconData>;
+    handleEnter(e: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZipTreeItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ZipTreeItem, "afp-zip-tree-item", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "depth": { "alias": "depth"; "required": true; "isSignal": true; }; "selectedPath": { "alias": "selectedPath"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": true; "isSignal": true; }; }, { "toggle": "toggle"; "select": "select"; "hover": "hover"; "leave": "leave"; }, never, never, true, never>;
+}

package/lib/renderers/base.types.d.ts

@@ -0,0 +1,10 @@
+import type { ToolbarGroup } from './toolbar.types';
+export interface RendererHandle {
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange?: (listener: () => void) => (() => void);
+}
+export declare class ToolbarEventEmitter {
+    private listeners;
+    subscribe(listener: () => void): () => void;
+    notify(): void;
+}

package/lib/renderers/lazy.d.ts

@@ -0,0 +1,23 @@
+import type { Type } from '@angular/core';
+export type RendererLoader = () => Promise<Type<unknown>>;
+export declare const loadImageRenderer: RendererLoader;
+export declare const loadPdfRenderer: RendererLoader;
+export declare const loadDocxRenderer: RendererLoader;
+export declare const loadXlsxRenderer: RendererLoader;
+export declare const loadPptxRenderer: RendererLoader;
+export declare const loadMsgRenderer: RendererLoader;
+export declare const loadEpubRenderer: RendererLoader;
+export declare const loadMobiRenderer: RendererLoader;
+export declare const loadVideoRenderer: RendererLoader;
+export declare const loadAudioRenderer: RendererLoader;
+export declare const loadMarkdownRenderer: RendererLoader;
+export declare const loadJsonRenderer: RendererLoader;
+export declare const loadCsvRenderer: RendererLoader;
+export declare const loadXmlRenderer: RendererLoader;
+export declare const loadSubtitleRenderer: RendererLoader;
+export declare const loadZipRenderer: RendererLoader;
+export declare const loadTextRenderer: RendererLoader;
+export declare const loadFontRenderer: RendererLoader;
+export declare const loadCadRenderer: RendererLoader;
+export declare const loadDocRenderer: RendererLoader;
+export declare const loadPptRenderer: RendererLoader;

package/lib/renderers/registry.d.ts

@@ -0,0 +1,13 @@
+import type { FileType, PreviewFile } from '../fp-core';
+import type { RendererLoader } from './lazy';
+export interface RendererContext {
+    resolvedUrl: string;
+    zipNestingDepth: number;
+    currentFile: PreviewFile;
+}
+export interface BuiltinRendererConfig {
+    fileType: FileType;
+    loader: RendererLoader;
+    getProps: (ctx: RendererContext) => Record<string, unknown>;
+}
+export declare const BUILTIN_RENDERERS: BuiltinRendererConfig[];

package/lib/renderers/toolbar.types.d.ts

@@ -0,0 +1,19 @@
+import type { LucideIconData } from 'lucide-angular';
+export interface ToolbarButtonItem {
+    type: 'button';
+    icon: LucideIconData;
+    tooltip: string;
+    action: () => void;
+    disabled?: boolean;
+    active?: boolean;
+    ariaKeyshortcuts?: string;
+}
+export interface ToolbarTextItem {
+    type: 'text';
+    content: string;
+    minWidth?: string;
+}
+export type ToolbarItem = ToolbarButtonItem | ToolbarTextItem;
+export interface ToolbarGroup {
+    items: ToolbarItem[];
+}

package/lib/types.d.ts

@@ -0,0 +1,26 @@
+import type { PreviewFile, PreviewFileLink, PreviewFileInput, FileType, PreviewState, CustomRendererEventPayload, RequestHandler, RequestInitFactory, RequestOptions, Fetcher, ShouldFetchAsBlob, Locale, Translator } from './fp-core';
+import type { Type } from '@angular/core';
+import type { LucideIconData } from 'lucide-angular';
+import type { ToolbarGroup } from './renderers/toolbar.types';
+export type { PreviewFile, PreviewFileLink, PreviewFileInput, FileType, PreviewState, CustomRendererEventPayload, RequestHandler, RequestInitFactory, RequestOptions, Fetcher, ShouldFetchAsBlob, };
+export interface ToolbarAction {
+    icon: LucideIconData;
+    label: string;
+    onClick: () => void;
+    disabled?: boolean;
+}
+export interface CustomRendererContext {
+    emit: (name: string, payload?: unknown) => void;
+    t: Translator;
+    theme: 'dark' | 'light';
+    locale: Locale;
+}
+export interface CustomRenderer {
+    test: (file: PreviewFile) => boolean;
+    /**
+     * 返回一个 Angular standalone 组件。将以 inputs `{ file, ctx }` 调用。
+     */
+    render: (file: PreviewFile, ctx?: CustomRendererContext) => Type<unknown>;
+    getToolbarGroups?: (file: PreviewFile, ctx: CustomRendererContext) => ToolbarGroup[];
+    events?: readonly string[];
+}

package/lib/utils/audio-player.d.ts

@@ -0,0 +1,20 @@
+export declare function createAudioPlayer(): {
+    isPlaying: import("@angular/core").WritableSignal<boolean>;
+    isLoading: import("@angular/core").WritableSignal<boolean>;
+    currentTime: import("@angular/core").WritableSignal<number>;
+    duration: import("@angular/core").WritableSignal<number>;
+    volume: import("@angular/core").WritableSignal<number>;
+    isMuted: import("@angular/core").WritableSignal<boolean>;
+    isLoop: import("@angular/core").WritableSignal<boolean>;
+    error: import("@angular/core").WritableSignal<string | null>;
+    bind: (el: HTMLAudioElement | null) => void;
+    togglePlay: () => void;
+    seek: (time: number) => void;
+    skip: (seconds: number) => void;
+    setVolume: (v: number) => void;
+    toggleMute: () => void;
+    toggleLoop: () => void;
+    formattedCurrent: () => string;
+    formattedDuration: () => string;
+    destroy: () => void;
+};

package/lib/utils/shiki-highlight.d.ts

@@ -0,0 +1,7 @@
+import { type Signal } from '@angular/core';
+export declare function createShikiHighlight(code: () => string, lang: () => string): {
+    html: Signal<string>;
+    lineHtmls: Signal<string[]>;
+    loading: Signal<boolean>;
+    highlight: () => Promise<void>;
+};