@netless/app-slide 0.2.81 → 0.2.82-beta.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ReadonlyTeleBox, RegisterParams, AppContext, View, NetlessApp } from '@netless/window-manager';
+import { ReadonlyTeleBox, RegisterParams, Room, AppContext, Player, View, NetlessApp } from '@netless/window-manager';
 import { VolumeAdjuster, SlideError } from '@netless/ppt-player';
 import { IPlugin } from '@netless/plugin-system';
 
@@ -203,6 +203,7 @@ interface ISlideRenderOptions {
      * [4] 3K 3200 × 1800, greater than 4 is calculated as 4; --- default setting for PC devices.
      */
     transitionResolutionLevel?: number;
+    antialias?: boolean;
 }
 interface INavigatorDelegate {
     gotoPage?: (index: number) => void;
@@ -757,6 +758,7 @@ interface FreezableSlide {
     freeze: () => void;
     unfreeze: () => void;
 }
+declare let useFreezer: boolean;
 declare let FreezerLength: number;
 declare function getFreezerLength(): number;
 /** @param length - must be >= 1, default is 2 */
@@ -911,6 +913,8 @@ declare class DocsViewer {
     protected sideEffect: SideEffectManager;
 }
 
+declare function syncSceneWithSlide(room: Room, context: AppContext<Attributes>, slide: Slide, baseScenePath: string): void;
+
 declare const DefaultUrl = "https://convertcdn.netless.link/dynamicConvert";
 interface SlideControllerOptions {
     context: AppContext<Attributes, MagixEvents, AppOptions>;
@@ -929,51 +933,52 @@ interface SlideControllerOptions {
     showRenderError?: boolean;
     invisibleBehavior?: "frozen" | "pause";
 }
+type MagixEventListener = Parameters<AppContext<Attributes, MagixEvents>["addMagixEventListener"]>[1];
 declare class SlideController {
     readonly context: SlideControllerOptions["context"];
     readonly slide: Slide;
     readonly showRenderError: boolean;
     readonly onRenderError?: (error: Error, pageIndex: number) => void;
     readonly onNavigate: (index: number, origin?: string) => void;
-    private readonly room?;
-    private readonly player?;
-    private readonly sideEffect;
-    private readonly onRenderStart;
-    private readonly onPageChanged;
-    private readonly onTransitionStart;
-    private readonly onTransitionEnd;
-    private readonly onError;
-    private syncStateOnceFlag;
-    private visible;
-    private savedIsFrozen;
-    private invisibleBehavior;
+    protected readonly room?: Room;
+    protected readonly player?: Player;
+    protected readonly sideEffect: SideEffectManager;
+    protected readonly onRenderStart: SlideControllerOptions["onRenderStart"];
+    protected readonly onPageChanged: SlideControllerOptions["onPageChanged"];
+    protected readonly onTransitionStart: SlideControllerOptions["onTransitionStart"];
+    protected readonly onTransitionEnd: SlideControllerOptions["onTransitionEnd"];
+    protected readonly onError: SlideControllerOptions["onError"];
+    protected syncStateOnceFlag: boolean;
+    protected visible: boolean;
+    protected savedIsFrozen: boolean;
+    protected invisibleBehavior: "frozen" | "pause";
     previewList: string[];
     constructor({ context, anchor, onRenderStart, onPageChanged, onTransitionStart, onTransitionEnd, onNavigate, onError, onRenderError, showRenderError, invisibleBehavior, }: SlideControllerOptions);
     ready: boolean;
-    private resolveReady;
+    protected resolveReady: (index: number) => void;
     readonly readyPromise: Promise<void>;
     jumpToPage(page: number, origin?: string): void;
-    private initialize;
-    private kickStart;
-    private registerEventListeners;
-    private onSyncDispatch;
-    private magixEventListener;
-    private syncStateOnce;
-    private onStateChange;
-    private pollCount;
-    private pollReadyState;
-    private _pageCount;
+    protected initialize(): void;
+    protected kickStart(): void;
+    protected registerEventListeners(): void;
+    protected onSyncDispatch: (event: SyncEvent) => void;
+    protected magixEventListener: MagixEventListener;
+    protected syncStateOnce(): void;
+    protected onStateChange: (state: SlideState) => void;
+    protected pollCount: number;
+    protected pollReadyState: () => void;
+    protected _pageCount: number;
     get pageCount(): number;
     get page(): number;
-    private createSlide;
-    private destroyed;
+    protected createSlide(anchor: HTMLDivElement, defaults?: Partial<ISlideConfig>): Slide;
+    protected destroyed: boolean;
     destroy(): void;
     timestamp: () => number;
     isFrozen: boolean;
-    private _toFreeze;
+    protected _toFreeze: -1 | 0 | 1;
     freeze: () => void;
     unfreeze: () => Promise<void>;
-    private onVisibilityChange;
+    protected onVisibilityChange: () => Promise<void>;
 }
 
 type MountSlideOptions = Omit<SlideControllerOptions, "context" | "onPageChanged"> & {
@@ -1000,10 +1005,10 @@ declare class SlideDocsViewer {
     protected readonly mountSlideController: SlideDocsViewerConfig["mountSlideController"];
     protected readonly mountWhiteboard: SlideDocsViewerConfig["mountWhiteboard"];
     protected readonly onNavigate: (index: number, origin?: string) => void;
-    private readonly baseScenePath;
-    private readonly appId;
-    private isViewMounted;
-    private justSildeReadonly;
+    protected readonly baseScenePath: string;
+    protected readonly appId: string;
+    protected isViewMounted: boolean;
+    protected justSildeReadonly: boolean;
     constructor({ context, box, view, mountSlideController, mountWhiteboard, baseScenePath, appId, urlInterrupter, onPagesReady, onNavigate, }: SlideDocsViewerConfig);
     $slide: HTMLDivElement;
     $whiteboardView: HTMLDivElement;
@@ -1021,8 +1026,8 @@ declare class SlideDocsViewer {
     protected onRenderStart: () => void;
     protected onRenderEnd: () => void;
     onPageChanged: () => void;
-    private _onPageChangedTimer;
-    private _onPageChanged;
+    protected _onPageChangedTimer: number;
+    protected _onPageChanged: () => void;
     protected refreshPages: () => void;
     protected getPageIndex(page: number): number;
     unmount(): this;
@@ -1035,10 +1040,48 @@ declare class SlideDocsViewer {
     protected sideEffect: SideEffectManager;
     protected wrapClassName(className: string): string;
     protected namespace: string;
-    private getWhiteSnapshot;
-    private reportProgress;
-    private toPdf;
+    protected getWhiteSnapshot(pageIndex: number, canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, slideWidth: number, slideHeight: number): Promise<void>;
+    protected reportProgress(progress: number, result: {
+        pdf: ArrayBuffer;
+        title: string;
+    } | null): void;
+    protected toPdf: () => Promise<null | undefined>;
+}
+
+type DebugMessage = {
+    slide: boolean | "__instance" | "__debug";
+};
+type RoomLogger = {
+    debug: (...args: any) => void;
+    info: (...args: any) => void;
+    warn: (...args: any) => void;
+};
+declare class Logger {
+    enable: boolean;
+    apps: Record<string, {
+        context?: AppContext | null;
+        controller?: SlideController | null;
+    }>;
+    setAppContext(appId: string, context: AppContext | null): void;
+    setAppController(appId: string, controller: SlideController | null): void;
+    deleteApp(appId: string): void;
+    level: "debug" | "verbose";
+    roomLogger: RoomLogger | null;
+    constructor(enable: boolean);
+    initialize(): void;
+    dispose(): void;
+    log(...args: any[]): void;
+    verbose(...args: any[]): void;
+    warn(...args: any[]): void;
+    /**
+     * @example
+     * window.postMessage({ slide: '__debug' })
+     * window.dispatchEvent(new MessageEvent('message', { data: { slide: '__debug' } }))
+     */
+    _onMessage: (ev: MessageEvent<DebugMessage> | CustomEvent<DebugMessage>) => void;
 }
+declare const logger: Logger;
+declare const log: (...args: any[]) => void;
 
 interface PreviewParams {
     container: HTMLElement;
@@ -1055,10 +1098,10 @@ declare class SlidePreviewer {
     slide: Slide | null;
     debug: boolean;
     $slide: HTMLDivElement;
-    private previewList;
-    private readonly sideEffect;
+    protected previewList: string[];
+    protected readonly sideEffect: SideEffectManager;
     ready: boolean;
-    private resolveReady;
+    protected resolveReady: () => void;
     readonly readyPromise: Promise<void>;
     constructor(config: {
         target: HTMLElement;
@@ -1072,7 +1115,7 @@ declare class SlidePreviewer {
      * previewer.registerHotKeys(windowLike)
      */
     registerHotKeys(windowLike: Window): void;
-    private hotkeyListener;
+    protected hotkeyListener: (ev: KeyboardEvent) => void;
     mount(taskId: string, url: string, resourceList: string[], previewList?: string[]): void;
     protected renderStyle(): HTMLElement;
     protected registerEventListeners(): void;
@@ -1082,7 +1125,7 @@ declare class SlidePreviewer {
     protected onError: ({ error }: {
         error: Error;
     }) => void;
-    private destroyed;
+    protected destroyed: boolean;
     destroy(): void;
     protected refreshPages: () => void;
     protected getPageIndex(page: number): number;
@@ -1145,4 +1188,4 @@ interface AppResult {
 }
 declare const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult>;
 
-export { type AddHooks, type AppOptions, type AppResult, type Attributes, DefaultUrl, type FreezableSlide, FreezerLength, type ILogger, type PreviewParams, Slide, SlidePreviewer, addHooks, apps, SlideApp as default, getFreezerLength, onCreated, onDestroyed, previewSlide, setFreezerLength, usePlugin, version };
+export { type AddHooks, type AppOptions, type AppResult, type Attributes, DefaultUrl, type FreezableSlide, FreezerLength, type ILogger, type PreviewParams, SideEffectManager, Slide, SlideController, SlideDocsViewer, SlidePreviewer, addHooks, apps, SlideApp as default, getFreezerLength, log, logger, onCreated, onDestroyed, previewSlide, setFreezerLength, syncSceneWithSlide, useFreezer, usePlugin, version };