@netless/fastboard-core 0.2.9 → 0.2.10

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { AppsConfig, AppsStatus, DefaultApps, FastboardApp, FastboardOptions, FastboardPlayer, FastboardReadable, FastboardReplayOptions, FastboardWritable, InsertDocsDynamic, InsertDocsParams, InsertDocsStatic, createFastboard, registerApps, replayFastboard } from './minimal';
+import 'white-web-sdk';
+import '@netless/window-manager';

package/dist/minimal.d.ts

@@ -0,0 +1,286 @@
+import * as white_web_sdk from 'white-web-sdk';
+import { SceneDefinition, Camera, MemberState, AnimationMode, Rectangle, ApplianceNames, ShapeType, Color, ConversionResponse, WhiteWebSdk, Room, HotKeys, RoomCallbacks, ViewCallbacks, PlayerState, Player, PlayerCallbacks, WhiteWebSdkConfiguration, JoinRoomParams, ReplayRoomParams } from 'white-web-sdk';
+import { RegisterParams, WindowManager, PublicEvent, MountParams } from '@netless/window-manager';
+
+interface AppsConfig {
+    [kind: string]: Omit<RegisterParams, "kind">;
+}
+declare const DefaultApps: AppsConfig;
+declare function registerApps(config: AppsConfig): void;
+
+declare type FastboardDisposer = () => void;
+interface FastboardReadable<T> {
+    readonly value: T;
+    subscribe(callback: (value: T) => void): FastboardDisposer;
+    reaction(callback: (value: T) => void): FastboardDisposer;
+}
+interface FastboardWritable<T, SetFn = (value: T) => void> extends FastboardReadable<T> {
+    setValue: SetFn;
+}
+/**
+ * Create a readonly, reactive value.
+ * @example
+ * createValue(manager.getMainViewSceneIndex(), (set) => {
+ *   manager.emitter.on("mainViewSceneIndexChanged", set)
+ *   return () => manager.emitter.off("mainViewSceneIndexChanged", set)
+ * })
+ */
+declare function createValue<T>(value: T, effect: (set: (value: T) => void) => FastboardDisposer | void): FastboardReadable<T>;
+/**
+ * Create a writable, reactive value.
+ * @example
+ * createValue(manager.getMainViewSceneIndex(), (set) => {
+ *   manager.emitter.on("mainViewSceneIndexChanged", set)
+ *   return () => manager.emitter.off("mainViewSceneIndexChanged", set)
+ * }, (newValue) => {
+ *   manager.setMainViewSceneIndex(newValue)
+ * })
+ */
+declare function createValue<T, SetFn = (value: T) => void>(value: T, effect: (set: (value: T) => void) => FastboardDisposer | void, set: (value: T) => void): FastboardWritable<T, SetFn>;
+
+declare class FastboardAppBase {
+    readonly sdk: WhiteWebSdk;
+    readonly room: Room;
+    readonly manager: WindowManager;
+    readonly hotKeys: Partial<HotKeys>;
+    constructor(sdk: WhiteWebSdk, room: Room, manager: WindowManager, hotKeys: Partial<HotKeys>);
+    protected readonly _disposers: FastboardDisposer[];
+    protected _destroyed: boolean;
+    protected _assertNotDestroyed(): void;
+    protected createValue: typeof createValue;
+    protected _addRoomListener<K extends keyof RoomCallbacks, T = RoomCallbacks[K]>(name: K, listener: T): () => void;
+    protected _addManagerListener<K extends keyof PublicEvent>(name: K, set: (value: PublicEvent[K]) => void): () => void;
+    protected _addMainViewListener<K extends keyof ViewCallbacks, T = ViewCallbacks[K]>(name: K, listener: T): () => void;
+    destroy(): Promise<void>;
+}
+interface InsertDocsStatic {
+    readonly fileType: "pdf";
+    readonly scenePath: string;
+    readonly scenes: SceneDefinition[];
+    readonly title?: string;
+}
+interface InsertDocsDynamic {
+    readonly fileType: "pptx";
+    readonly scenePath: string;
+    readonly taskId: string;
+    readonly title?: string;
+    readonly url?: string;
+    /** @example [{ name: '1' }, { name: '2' }, { name: '3' }] */
+    readonly scenes?: SceneDefinition[];
+}
+declare type InsertDocsParams = InsertDocsStatic | InsertDocsDynamic;
+interface AppsStatus {
+    [kind: string]: {
+        status: "idle" | "loading" | "failed";
+        reason?: string;
+    };
+}
+declare class FastboardApp extends FastboardAppBase {
+    /**
+     * Render this app to some DOM.
+     */
+    bindContainer(container: HTMLElement): void;
+    /**
+     * Move window-manager's collector to some place.
+     */
+    bindCollector(container: HTMLElement): void;
+    /**
+     * Is current room writable?
+     */
+    readonly writable: FastboardWritable<boolean, (value: boolean) => void>;
+    /**
+     * Current window-manager's windows' state (is it maximized?).
+     */
+    readonly boxState: FastboardReadable<"minimized" | "maximized" | "normal" | undefined>;
+    /**
+     * Current window-manager's focused app's id.
+     * @example "HelloWorld-1A2b3C4d"
+     */
+    readonly focusedApp: FastboardReadable<string | undefined>;
+    /**
+     * How many times can I call `app.redo()`?
+     */
+    readonly canRedoSteps: FastboardReadable<number>;
+    /**
+     * How many times can I call `app.undo()`?
+     */
+    readonly canUndoSteps: FastboardReadable<number>;
+    /**
+     * Current camera information of main view.
+     */
+    readonly camera: FastboardReadable<Camera>;
+    /**
+     * Current tool's info, like "is using pencil?", "what color?".
+     */
+    readonly memberState: FastboardReadable<MemberState>;
+    /**
+     * 0..n-1, current index of main view scenes.
+     */
+    readonly sceneIndex: FastboardWritable<number, (value: number) => void>;
+    /**
+     * How many pages are in the main view?
+     */
+    readonly sceneLength: FastboardReadable<number>;
+    private _appsStatus;
+    /**
+     * Apps status.
+     */
+    readonly appsStatus: FastboardReadable<AppsStatus>;
+    /**
+     * Undo a step on main view.
+     */
+    undo(): void;
+    /**
+     * Redo a step on main view.
+     */
+    redo(): void;
+    /**
+     * Move current main view's camera position.
+     */
+    moveCamera(camera: Partial<Camera> & {
+        animationMode?: AnimationMode | undefined;
+    }): void;
+    /**
+     * Move current main view's camera to include a rectangle.
+     */
+    moveCameraToContain(rectangle: Rectangle & {
+        animationMode?: AnimationMode;
+    }): void;
+    /**
+     * Delete all things on the main view.
+     */
+    cleanCurrentScene(): void;
+    /**
+     * Set current tool, like "pencil".
+     */
+    setAppliance(appliance: ApplianceNames, shape?: ShapeType): void;
+    setStrokeWidth(strokeWidth: number): void;
+    setStrokeColor(strokeColor: Color): void;
+    /**
+     * Insert an image to the main view.
+     */
+    insertImage(url: string): Promise<void>;
+    /**
+     * Insert PDF/PPTX from conversion result.
+     * @param status https://developer.netless.link/server-en/home/server-conversion#get-query-task-conversion-progress
+     */
+    insertDocs(filename: string, status: ConversionResponse): Promise<string | undefined>;
+    /**
+     * Manual way.
+     * @example
+     * app.insertDocs({
+     *   fileType: 'pptx',
+     *   scenePath: `/pptx/${conversion.taskId}`,
+     *   taskId: conversion.taskId,
+     *   title: 'Title',
+     * })
+     */
+    insertDocs(params: InsertDocsParams): Promise<string | undefined>;
+    private _insertDocsImpl;
+    /**
+     * Insert the Monaco Code Editor app.
+     */
+    insertCodeEditor(): Promise<string | undefined>;
+    /**
+     * Insert the Countdown app.
+     */
+    insertCountdown(): Promise<string | undefined>;
+    /**
+     * Insert the Media Player app.
+     */
+    insertMedia(title: string, src: string): Promise<string | undefined>;
+    /**
+     * Insert the GeoGebra app.
+     */
+    insertGeoGebra(): Promise<string | undefined>;
+}
+
+declare class FastboardPlayerBase {
+    readonly sdk: WhiteWebSdk;
+    readonly player: Player;
+    readonly manager: WindowManager;
+    constructor(sdk: WhiteWebSdk, player: Player, manager: WindowManager);
+    protected readonly _disposers: FastboardDisposer[];
+    protected _destroyed: boolean;
+    protected _assertNotDestroyed(): void;
+    protected createValue: typeof createValue;
+    protected _addPlayerListener<K extends keyof PlayerCallbacks, T = PlayerCallbacks[K]>(name: K, listener: T): () => void;
+    protected _addManagerListener<K extends keyof PublicEvent>(name: K, set: (value: PublicEvent[K]) => void): () => void;
+    protected _addMainViewListener<K extends keyof ViewCallbacks, T = ViewCallbacks[K]>(name: K, listener: T): () => void;
+    destroy(): void;
+}
+declare class FastboardPlayer extends FastboardPlayerBase {
+    /**
+     * Render this player to some DOM.
+     */
+    bindContainer(container: HTMLElement): void;
+    /**
+     * Move window-manager's collector to some place.
+     */
+    bindCollector(container: HTMLElement): void;
+    readonly currentTime: FastboardWritable<number, (value: number) => void>;
+    readonly phase: FastboardReadable<white_web_sdk.PlayerPhase>;
+    readonly canplay: FastboardReadable<boolean>;
+    private _setSpeed;
+    readonly speed: FastboardWritable<number, (value: number) => void>;
+    readonly state: FastboardReadable<PlayerState | null>;
+    seek(timestamp: number): Promise<white_web_sdk.PlayerSeekingResult>;
+    play(): void;
+    pause(): void;
+    stop(): void;
+}
+
+interface FastboardOptions {
+    sdkConfig: Omit<WhiteWebSdkConfiguration, "useMobXState"> & {
+        region: string;
+    };
+    joinRoom: Omit<JoinRoomParams, "useMultiViews" | "disableNewPencil" | "disableMagixEventDispatchLimit"> & {
+        callbacks?: Partial<RoomCallbacks>;
+    };
+    managerConfig?: Omit<MountParams, "room">;
+    appsConfig?: AppsConfig;
+}
+/**
+ * Create a FastboardApp instance.
+ * @example
+ * let app = await createFastboard({
+ *   sdkConfig: {
+ *     appIdentifier: import.meta.env.VITE_APPID,
+ *     region: "ch-hz",
+ *   },
+ *   joinRoom: {
+ *     uid: unique_id,
+ *     uuid: import.meta.env.VITE_ROOM_UUID,
+ *     roomToken: import.meta.env.VITE_ROOM_TOKEN,
+ *   },
+ * })
+ */
+declare function createFastboard({ sdkConfig, joinRoom: { callbacks, ...joinRoomParams }, managerConfig, appsConfig, }: FastboardOptions): Promise<FastboardApp>;
+interface FastboardReplayOptions {
+    sdkConfig: Omit<WhiteWebSdkConfiguration, "useMobXState"> & {
+        region: string;
+    };
+    replayRoom: Omit<ReplayRoomParams, "useMultiViews"> & {
+        callbacks?: Partial<PlayerCallbacks>;
+    };
+    managerConfig?: Omit<MountParams, "room">;
+    appsConfig?: AppsConfig;
+}
+/**
+ * Create a FastboardPlayer instance.
+ * @example
+ * let app = await replayFastboard({
+ *   sdkConfig: {
+ *     appIdentifier: import.meta.env.VITE_APPID,
+ *     region: "ch-hz",
+ *   },
+ *   replayRoom: {
+ *     uid: unique_id,
+ *     uuid: import.meta.env.VITE_ROOM_UUID,
+ *     roomToken: import.meta.env.VITE_ROOM_TOKEN,
+ *   },
+ * })
+ */
+declare function replayFastboard({ sdkConfig, replayRoom: { callbacks, ...replayRoomParams }, managerConfig, appsConfig, }: FastboardReplayOptions): Promise<FastboardPlayer>;
+
+export { AppsConfig, AppsStatus, DefaultApps, FastboardApp, FastboardOptions, FastboardPlayer, FastboardReadable, FastboardReplayOptions, FastboardWritable, InsertDocsDynamic, InsertDocsParams, InsertDocsStatic, createFastboard, registerApps, replayFastboard };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netless/fastboard-core",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "A tiny wrapper of white-web-sdk and @netless/window-manager.",
   "main": "dist/index.js",
   "files": [
@@ -27,5 +27,5 @@
     "check": "tsc --noEmit"
   },
   "module": "dist/index.mjs",
-  "types": "src/index.ts"
+  "types": "dist/index.d.ts"
 }