@lingshugroup/web-plus 1.2.1 → 1.3.1

package/lib/types/components/preview/components/Image.vue.d.ts

@@ -0,0 +1,63 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { EpPropFinalized, EpPropMergeType } from '../../_utils/types';
+declare function setActiveItem(index: number): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        wrapper: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<globalThis.ExtractPropTypes<{
+    readonly source: EpPropFinalized<readonly [globalThis.PropType<string[]>, StringConstructor], unknown, unknown, () => [], boolean>;
+    readonly zIndex: {
+        readonly type: globalThis.PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initialIndex: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly infinite: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly hideOnClickModal: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly teleported: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly closeOnPressEscape: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly onClose: FunctionConstructor;
+    readonly zoomSize: EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 1.5, boolean>;
+}>, {
+    /** @description manually switch image */
+    setActiveItem: typeof setActiveItem;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    readonly source: EpPropFinalized<readonly [globalThis.PropType<string[]>, StringConstructor], unknown, unknown, () => [], boolean>;
+    readonly zIndex: {
+        readonly type: globalThis.PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initialIndex: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly infinite: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly hideOnClickModal: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly teleported: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly closeOnPressEscape: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly onClose: FunctionConstructor;
+    readonly zoomSize: EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 1.5, boolean>;
+}>> & Readonly<{}>, {
+    readonly source: EpPropMergeType<readonly [globalThis.PropType<string[]>, StringConstructor], unknown, unknown>;
+    readonly teleported: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly closeOnPressEscape: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly initialIndex: number;
+    readonly infinite: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly hideOnClickModal: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly zoomSize: EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/types/components/preview/components/Pdf.vue.d.ts

@@ -0,0 +1,16 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    source: string;
+    onClose: Function;
+    showSize?: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    [x: string]: any;
+} & {
+    [x: string]: any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+}>, {
+    showSize: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/types/components/preview/components/Xlsx.vue.d.ts

@@ -0,0 +1,21 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { EpPropFinalized, EpPropMergeType } from '../../_utils/types';
+declare const _default: DefineComponent<globalThis.ExtractPropTypes<{
+    source: EpPropFinalized<({
+        new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+        prototype: File;
+    } | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    source: EpPropFinalized<({
+        new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+        prototype: File;
+    } | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+}>> & Readonly<{}>, {
+    source: EpPropMergeType<({
+        new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+        prototype: File;
+    } | StringConstructor)[], unknown, unknown>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/lib/types/components/preview/components/pdfs/Annotation.vue.d.ts

@@ -0,0 +1,22 @@
+import { PDFDocumentProxy, PDFPageProxy, PageViewport } from 'pdfjs-dist';
+import { AnnotationEventPayload } from '../../types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    page?: PDFPageProxy;
+    viewport?: PageViewport;
+    document?: PDFDocumentProxy;
+    annotationsFilter?: string[];
+    annotationsMap?: object;
+    imageResourcesPath?: string;
+    hideForms?: boolean;
+    enableScripting?: boolean;
+    intent: string;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    annotation: (payload: AnnotationEventPayload) => any;
+    annotationLoaded: (payload: any[]) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAnnotation?: ((payload: AnnotationEventPayload) => any) | undefined;
+    onAnnotationLoaded?: ((payload: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/types/components/preview/components/pdfs/PdfItem.vue.d.ts

@@ -0,0 +1,58 @@
+import { PDFDocumentLoadingTask } from 'pdfjs-dist';
+import { HighlightOptions, WatermarkOptions } from '../../types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    pdf: PDFDocumentLoadingTask;
+    page: number;
+    scale: number;
+    rotation?: number;
+    fitParent?: boolean;
+    width?: number;
+    height?: number;
+    textLayer?: boolean;
+    imageResourcesPath?: string;
+    hideForms?: boolean;
+    intent?: string;
+    annotationLayer?: boolean;
+    annotationsFilter?: string[];
+    annotationsMap?: object;
+    watermarkText?: string;
+    watermarkOptions?: WatermarkOptions;
+    highlightText?: string | string[];
+    highlightOptions?: HighlightOptions;
+};
+declare function reload(): void;
+declare function cancel(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        container: HTMLDivElement;
+        loadingLayer: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {
+    reload: typeof reload;
+    cancel: typeof cancel;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    [x: string]: any;
+} & {
+    [x: string]: any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+}>, {
+    scale: number;
+    page: number;
+    intent: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/types/components/preview/components/pdfs/Text.vue.d.ts

@@ -0,0 +1,17 @@
+import { PDFPageProxy, PageViewport } from 'pdfjs-dist';
+import { HighlightEventPayload, HighlightOptions, TextLayerLoadedEventPayload } from '../../types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    page?: PDFPageProxy;
+    viewport?: PageViewport;
+    highlightText?: string | string[];
+    highlightOptions?: HighlightOptions;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    highlight: (payload: HighlightEventPayload) => any;
+    textLoaded: (payload: TextLayerLoadedEventPayload) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onHighlight?: ((payload: HighlightEventPayload) => any) | undefined;
+    onTextLoaded?: ((payload: TextLayerLoadedEventPayload) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/types/components/preview/components/pdfs/XFA.vue.d.ts

@@ -0,0 +1,13 @@
+import { PDFDocumentProxy, PDFPageProxy, PageViewport } from 'pdfjs-dist';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    page?: PDFPageProxy;
+    document?: PDFDocumentProxy;
+    viewport?: PageViewport;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    xfaLoaded: () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onXfaLoaded?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/types/components/preview/components/pdfs/annotations.d.ts

@@ -0,0 +1,5 @@
+import { PDFDocumentProxy } from 'pdfjs-dist';
+import { AnnotationEventPayload } from '../../types';
+declare const EVENTS_TO_HANDLER: string[];
+declare function annotationEventsHandler(evt: Event, PDFDoc: PDFDocumentProxy, Annotations: Object[]): AnnotationEventPayload | Promise<AnnotationEventPayload | undefined> | undefined;
+export { annotationEventsHandler, EVENTS_TO_HANDLER };

package/lib/types/components/preview/components/pdfs/destination.d.ts

@@ -0,0 +1,7 @@
+import { PDFDocumentProxy, RefProxy } from 'pdfjs-dist/types/src/display/api';
+import { PDFLocation } from '../../types';
+declare function getDestinationArray(doc: PDFDocumentProxy, dest: string | any[] | null): Promise<any[] | null>;
+declare function getDestinationRef(doc: PDFDocumentProxy, destArray: any[] | null): Promise<RefProxy | null>;
+declare function getLocation(type: string, spec: number[]): PDFLocation | null;
+declare const isSpecLike: (list: any[]) => list is number[];
+export { getDestinationArray, getDestinationRef, getLocation, isSpecLike };

package/lib/types/components/preview/components/pdfs/highlight.d.ts

@@ -0,0 +1,6 @@
+import { TextContent } from 'pdfjs-dist/types/src/display/text_layer';
+import { HighlightOptions, Match } from '../../types';
+declare function highlightMatches(matches: Match[], textContent: TextContent, textDivs: HTMLElement[]): void;
+declare function resetDivs(textContent: TextContent, textDivs: HTMLElement[]): void;
+declare function findMatches(queries: string[], textContent: TextContent, options: HighlightOptions): Match[];
+export { findMatches, highlightMatches, resetDivs };

package/lib/types/components/preview/components/pdfs/linkService.d.ts

@@ -0,0 +1,71 @@
+import { IPDFLinkService } from 'pdfjs-dist/types/web/interfaces';
+declare class SimpleLinkService implements IPDFLinkService {
+    externalLinkEnabled: boolean;
+    constructor();
+    /**
+     * @type {number}
+     */
+    get pagesCount(): number;
+    /**
+     * @type {number}
+     */
+    get page(): number;
+    /**
+     * @param {number} _value
+     */
+    set page(_value: number);
+    /**
+     * @type {number}
+     */
+    get rotation(): number;
+    /**
+     * @param {number} _value
+     */
+    set rotation(_value: number);
+    /**
+     * @type {boolean}
+     */
+    get isInPresentationMode(): boolean;
+    /**
+     * @param {string|Array} _dest - The named, or explicit, PDF destination.
+     */
+    goToDestination(_dest: string | Array<any>): Promise<void>;
+    /**
+     * @param {number|string} _val - The page number, or page label.
+     */
+    goToPage(_val: number | string): void;
+    /**
+     * @param {HTMLAnchorElement} link
+     * @param {string} url
+     * @param {boolean} [_newWindow]
+     */
+    addLinkAttributes(link: HTMLAnchorElement, url: string, _newWindow?: boolean): void;
+    /**
+     * @param _dest - The PDF destination object.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getDestinationHash(_dest: any): string;
+    /**
+     * @param _hash - The PDF parameters/hash.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getAnchorUrl(_hash: any): string;
+    /**
+     * @param {string} _hash
+     */
+    setHash(_hash: string): void;
+    /**
+     * @param {string} _action
+     */
+    executeNamedAction(_action: string): void;
+    /**
+     * @param {Object} _action
+     */
+    executeSetOCGState(_action: object): void;
+    /**
+     * @param {number} _pageNum - page number.
+     * @param {Object} _pageRef - reference to the page.
+     */
+    cachePageRef(_pageNum: number, _pageRef: object): void;
+}
+export { SimpleLinkService };

package/lib/types/components/preview/components/pdfs/miscellaneous.d.ts

@@ -0,0 +1,3 @@
+declare function createIframe(): Promise<HTMLIFrameElement>;
+declare function addStylesToIframe(content: Window, sizeX: number, sizeY: number): void;
+export { addStylesToIframe, createIframe };

package/lib/types/components/preview/composable.d.ts

@@ -0,0 +1,30 @@
+import { Ref, ShallowRef } from 'vue';
+import { PDFDestination, PDFInfo, PDFOptions, PDFSrc } from './types';
+import { PDFDocumentLoadingTask } from 'pdfjs-dist/types/src/display/api';
+/**
+ * @typedef {Object} UsePDFParameters
+ * @property {string} password
+ * Document password to unlock content
+ * @property {function} onProgress
+ * Callback to request a password if a wrong or no password was provided. The callback receives two parameters: a function that should be called with the new password, and a reason (see PasswordResponses).
+ * @property {function} onPassword
+ * Callback to be able to monitor the loading progress of the PDF file (necessary to implement e.g. a loading bar). The callback receives an OnProgressParameters argument. if this function is used option.password is ignored
+ * @property {function} onError
+ * Callback to be able to handle errors during loading
+ * */
+/**
+ *
+ * @param {string | URL | TypedArray | PDFDataRangeTransport | DocumentInitParameters} src
+ * Can be a URL where a PDF file is located, a typed array (Uint8Array) already populated with data, or a parameter object.
+ * @param {UsePDFParameters} options
+ * UsePDF object parameters
+ */
+export declare function usePDF(src: PDFSrc | Ref<PDFSrc>, options?: PDFOptions): {
+    pdf: ShallowRef< PDFDocumentLoadingTask | undefined, PDFDocumentLoadingTask | undefined>;
+    pages: ShallowRef<number, number>;
+    info: ShallowRef<{}, {}> | ShallowRef<PDFInfo, PDFInfo>;
+    print: (dpi?: number, filename?: string) => Promise<void>;
+    download: (filename?: string) => Promise<void>;
+    getPDFDestination: (destination: string | any[] | null) => Promise<PDFDestination | null>;
+    processLoadingTask: (source: any) => Promise<void>;
+};

package/lib/types/components/preview/index.d.ts

@@ -0,0 +1,130 @@
+import { App, CreateComponentPublicInstanceWithMixins, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
+import { LSOptions } from '../_utils/types';
+declare const LSPreview: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+        type: {
+            type: globalThis.PropType<"docx" | "pdf" | "xlsx" | "image">;
+            require: boolean;
+            default: string;
+        };
+        source: {};
+        zoomSize: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: number;
+        };
+        needLoading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loadingOption: {
+            type: ObjectConstructor;
+            default: () => {
+                text: string;
+                background: string;
+            };
+        };
+        modelValue: {
+            type: globalThis.PropType<boolean>;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((value: boolean | undefined) => any) | undefined;
+        onLoadComplete?: (() => any) | undefined;
+        onLoadError?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        "update:modelValue": (value: boolean | undefined) => any;
+    } & {
+        loadComplete: () => any;
+        loadError: () => any;
+    }, PublicProps, {
+        type: "docx" | "pdf" | "xlsx" | "image";
+        zoomSize: string | number;
+        needLoading: boolean;
+        loadingOption: Record<string, any>;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<globalThis.ExtractPropTypes<{
+        type: {
+            type: globalThis.PropType<"docx" | "pdf" | "xlsx" | "image">;
+            require: boolean;
+            default: string;
+        };
+        source: {};
+        zoomSize: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: number;
+        };
+        needLoading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loadingOption: {
+            type: ObjectConstructor;
+            default: () => {
+                text: string;
+                background: string;
+            };
+        };
+        modelValue: {
+            type: globalThis.PropType<boolean>;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((value: boolean | undefined) => any) | undefined;
+        onLoadComplete?: (() => any) | undefined;
+        onLoadError?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        type: "docx" | "pdf" | "xlsx" | "image";
+        zoomSize: string | number;
+        needLoading: boolean;
+        loadingOption: Record<string, any>;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+    type: {
+        type: globalThis.PropType<"docx" | "pdf" | "xlsx" | "image">;
+        require: boolean;
+        default: string;
+    };
+    source: {};
+    zoomSize: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    needLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingOption: {
+        type: ObjectConstructor;
+        default: () => {
+            text: string;
+            background: string;
+        };
+    };
+    modelValue: {
+        type: globalThis.PropType<boolean>;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean | undefined) => any) | undefined;
+    onLoadComplete?: (() => any) | undefined;
+    onLoadError?: (() => any) | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean | undefined) => any;
+} & {
+    loadComplete: () => any;
+    loadError: () => any;
+}, string, {
+    type: "docx" | "pdf" | "xlsx" | "image";
+    zoomSize: string | number;
+    needLoading: boolean;
+    loadingOption: Record<string, any>;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
+    install: (app: App, options?: LSOptions) => void;
+};
+export default LSPreview;

package/lib/types/components/preview/types.d.ts

@@ -0,0 +1,143 @@
+import { ExtractPropTypes, PropType } from 'vue';
+import { PageViewport } from 'pdfjs-dist';
+import { DocumentInitParameters, OnProgressParameters, PDFDataRangeTransport, TextContent, TypedArray } from 'pdfjs-dist/types/src/display/api';
+import { Metadata } from 'pdfjs-dist/types/src/display/metadata';
+import { default as LSImage } from './components/Image.vue';
+import { EpPropFinalized } from '../_utils/types';
+declare const emitNames: string[];
+export { emitNames };
+export type ImageViewerAction = 'zoomIn' | 'zoomOut' | 'clockwise' | 'anticlockwise';
+export declare const imageViewerProps: {
+    readonly source: EpPropFinalized<readonly [PropType<string[]>, StringConstructor], unknown, unknown, () => [], boolean>;
+    readonly zIndex: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly initialIndex: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly infinite: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly hideOnClickModal: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly teleported: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly closeOnPressEscape: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly onClose: FunctionConstructor;
+    readonly zoomSize: EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 1.5, boolean>;
+};
+export type ImageViewerProps = ExtractPropTypes<typeof imageViewerProps>;
+export declare const previewEmits: string[];
+export type PreviewEmits = typeof previewEmits;
+export interface ImageViewerMode {
+    name: string;
+}
+export type ImageViewerInstance = InstanceType<typeof LSImage>;
+export declare const docxProps: {
+    source: EpPropFinalized<(ArrayBufferConstructor | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+};
+export declare const xlsxProps: {
+    source: EpPropFinalized<({
+        new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+        prototype: File;
+    } | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+};
+export interface Match {
+    start: {
+        idx: number;
+        offset: number;
+    };
+    end: {
+        idx: number;
+        offset: number;
+    };
+    str: string;
+    oindex: number;
+}
+export type LoadedEventPayload = PageViewport;
+export interface AnnotationEventPayload {
+    type: string;
+    data: any;
+}
+export interface HighlightEventPayload {
+    matches: Match[];
+    page: number;
+    textContent: TextContent;
+    textDivs: HTMLElement[];
+}
+export interface TextLayerLoadedEventPayload {
+    textDivs: HTMLElement[];
+    textContent: TextContent | undefined;
+}
+export interface WatermarkOptions {
+    columns?: number;
+    rows?: number;
+    rotation?: number;
+    fontSize?: number;
+    color?: string;
+}
+export interface HighlightOptions {
+    ignoreCase?: boolean;
+    completeWords?: boolean;
+}
+export interface Base<T, S> {
+    type: T;
+    spec: S;
+}
+export type XYZ = Base<'XYZ', [left: number, top: number, zoom: number]>;
+export type Fit = Base<'Fit', []>;
+export type FitH = Base<'FitH', [top: number]>;
+export type FitV = Base<'FitV', [left: number]>;
+export type FitR = Base<'FitR', [left: number, bottom: number, right: number, top: number]>;
+export type FitB = Base<'FitB', []>;
+export type FitBH = Base<'FitBH', [top: number]>;
+export type FitBV = Base<'FitBV', [left: number]>;
+export type PDFLocation = XYZ | Fit | FitH | FitV | FitR | FitB | FitBH | FitBV;
+export interface PDFDestination {
+    pageIndex: number;
+    location: PDFLocation;
+}
+export type OnProgressCallback = (progressData: OnProgressParameters) => void;
+export type UpdatePasswordFn = (newPassword: string) => void;
+export type OnPasswordCallback = (updatePassword: UpdatePasswordFn, reason: any) => void;
+export type OnErrorCallback = (error: any) => void;
+export type PDFSrc = string | URL | TypedArray | PDFDataRangeTransport | DocumentInitParameters | undefined | null;
+export interface PDFOptions {
+    onProgress?: OnProgressCallback;
+    onPassword?: OnPasswordCallback;
+    onError?: OnErrorCallback;
+    password?: string;
+}
+export interface PDFInfoMetadata {
+    info: Object;
+    metadata: Metadata;
+}
+export interface PDFInfo {
+    metadata: PDFInfoMetadata;
+    attachments: Record<string, unknown>;
+    javascript: string[] | null;
+    outline: any;
+}
+type PreviewType = 'image' | 'docx' | 'xlsx' | 'pdf';
+export declare const lsPreviewProp: {
+    type: {
+        type: PropType<PreviewType>;
+        require: boolean;
+        default: string;
+    };
+    source: {};
+    zoomSize: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    needLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingOption: {
+        type: ObjectConstructor;
+        default: () => {
+            text: string;
+            background: string;
+        };
+    };
+};

package/lib/types/components/preview_docx/Docx.vue.d.ts

@@ -0,0 +1,12 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { EpPropFinalized, EpPropMergeType } from '../_utils/types';
+declare const _default: DefineComponent<globalThis.ExtractPropTypes<{
+    source: EpPropFinalized<(ArrayBufferConstructor | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    source: EpPropFinalized<(ArrayBufferConstructor | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+}>> & Readonly<{}>, {
+    source: EpPropMergeType<(ArrayBufferConstructor | StringConstructor)[], unknown, unknown>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;