pptx-react-viewer 1.16.1 → 1.17.0

package/dist/index-XGt7MZpa.d.ts

@@ -0,0 +1,607 @@
+import { C as CollaborationConfig$1, D as UserPresence, E as ConnectionStatus, et as ViewerMode$1, m as PresentationAnimationRuntime, w as CollaborationContextValue } from "./types-BK7Nt13M.js";
+import { PptxAction, PptxData, PptxElement, PptxHandler, PptxSlide, PptxSlideTransition, PptxThemeColorScheme, PptxThemeFontScheme, PptxThemePreset } from "pptx-viewer-core";
+import { CollaborationConfig, ElementAnimationState } from "pptx-viewer-shared";
+import { RefObject } from "react";
+import * as Y from "yjs";
+import { Doc, Doc as YDoc } from "yjs";
+//#region src/viewer/hooks/presentation-mode/types.d.ts
+/**
+ * State describing the transition overlay that plays while advancing into a
+ * slide that carries a `p:transition`. The outgoing slide is snapshotted into
+ * an animated overlay layer while the incoming slide renders underneath on the
+ * main stage; the overlay tears down once `durationMs` elapses.
+ */
+interface PresentationTransitionOverlayState {
+  /** Index of the leaving slide, rendered (animated) in the overlay layer. */
+  outgoingSlideIndex: number;
+  /** Index of the arriving slide, already live on the main stage. */
+  incomingSlideIndex: number;
+  /** The incoming slide's transition definition (drives the CSS animation). */
+  transition: PptxSlideTransition;
+  /** Resolved transition duration (ms). */
+  durationMs: number;
+}
+interface UsePresentationModeInput {
+  mode: ViewerMode$1;
+  slides: PptxSlide[];
+  visibleSlideIndexes: number[];
+  activeSlideIndex: number;
+  containerRef: React.RefObject<HTMLElement | null>;
+  /** Raw PPTX bytes: forwarded to audience window for content sharing. */
+  content?: ArrayBuffer | Uint8Array | null;
+  onSetMode: (mode: ViewerMode$1) => void;
+  onSetActiveSlideIndex: (index: number) => void;
+  onPlayActionSound?: (soundPath: string) => void;
+  /** Called when L key is pressed during presentation. */
+  onToggleLaser?: () => void;
+  /** Called when P key is pressed during presentation. */
+  onTogglePen?: () => void;
+  /** Called when E key is pressed during presentation. */
+  onToggleEraser?: () => void;
+  /** Called when Ctrl+M is pressed during presentation. */
+  onToggleToolbar?: () => void;
+  /** Called to persist rehearsal timings into slide transitions. */
+  onSaveRehearsalTimings?: (timings: Record<number, number>) => void;
+  /** Whether to loop continuously (kiosk or explicit loop setting). */
+  loopContinuously?: boolean;
+  /** Whether to play animations during the slide show (false = skip all animations). */
+  showWithAnimation?: boolean;
+  /** Whether to use rehearsed auto-advance timings (false = manual advance only). */
+  useTimings?: boolean;
+}
+interface UsePresentationModeResult {
+  presentationSlideIndex: number;
+  setPresentationSlideIndex: (index: number) => void;
+  presentationSlideVisible: boolean;
+  /** Active slide-transition overlay, or `null` when no transition is playing. */
+  transitionOverlay: PresentationTransitionOverlayState | null;
+  /** Tear down the transition overlay once its animation completes. */
+  handleTransitionOverlayComplete: () => void;
+  presentationAnimations: PresentationAnimationRuntime[];
+  presentationElementStates: Map<string, ElementAnimationState>;
+  presentationKeyframesCss: string;
+  clearPresentationTimers: () => void;
+  runPresentationEntranceAnimations: (slideIndex: number) => void;
+  movePresentationSlide: (direction: 1 | -1) => void;
+  navigateToSlide: (slideIndex: number) => void;
+  handlePresentationAction: (action: PptxAction) => void;
+  /**
+   * Handle a shape click in presentation mode. If the shape is an interactive
+   * trigger, play its animation sequence. Returns `true` if handled.
+   */
+  handleInteractiveShapeClick: (shapeId: string) => boolean;
+  /** Set of shape IDs that are interactive sequence triggers on the current slide. */
+  interactiveTriggerShapeIds: ReadonlySet<string>;
+  /** Set of shape IDs that are hover animation triggers on the current slide. */
+  hoverTriggerShapeIds: ReadonlySet<string>;
+  /** Handle hover start on a shape. If the shape has a hover sequence, play it. Returns `true` if handled. */
+  handleHoverStart: (shapeId: string) => boolean;
+  /** Handle hover end on a shape. Resets the hover sequence for replay. */
+  handleHoverEnd: (shapeId: string) => void;
+  /** Must be called from a user-gesture handler (click) to satisfy browser fullscreen policy. */
+  enterPresentMode: () => void;
+  /** Whether presenter view (split-screen with notes) is active instead of fullscreen. */
+  presenterMode: boolean;
+  /** Enter presenter view mode (no fullscreen, shows notes panel). */
+  enterPresenterView: () => void;
+  /** Toggle between fullscreen and presenter view during presentation. */
+  togglePresenterView: () => void;
+  /** Timestamp (ms) when the presentation started: used for elapsed timer. */
+  presentationStartTime: number | null;
+  /** Whether the current presentation session is in rehearse-timings mode. */
+  rehearsing: boolean;
+  /** Enter rehearse-timings mode (fullscreen presentation + timing HUD). */
+  enterRehearsalMode: () => void;
+  /** Recorded timings in ms, keyed by slide index. Populated during rehearsal. */
+  recordedTimings: Record<number, number>;
+  /** Timestamp when the current slide started (ms since epoch). */
+  slideStartTime: number | null;
+  /** Whether the rehearsal summary dialog should be shown. */
+  showRehearsalSummary: boolean;
+  /** Dismiss the rehearsal summary (discard timings). */
+  dismissRehearsalSummary: () => void;
+  /** Save recorded timings into each slide's transition.advanceAfterMs. */
+  saveRehearsalTimings: () => void;
+  /** Whether rehearsal timer is paused. */
+  rehearsalPaused: boolean;
+  /** Toggle the rehearsal timer pause state. */
+  toggleRehearsalPause: () => void;
+  /** Handle a zoom element click in presentation mode. */
+  handleZoomClick: (targetSlideIndex: number, returnSlideIndex: number) => void;
+  /** Ref holding the slide index to return to after zoom navigation. */
+  zoomReturnSlideIndex: React.RefObject<number | null>;
+  /** Navigate back to the zoom summary slide. Returns true if navigation occurred. */
+  returnToZoomSlide: () => boolean;
+  /** Clear the stored zoom return index. */
+  clearZoomReturn: () => void;
+  /** Open the audience display in a separate browser window. Returns `true` if successful. */
+  openAudienceWindow: () => boolean;
+  /** Close the audience display window. */
+  closeAudienceWindow: () => void;
+  /** Whether the audience window is currently open. */
+  isAudienceWindowOpen: () => boolean;
+  /** Send a slide index to the audience window explicitly. */
+  syncSlideToAudience: (slideIndex: number) => void;
+}
+//#endregion
+//#region src/viewer/hooks/useThemeSwitching.d.ts
+interface UseThemeSwitchingInput {
+  /** Ref to the PptxHandler instance. */
+  handlerRef: RefObject<PptxHandler | null>;
+  /** Current parsed presentation data (null when nothing is loaded). */
+  data: PptxData | null;
+  /** Callback to update the presentation data after theme switch. */
+  onDataChange: (newData: PptxData) => void;
+  /** Optional callback fired when theme switch completes successfully. */
+  onThemeChanged?: (preset: PptxThemePreset) => void;
+}
+interface ThemeSwitchingResult {
+  /** All available built-in theme presets. */
+  presets: readonly PptxThemePreset[];
+  /**
+   * Apply a theme preset to the current presentation.
+   * Updates both the in-memory ZIP and all resolved element colours.
+   */
+  switchToPreset: (preset: PptxThemePreset) => Promise<void>;
+  /**
+   * Apply a custom colour scheme (and optional font scheme) to the
+   * current presentation.
+   */
+  switchToCustom: (colorScheme: PptxThemeColorScheme, fontScheme?: PptxThemeFontScheme, themeName?: string) => Promise<void>;
+  /**
+   * Get the preset matching the current presentation theme (if any).
+   * Returns undefined if the current theme does not match a built-in preset.
+   */
+  currentPreset: PptxThemePreset | undefined;
+}
+/**
+ * React hook providing theme switching capabilities for the PowerPoint viewer.
+ *
+ * @example
+ * ```tsx
+ * const { presets, switchToPreset, currentPreset } = useThemeSwitching({
+ *   handlerRef,
+ *   data,
+ *   onDataChange: setData,
+ * });
+ *
+ * return (
+ *   <div>
+ *     {presets.map(preset => (
+ *       <button
+ *         key={preset.id}
+ *         onClick={() => switchToPreset(preset)}
+ *         aria-pressed={preset.id === currentPreset?.id}
+ *       >
+ *         {preset.name}
+ *       </button>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+declare function useThemeSwitching(input: UseThemeSwitchingInput): ThemeSwitchingResult;
+//#endregion
+//#region ../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/observable.d.ts
+/**
+ * Handles named events.
+ *
+ * @deprecated
+ * @template N
+ */
+declare class Observable<N> {
+  /**
+   * Some desc.
+   * @type {Map<N, any>}
+   */
+  _observers: Map<N, any>;
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  on(name: N, f: Function): void;
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  once(name: N, f: Function): void;
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  off(name: N, f: Function): void;
+  /**
+   * Emit a named event. All registered event listeners that listen to the
+   * specified name will receive the event.
+   *
+   * @todo This should catch exceptions
+   *
+   * @param {N} name The event name.
+   * @param {Array<any>} args The arguments that are applied to the event listener.
+   */
+  emit(name: N, args: Array<any>): void;
+  destroy(): void;
+}
+//#endregion
+//#region ../../node_modules/.bun/y-protocols@1.0.7+253afa400b9c0a30/node_modules/y-protocols/awareness.d.ts
+/**
+ * @typedef {Object} MetaClientState
+ * @property {number} MetaClientState.clock
+ * @property {number} MetaClientState.lastUpdated unix timestamp
+ */
+/**
+ * The Awareness class implements a simple shared state protocol that can be used for non-persistent data like awareness information
+ * (cursor, username, status, ..). Each client can update its own local state and listen to state changes of
+ * remote clients. Every client may set a state of a remote peer to `null` to mark the client as offline.
+ *
+ * Each client is identified by a unique client id (something we borrow from `doc.clientID`). A client can override
+ * its own state by propagating a message with an increasing timestamp (`clock`). If such a message is received, it is
+ * applied if the known state of that client is older than the new state (`clock < newClock`). If a client thinks that
+ * a remote client is offline, it may propagate a message with
+ * `{ clock: currentClientClock, state: null, client: remoteClient }`. If such a
+ * message is received, and the known clock of that client equals the received clock, it will override the state with `null`.
+ *
+ * Before a client disconnects, it should propagate a `null` state with an updated clock.
+ *
+ * Awareness states must be updated every 30 seconds. Otherwise the Awareness instance will delete the client state.
+ *
+ * @extends {Observable<string>}
+ */
+declare class Awareness extends Observable<string> {
+  /**
+   * @param {Y.Doc} doc
+   */
+  constructor(doc: Y.Doc);
+  doc: Y.Doc;
+  /**
+   * @type {number}
+   */
+  clientID: number;
+  /**
+   * Maps from client id to client state
+   * @type {Map<number, Object<string, any>>}
+   */
+  states: Map<number, {
+    [x: string]: any;
+  }>;
+  /**
+   * @type {Map<number, MetaClientState>}
+   */
+  meta: Map<number, MetaClientState>;
+  _checkInterval: any;
+  /**
+   * @return {Object<string,any>|null}
+   */
+  getLocalState(): {
+    [x: string]: any;
+  } | null;
+  /**
+   * @param {Object<string,any>|null} state
+   */
+  setLocalState(state: {
+    [x: string]: any;
+  } | null): void;
+  /**
+   * @param {string} field
+   * @param {any} value
+   */
+  setLocalStateField(field: string, value: any): void;
+  /**
+   * @return {Map<number,Object<string,any>>}
+   */
+  getStates(): Map<number, {
+    [x: string]: any;
+  }>;
+}
+type MetaClientState = {
+  clock: number;
+  /**
+   * unix timestamp
+   */
+  lastUpdated: number;
+};
+//#endregion
+//#region src/viewer/hooks/collaboration/useYjsProvider.d.ts
+interface UseYjsProviderInput {
+  /**
+   * Collaboration config, or `undefined` when collaboration is inactive. The
+   * hook is always called (React hook rules) but stays fully dormant, never
+   * opening a transport, while config is absent.
+   */
+  config?: CollaborationConfig$1;
+}
+interface UseYjsProviderResult {
+  /** Current WebSocket connection status. */
+  status: ConnectionStatus;
+  /** The Yjs awareness instance (null until connected). */
+  awareness: Awareness | null;
+  /** The Yjs document (null until initialised). */
+  doc: YDoc | null;
+  /** Local awareness client ID. */
+  clientId: number | null;
+  /**
+   * Whether the provider completed its initial document sync. Local doc
+   * writes should be gated on this so a late joiner never seeds its
+   * bootstrap deck into a room whose content has not arrived yet. Websocket
+   * flips it on the provider's 'synced' event; webrtc flips it on peer sync
+   * or after {@link INITIAL_SYNC_GRACE_MS} (a lone fresh-room peer never
+   * receives a sync event).
+   */
+  synced: boolean;
+  /** Manually retry the connection after a timeout or error. */
+  retry: () => void;
+}
+/**
+ * Lazily loads `yjs` and `y-websocket`, creates a Y.Doc and
+ * WebSocketProvider, and tracks the connection lifecycle.
+ *
+ * If the connection does not succeed within {@link CONNECTION_TIMEOUT_MS},
+ * the provider is torn down and status moves to `'error'`. The consumer
+ * can call `retry()` to attempt a fresh connection.
+ *
+ * The Yjs packages are dynamically imported so they are fully
+ * tree-shaken when collaboration is not enabled.
+ */
+declare function useYjsProvider({ config }: UseYjsProviderInput): UseYjsProviderResult;
+//#endregion
+//#region src/viewer/hooks/collaboration/usePresenceTracking.d.ts
+interface UsePresenceTrackingInput {
+  awareness: Awareness | null;
+  localClientId: number | null;
+  userName: string;
+  userColor: string;
+  userAvatar?: string;
+  /** Role in the session (broadcaster, viewer, or collaborator). */
+  role?: string;
+  canvasWidth: number;
+  canvasHeight: number;
+}
+interface UsePresenceTrackingResult {
+  /** Presence data for all remote users (excludes local). */
+  remoteUsers: UserPresence[];
+  /** Broadcast a partial presence update for the local user. */
+  broadcastPresence: (update: Partial<Omit<UserPresence, 'clientId'>>) => void;
+}
+declare function usePresenceTracking({ awareness, localClientId, userName, userColor, userAvatar, role, canvasWidth, canvasHeight }: UsePresenceTrackingInput): UsePresenceTrackingResult;
+//#endregion
+//#region src/viewer/hooks/collaboration/useCollaborativeState.d.ts
+interface UseCollaborativeStateInput {
+  /**
+   * Collaboration config, or `undefined` when collaboration is inactive. The
+   * hook is always called so the surrounding provider keeps a stable React
+   * tree shape; it produces a dormant value (no transport, empty presence)
+   * while config is absent.
+   */
+  config?: CollaborationConfig$1;
+  canvasWidth: number;
+  canvasHeight: number;
+}
+declare function useCollaborativeState({ config, canvasWidth, canvasHeight }: UseCollaborativeStateInput): CollaborationContextValue | null;
+//#endregion
+//#region src/viewer/hooks/collaboration/useCollaborativeHistory.d.ts
+interface UseCollaborativeHistoryInput {
+  /** The local user's client ID (from Yjs awareness). */
+  localClientId: number | null;
+  /** Standard history undo function. */
+  handleUndo: () => void;
+  /** Standard history redo function. */
+  handleRedo: () => void;
+  /** Whether undo is available. */
+  canUndo: boolean;
+  /** Whether redo is available. */
+  canRedo: boolean;
+}
+interface UseCollaborativeHistoryResult {
+  /** Undo the last local change. */
+  handleUndo: () => void;
+  /** Redo the last undone local change. */
+  handleRedo: () => void;
+  /** Whether undo is available. */
+  canUndo: boolean;
+  /** Whether redo is available. */
+  canRedo: boolean;
+}
+declare function useCollaborativeHistory({ localClientId: _localClientId, handleUndo, handleRedo, canUndo, canRedo }: UseCollaborativeHistoryInput): UseCollaborativeHistoryResult;
+//#endregion
+//#region src/viewer/hooks/collaboration/useYjsDocumentSync.d.ts
+interface UseYjsDocumentSyncInput {
+  /** The Yjs document (from useYjsProvider). null when not collaborating. */
+  doc: Doc | null;
+  /** Current slides state. */
+  slides: PptxSlide[];
+  /** Separated master/layout (template) elements, merged back on write-back. */
+  templateElementsBySlideId: Record<string, PptxElement[]>;
+  /** React state setter for slides. */
+  setSlides: React.Dispatch<React.SetStateAction<PptxSlide[]>>;
+  /** Whether collaboration is active (status === 'connected'). */
+  isConnected: boolean;
+  /**
+   * Whether the provider completed its initial document sync. Local -> doc
+   * writes are gated on this so a late joiner never seeds its bootstrap deck
+   * into a room whose real content has not arrived yet. Defaults to true for
+   * callers that manage sync readiness themselves.
+   */
+  isSynced?: boolean;
+  /** Collaboration config (for role and write-back). */
+  config?: Pick<CollaborationConfig, 'role' | 'onWriteBack' | 'writeBackDebounceMs'>;
+  /**
+   * Return the source PPTX bytes for write-back serialization. Only called
+   * when role === 'owner' and onWriteBack is set.
+   */
+  getSourceBytes?: () => Uint8Array | null;
+}
+declare function useYjsDocumentSync({ doc, slides, templateElementsBySlideId, setSlides, isConnected, isSynced, config, getSourceBytes }: UseYjsDocumentSyncInput): void;
+//#endregion
+//#region src/viewer/hooks/collaboration/useBroadcastFollower.d.ts
+interface UseBroadcastFollowerInput {
+  /** The collaboration context (null when collaboration is disabled). */
+  collab: CollaborationContextValue | null;
+  /** Current local active slide index. */
+  activeSlideIndex: number;
+  /** Setter for the active slide index. */
+  setActiveSlideIndex: (index: number) => void;
+  /** Total number of slides (for bounds checking). */
+  slideCount: number;
+  /**
+   * When true, auto-follow stands down (e.g. the local user is manually
+   * following a specific peer via the follow bar). Defaults to false.
+   */
+  paused?: boolean;
+}
+declare function useBroadcastFollower({ collab, activeSlideIndex, setActiveSlideIndex, slideCount, paused }: UseBroadcastFollowerInput): void;
+//#endregion
+//#region src/viewer/hooks/collaboration/useFollowMode.d.ts
+interface UseFollowModeInput {
+  /** The collaboration context (null when collaboration is disabled). */
+  collab: CollaborationContextValue | null;
+  /** Current local active slide index. */
+  activeSlideIndex: number;
+  /** Setter for the active slide index. */
+  setActiveSlideIndex: (index: number) => void;
+  /** Total number of slides (for bounds checking). */
+  slideCount: number;
+}
+interface UseFollowModeResult {
+  /** The clientId currently being followed, or null. */
+  followedClientId: number | null;
+  /** Follow the given peer, or `null` to stop following. */
+  followUser: (clientId: number | null) => void;
+}
+declare function useFollowMode({ collab, activeSlideIndex, setActiveSlideIndex, slideCount }: UseFollowModeInput): UseFollowModeResult;
+//#endregion
+//#region src/viewer/hooks/presentation-mode/useAnimationPlayback.d.ts
+interface UseAnimationPlaybackInput {
+  slides: PptxSlide[];
+  onPlayActionSound?: (soundPath: string) => void;
+  /** When false, all animations are skipped (elements shown immediately). */
+  showWithAnimation?: boolean;
+}
+interface UseAnimationPlaybackResult {
+  presentationAnimations: PresentationAnimationRuntime[];
+  presentationElementStates: Map<string, ElementAnimationState>;
+  presentationKeyframesCss: string;
+  interactiveTriggerShapeIds: ReadonlySet<string>;
+  hoverTriggerShapeIds: ReadonlySet<string>;
+  clearPresentationTimers: () => void;
+  playNextAnimationGroup: () => boolean;
+  handleInteractiveShapeClick: (shapeId: string) => boolean;
+  handleHoverStart: (shapeId: string) => boolean;
+  handleHoverEnd: (shapeId: string) => void;
+  runPresentationEntranceAnimations: (slideIndex: number) => void;
+  /** Exposed so the orchestrator can schedule additional timers (e.g. auto-advance). */
+  presentationTimersRef: React.RefObject<number[]>;
+}
+declare function useAnimationPlayback(input: UseAnimationPlaybackInput): UseAnimationPlaybackResult;
+//#endregion
+//#region src/viewer/hooks/presentation-mode/useRehearsalTimings.d.ts
+interface UseRehearsalTimingsInput {
+  containerRef: React.RefObject<HTMLElement | null>;
+  onSetMode: (mode: ViewerMode$1) => void;
+  onSaveRehearsalTimings?: (timings: Record<number, number>) => void;
+  setPresentationStartTime: (time: number | null) => void;
+  setPresenterMode: (mode: boolean) => void;
+}
+interface UseRehearsalTimingsResult {
+  rehearsing: boolean;
+  setRehearsing: React.Dispatch<React.SetStateAction<boolean>>;
+  recordedTimings: Record<number, number>;
+  slideStartTime: number | null;
+  showRehearsalSummary: boolean;
+  setShowRehearsalSummary: React.Dispatch<React.SetStateAction<boolean>>;
+  rehearsalPaused: boolean;
+  recordCurrentSlideTime: (slideIndex: number) => void;
+  dismissRehearsalSummary: () => void;
+  saveRehearsalTimings: () => void;
+  enterRehearsalMode: () => void;
+  toggleRehearsalPause: () => void;
+}
+declare function useRehearsalTimings(input: UseRehearsalTimingsInput): UseRehearsalTimingsResult;
+//#endregion
+//#region src/viewer/hooks/presentation-mode/usePresentationKeyboard.d.ts
+interface UsePresentationKeyboardInput {
+  mode: ViewerMode$1;
+  movePresentationSlide: (direction: 1 | -1) => void;
+  onSetMode: (mode: ViewerMode$1) => void;
+  onToggleLaser?: () => void;
+  onTogglePen?: () => void;
+  onToggleEraser?: () => void;
+  onToggleToolbar?: () => void;
+  /** Toggle between presenter view (split-screen with notes) and fullscreen. */
+  onTogglePresenterView?: () => void;
+  rehearsing: boolean;
+  recordCurrentSlideTime: (slideIndex: number) => void;
+  presentationSlideIndex: number;
+  setShowRehearsalSummary: (value: boolean) => void;
+}
+/**
+ * Registers keyboard shortcuts for presentation mode: arrow/space
+ * for slide navigation, Escape to exit, and annotation tool toggles.
+ */
+declare function usePresentationKeyboard(input: UsePresentationKeyboardInput): void;
+//#endregion
+//#region src/viewer/hooks/presentation-mode/useSlideNavigation.d.ts
+interface UseSlideNavigationInput {
+  slides: PptxSlide[];
+  visibleSlideIndexes: number[];
+  presentationSlideIndex: number;
+  setPresentationSlideIndex: (index: number) => void;
+  setPresentationSlideVisible: (visible: boolean) => void;
+  setTransitionOverlay: (state: PresentationTransitionOverlayState | null) => void;
+  onSetMode: (mode: ViewerMode$1) => void;
+  onSetActiveSlideIndex: (index: number) => void;
+  onPlayActionSound?: (soundPath: string) => void;
+  loopContinuously?: boolean;
+  /** Whether to use rehearsed auto-advance timings. When false, slides advance only on click. */
+  useTimings?: boolean;
+  playNextAnimationGroup: () => boolean;
+  clearPresentationTimers: () => void;
+  runPresentationEntranceAnimations: (slideIndex: number) => void;
+  presentationTimersRef: {
+    current: number[];
+  };
+  rehearsing: boolean;
+  recordCurrentSlideTime: (slideIndex: number) => void;
+  setShowRehearsalSummary: (value: boolean) => void;
+}
+interface UseSlideNavigationResult {
+  movePresentationSlide: (direction: 1 | -1) => void;
+  navigateToSlide: (slideIndex: number) => void;
+  handlePresentationAction: (action: PptxAction) => void;
+  scheduleAutoAdvanceForSlide: (slideIndex: number) => void;
+}
+declare function useSlideNavigation(input: UseSlideNavigationInput): UseSlideNavigationResult;
+//#endregion
+//#region src/viewer/hooks/presentation-mode/usePresenterWindow.d.ts
+/** Returns true if the current page was opened as an audience tab. */
+declare function isAudienceTab(): boolean;
+interface UsePresenterWindowInput {
+  currentSlideIndex: number;
+  isPresenterMode: boolean;
+  /** Raw PPTX bytes to share with the audience tab via IndexedDB. */
+  content?: ArrayBuffer | Uint8Array | null;
+}
+interface UsePresenterWindowResult {
+  openAudienceWindow: () => boolean;
+  closeAudienceWindow: () => void;
+  isAudienceWindowOpen: () => boolean;
+  syncSlideToAudience: (slideIndex: number) => void;
+}
+declare function usePresenterWindow(input: UsePresenterWindowInput): UsePresenterWindowResult;
+//#endregion
+//#region src/viewer/hooks/presentation-mode/useAudienceMode.d.ts
+interface UseAudienceModeInput {
+  mode: ViewerMode$1;
+  onSetMode: (mode: ViewerMode$1) => void;
+  onSetActiveSlideIndex: (index: number) => void;
+  containerRef: React.RefObject<HTMLElement | null>;
+}
+/**
+ * When the page was opened with the `#pptx-audience` hash, this hook:
+ * 1. Auto-enters fullscreen presentation mode after content loads
+ * 2. Listens on BroadcastChannel for slide-change messages from the presenter
+ * 3. Exits presentation mode when the presenter sends an exit signal
+ */
+declare function useAudienceMode(input: UseAudienceModeInput): void;
+//#endregion
+export { usePresenceTracking as A, UseCollaborativeHistoryInput as C, useCollaborativeState as D, UseCollaborativeStateInput as E, UseThemeSwitchingInput as F, useThemeSwitching as I, UsePresentationModeInput as L, UseYjsProviderResult as M, useYjsProvider as N, UsePresenceTrackingInput as O, ThemeSwitchingResult as P, UsePresentationModeResult as R, useYjsDocumentSync as S, useCollaborativeHistory as T, UseFollowModeResult as _, usePresenterWindow as a, useBroadcastFollower as b, useSlideNavigation as c, UseRehearsalTimingsResult as d, useRehearsalTimings as f, UseFollowModeInput as g, useAnimationPlayback as h, isAudienceTab as i, UseYjsProviderInput as j, UsePresenceTrackingResult as k, usePresentationKeyboard as l, UseAnimationPlaybackResult as m, UsePresenterWindowInput as n, UseSlideNavigationInput as o, UseAnimationPlaybackInput as p, UsePresenterWindowResult as r, UseSlideNavigationResult as s, useAudienceMode as t, UseRehearsalTimingsInput as u, useFollowMode as v, UseCollaborativeHistoryResult as w, UseYjsDocumentSyncInput as x, UseBroadcastFollowerInput as y };
+//# sourceMappingURL=index-XGt7MZpa.d.ts.map

