pptx-react-viewer 2.2.1 → 2.4.0

package/dist/audience-content-store-BMlth_3U.d.ts

@@ -0,0 +1,386 @@
+import { C as CollaborationConfig$1, D as UserPresence, E as ConnectionStatus, w as CollaborationContextValue } from "./types-DciBT90G.js";
+import { PptxData, PptxElement, PptxHandler, PptxSlide, PptxThemeColorScheme, PptxThemeFontScheme, PptxThemePreset } from "pptx-viewer-core";
+import { CollaborationConfig, CollaborationLivePatcher, PresentationSnapshot, clearAudienceContent, loadAudienceContent, storeAudienceContent } from "pptx-viewer-shared";
+import { RefObject } from "react";
+import * as Y from "yjs";
+import { Doc, Doc as YDoc } from "yjs";
+//#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;
+  /**
+   * Monotonic counter bumped each time the content-load pipeline finishes
+   * applying a parsed deck to viewer state. A local load that lands while the
+   * shared doc already holds slides (a late joiner's bootstrap deck parsing
+   * after the room state arrived) would silently clobber the synced slides;
+   * each bump re-adopts the doc's slides when the room has content.
+   */
+  loadVersion?: number;
+}
+declare function useYjsDocumentSync({ doc, slides, templateElementsBySlideId, setSlides, isConnected, isSynced, config, getSourceBytes, loadVersion }: 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/usePresenterWindow.d.ts
+/**
+ * Parse the session nonce from the current page URL hash. Returns null if the
+ * hash is not in the expected `#pptx-audience&nonce=<uuid>` form.
+ */
+declare function parseAudienceNonce(): string | null;
+/** 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;
+  snapshot: PresentationSnapshot;
+}
+interface UsePresenterWindowResult {
+  openAudienceWindow: () => boolean;
+  closeAudienceWindow: () => void;
+  isAudienceWindowOpen: () => boolean;
+  syncSlideToAudience: (slideIndex: number) => void;
+  syncStateToAudience: (snapshot: PresentationSnapshot) => void;
+  swapDisplays: () => Promise<boolean>;
+}
+declare function usePresenterWindow(input: UsePresenterWindowInput): UsePresenterWindowResult;
+//#endregion
+export { usePresenceTracking as C, ThemeSwitchingResult as D, useYjsProvider as E, UseThemeSwitchingInput as O, UsePresenceTrackingResult as S, UseYjsProviderResult as T, UseCollaborativeHistoryResult as _, UsePresenterWindowResult as a, useCollaborativeState as b, usePresenterWindow as c, useFollowMode as d, UseBroadcastFollowerInput as f, UseCollaborativeHistoryInput as g, useYjsDocumentSync as h, UsePresenterWindowInput as i, useThemeSwitching as k, UseFollowModeInput as l, UseYjsDocumentSyncInput as m, loadAudienceContent as n, isAudienceTab as o, useBroadcastFollower as p, storeAudienceContent as r, parseAudienceNonce as s, clearAudienceContent as t, UseFollowModeResult as u, useCollaborativeHistory as v, UseYjsProviderInput as w, UsePresenceTrackingInput as x, UseCollaborativeStateInput as y };
+//# sourceMappingURL=audience-content-store-BMlth_3U.d.ts.map

package/dist/audience-content-store-BMlth_3U.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audience-content-store-BMlth_3U.d.ts","names":[],"sources":["../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/usePresenterWindow.ts"],"x_google_ignoreList":[1,2],"mappings":";;;;;;;UAqBiB;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCA,kBAAkB,OAAO,yBAAyB;;;;;;;;;cCrCrD,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;;;;UC9Ba;;;;;;EAMhB,SAAS;;UAGO;;EAEhB,QAAQ;;EAER,WAAW;;EAEX,KAAK;;EAEL;;;;;;;;;EASA;;EAEA;;;;;;;;;;;;;iBAkBe,iBAAiB,UAAU,sBAAsB;;;UChFhD;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;;;UC1BjB;;EAEhB,KAAK;;EAEL,QAAQ;;EAER,2BAA2B,eAAe;;EAE1C,WAAW,MAAM,SAAS,MAAM,eAAe;;EAE/C;;;;;;;EAOA;;EAEA,SAAS,KAAK;;;;;EAKd,uBAAuB;;;;;;;;EAQvB;;iBAGe,qBACf,KACA,QACA,2BACA,WACA,aACA,UACA,QACA,gBACA,eACE;;;UCtDc;;EAEhB,QAAQ;;EAER;;EAEA,sBAAsB;;EAEtB;;;;;EAKA;;iBAOe,uBACf,QACA,kBACA,qBACA,YACA,UACE;;;UCzBc;;EAEhB,QAAQ;;EAER;;EAEA,sBAAsB;;EAEtB;;UAGgB;;EAEhB;;EAEA,aAAa;;iBAOE,gBACf,QACA,kBACA,qBACA,cACE,qBAAqB;;;;;;;iBCgBR;;iBAkDA;UAQC;EAChB;EACA;;EAEA,UAAU,cAAc;EACxB,UAAU;;UAGM;EAChB;EACA;EACA;EACA,sBAAsB;EACtB,sBAAsB,UAAU;EAChC,oBAAoB;;iBAOL,mBAAmB,OAAO,0BAA0B"}

package/dist/{chunk-YIFO3WQO.js → chunk-25VSL2BB.js}

@@ -377,6 +377,7 @@ var translationsEn = {
   "pptx.presentation.highlighter": "Highlighter",
   "pptx.presentation.eraser": "Eraser",
   "pptx.presentation.laserPointer": "Laser Pointer",
+  "pptx.presentation.endOfSlideShow": "End of slide show, click to exit.",
   "pptx.presentation.pointerTools": "Pointer Options",
   // Selection pane
   "pptx.selectionPane.title": "Selection Pane",

package/dist/{chunk-XJTWUXXC.js → chunk-5GHLRHBR.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkR2H3FHK6_js = require('./chunk-R2H3FHK6.js');
+var chunkWK56SFN7_js = require('./chunk-WK56SFN7.js');
 var chunk4VNS5WPM_js = require('./chunk-4VNS5WPM.js');
 var mcp = require('pptx-viewer-mcp');
 var mcpSchemas = require('pptx-viewer-mcp/schemas');
@@ -14879,7 +14879,7 @@ async function buildSlideMarkdown(slides, slideIndex2, meta3, options = {}) {
   };
   let markdown;
   try {
-    const converter = new chunkR2H3FHK6_js.PptxMarkdownConverter(
+    const converter = new chunkWK56SFN7_js.PptxMarkdownConverter(
       "",
       {
         sourceName: meta3.title ?? "deck.pptx",
@@ -15470,7 +15470,7 @@ var getTheme = (ctx) => {
     name: theme?.name,
     colorScheme: theme?.colorScheme,
     fontScheme: theme?.fontScheme,
-    availablePresets: Object.keys(chunkR2H3FHK6_js.ThemePresets)
+    availablePresets: Object.keys(chunkWK56SFN7_js.ThemePresets)
   };
 };
 var readExecutors = {