package/dist/index-XGt7MZpa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-XGt7MZpa.d.ts","names":[],"sources":["../src/viewer/hooks/presentation-mode/types.ts","../src/viewer/hooks/useThemeSwitching.ts","../../../node_modules/.bun/lib0@0.2.117/node_modules/lib0/observable.d.ts","../../../node_modules/.bun/y-protocols@1.0.7+253afa400b9c0a30/node_modules/y-protocols/awareness.d.ts","../src/viewer/hooks/collaboration/useYjsProvider.ts","../src/viewer/hooks/collaboration/usePresenceTracking.ts","../src/viewer/hooks/collaboration/useCollaborativeState.ts","../src/viewer/hooks/collaboration/useCollaborativeHistory.ts","../src/viewer/hooks/collaboration/useYjsDocumentSync.ts","../src/viewer/hooks/collaboration/useBroadcastFollower.ts","../src/viewer/hooks/collaboration/useFollowMode.ts","../src/viewer/hooks/presentation-mode/useAnimationPlayback.ts","../src/viewer/hooks/presentation-mode/useRehearsalTimings.ts","../src/viewer/hooks/presentation-mode/usePresentationKeyboard.ts","../src/viewer/hooks/presentation-mode/useSlideNavigation.ts","../src/viewer/hooks/presentation-mode/usePresenterWindow.ts","../src/viewer/hooks/presentation-mode/useAudienceMode.ts"],"x_google_ignoreList":[2,3],"mappings":";;;;;;;;;;;;;UAeiB;;EAEhB;;EAEA;;EAEA,YAAY;;EAEZ;;UAOgB;EAChB,MAAM;EACN,QAAQ;EACR;EACA;EACA,cAAc,MAAM,UAAU;;EAE9B,UAAU,cAAc;EACxB,YAAY,MAAM;EAClB,wBAAwB;EACxB,qBAAqB;;EAErB;;EAEA;;EAEA;;EAEA;;EAEA,0BAA0B,SAAS;;EAEnC;;EAEA;;EAEA;;UAGgB;EAChB;EACA,4BAA4B;EAC5B;;EAEA,mBAAmB;;EAEnB;EACA,wBAAwB;EACxB,2BAA2B,YAAY;EACvC;EACA;EACA,oCAAoC;EACpC,wBAAwB;EACxB,kBAAkB;EAClB,2BAA2B,QAAQ;;;;;EAKnC,8BAA8B;;EAE9B,4BAA4B;;EAE5B,sBAAsB;;EAEtB,mBAAmB;;EAEnB,iBAAiB;;EAEjB;;EAEA;;EAEA;;EAEA;;EAEA;;EAGA;;EAEA;;EAEA,iBAAiB;;EAEjB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAGA,kBAAkB,0BAA0B;;EAE5C,sBAAsB,MAAM;;EAE5B;;EAEA;;EAGA;;EAEA;;EAEA;;EAEA,sBAAsB;;;;UCjHN;;EAEhB,YAAY,UAAU;;EAEtB,MAAM;;EAEN,eAAe,SAAS;;EAExB,kBAAkB,QAAQ;;UAGV;;EAEhB,kBAAkB;;;;;EAMlB,iBAAiB,QAAQ,oBAAoB;;;;;EAM7C,iBACC,aAAa,sBACb,aAAa,qBACb,uBACI;;;;;EAML,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DA,kBAAkB,OAAO,yBAAyB;;;;;;;;;cCjErD,WAAW;;;;;EAKpB,YAAY,IAAI;;;;;EAKhB,GAAG,MAAM,GAAG,GAAG;;;;;EAKf,KAAK,MAAM,GAAG,GAAG;;;;;EAKjB,IAAI,MAAM,GAAG,GAAG;;;;;;;;;;EAUhB,KAAK,MAAM,GAAG,MAAM;EACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;cC3DS,kBAAkB;;;;EAI3B,YAAY,KAAK,EAAE;EACnB,KAAK,EAAE;;;;EAIP;;;;;EAKA,QAAQ;KACH;;;;;EAKL,MAAM,YAAY;EAClB;;;;EAIA;KACK;;;;;EAKL,cAAc;KACT;;;;;;EAML,mBAAmB,eAAe;;;;EAIlC,aAAa;KACR;;;KASG;EACR;;;;EAIA;;;;UCjCa;;;;;;EAMhB,SAAS;;UAGO;;EAEhB,QAAQ;;EAER,WAAW;;EAEX,KAAK;;EAEL;;;;;;;;;EASA;;EAEA;;;;;;;;;;;;;iBAkBe,iBAAiB,UAAU,sBAAsB;;;UC7EhD;EAChB,WAAW;EACX;EACA;EACA;EACA;;EAEA;EACA;EACA;;UAGgB;;EAEhB,aAAa;;EAEb,oBAAoB,QAAQ,QAAQ,KAAK;;iBAO1B,sBACf,WACA,eACA,UACA,WACA,YACA,MACA,aACA,gBACE,2BAA2B;;;UC3Bb;;;;;;;EAOhB,SAAS;EACT;EACA;;iBAOe,wBACf,QACA,aACA,gBACE,6BAA6B;;;UCvBf;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;UAGgB;;EAEhB;;EAEA;;EAEA;;EAEA;;iBAOe,0BACf,eAAe,gBACf,YACA,YACA,SACA,WACE,+BAA+B;;;UC3BjB;;EAEhB,KAAK;;EAEL,QAAQ;;EAER,2BAA2B,eAAe;;EAE1C,WAAW,MAAM,SAAS,MAAM,eAAe;;EAE/C;;;;;;;EAOA;;EAEA,SAAS,KAAK;;;;;EAKd,uBAAuB;;iBAGR,qBACf,KACA,QACA,2BACA,WACA,aACA,UACA,QACA,kBACE;;;UC7Cc;;EAEhB,QAAQ;;EAER;;EAEA,sBAAsB;;EAEtB;;;;;EAKA;;iBAOe,uBACf,QACA,kBACA,qBACA,YACA,UACE;;;UCxBc;;EAEhB,QAAQ;;EAER;;EAEA,sBAAsB;;EAEtB;;UAGgB;;EAEhB;;EAEA,aAAa;;iBAOE,gBACf,QACA,kBACA,qBACA,cACE,qBAAqB;;;UC3BP;EAChB,QAAQ;EACR,qBAAqB;;EAErB;;UAGgB;EAChB,wBAAwB;EACxB,2BAA2B,YAAY;EACvC;EACA,4BAA4B;EAC5B,sBAAsB;EACtB;EACA;EACA,8BAA8B;EAC9B,mBAAmB;EACnB,iBAAiB;EACjB,oCAAoC;;EAEpC,uBAAuB,MAAM;;iBAOd,qBAAqB,OAAO,4BAA4B;;;UCtCvD;EAChB,cAAc,MAAM,UAAU;EAC9B,YAAY,MAAM;EAClB,0BAA0B,SAAS;EACnC,2BAA2B;EAC3B,mBAAmB;;UAGH;EAChB;EACA,eAAe,MAAM,SAAS,MAAM;EACpC,iBAAiB;EACjB;EACA;EACA,yBAAyB,MAAM,SAAS,MAAM;EAC9C;EACA,yBAAyB;EACzB;EACA;EACA;EACA;;iBAOe,oBAAoB,OAAO,2BAA2B;;;UC1BrD;EAChB,MAAM;EACN,wBAAwB;EACxB,YAAY,MAAM;EAClB;EACA;EACA;EACA;;EAEA;EACA;EACA,yBAAyB;EACzB;EACA,0BAA0B;;;;;;iBAWX,wBAAwB,OAAO;;;UCrB9B;EAChB,QAAQ;EACR;EACA;EACA,4BAA4B;EAC5B,8BAA8B;EAC9B,uBAAuB,OAAO;EAC9B,YAAY,MAAM;EAClB,wBAAwB;EACxB,qBAAqB;EACrB;;EAEA;EACA;EACA;EACA,oCAAoC;EACpC;IAAyB;;EACzB;EACA,yBAAyB;EACzB,0BAA0B;;UAGV;EAChB,wBAAwB;EACxB,kBAAkB;EAClB,2BAA2B,QAAQ;EACnC,8BAA8B;;iBAOf,mBAAmB,OAAO,0BAA0B;;;;iBCuDpD;UAQC;EAChB;EACA;;EAEA,UAAU,cAAc;;UAGR;EAChB;EACA;EACA;EACA,sBAAsB;;iBAOP,mBAAmB,OAAO,0BAA0B;;;UC9GnD;EAChB,MAAM;EACN,YAAY,MAAM;EAClB,wBAAwB;EACxB,cAAc,MAAM,UAAU;;;;;;;;iBASf,gBAAgB,OAAO"}