@aixa-transformation/pptx-viewer 2.0.2

package/dist/y-websocket-WMSHYIGX.js

@@ -0,0 +1,384 @@
+'use strict';
+
+var chunkY6FQDUJU_js = require('./chunk-Y6FQDUJU.js');
+require('./chunk-QGM4M3NI.js');
+require('yjs');
+
+var messagePermissionDenied = 0;
+var readAuthMessage = (decoder, y, permissionDeniedHandler2) => {
+  switch (chunkY6FQDUJU_js.readVarUint(decoder)) {
+    case messagePermissionDenied:
+      permissionDeniedHandler2(y, chunkY6FQDUJU_js.readVarString(decoder));
+  }
+};
+
+// ../../node_modules/lib0/url.js
+var encodeQueryParams = (params) => chunkY6FQDUJU_js.map2(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join("&");
+
+// ../../node_modules/y-websocket/src/y-websocket.js
+var messageSync = 0;
+var messageQueryAwareness = 3;
+var messageAwareness = 1;
+var messageAuth = 2;
+var messageHandlers = [];
+messageHandlers[messageSync] = (encoder, decoder, provider, emitSynced, _messageType) => {
+  chunkY6FQDUJU_js.writeVarUint(encoder, messageSync);
+  const syncMessageType = chunkY6FQDUJU_js.readSyncMessage(
+    decoder,
+    encoder,
+    provider.doc,
+    provider
+  );
+  if (emitSynced && syncMessageType === chunkY6FQDUJU_js.messageYjsSyncStep2 && !provider.synced) {
+    provider.synced = true;
+  }
+};
+messageHandlers[messageQueryAwareness] = (encoder, _decoder, provider, _emitSynced, _messageType) => {
+  chunkY6FQDUJU_js.writeVarUint(encoder, messageAwareness);
+  chunkY6FQDUJU_js.writeVarUint8Array(
+    encoder,
+    chunkY6FQDUJU_js.encodeAwarenessUpdate(
+      provider.awareness,
+      Array.from(provider.awareness.getStates().keys())
+    )
+  );
+};
+messageHandlers[messageAwareness] = (_encoder, decoder, provider, _emitSynced, _messageType) => {
+  chunkY6FQDUJU_js.applyAwarenessUpdate(
+    provider.awareness,
+    chunkY6FQDUJU_js.readVarUint8Array(decoder),
+    provider
+  );
+};
+messageHandlers[messageAuth] = (_encoder, decoder, provider, _emitSynced, _messageType) => {
+  readAuthMessage(
+    decoder,
+    provider.doc,
+    (_ydoc, reason) => permissionDeniedHandler(provider, reason)
+  );
+};
+var messageReconnectTimeout = 3e4;
+var permissionDeniedHandler = (provider, reason) => console.warn(`Permission denied to access ${provider.url}.
+${reason}`);
+var readMessage = (provider, buf, emitSynced) => {
+  const decoder = chunkY6FQDUJU_js.createDecoder(buf);
+  const encoder = chunkY6FQDUJU_js.createEncoder();
+  const messageType = chunkY6FQDUJU_js.readVarUint(decoder);
+  const messageHandler = provider.messageHandlers[messageType];
+  if (
+    /** @type {any} */
+    messageHandler
+  ) {
+    messageHandler(encoder, decoder, provider, emitSynced, messageType);
+  } else {
+    console.error("Unable to compute message");
+  }
+  return encoder;
+};
+var closeWebsocketConnection = (provider, ws, event) => {
+  if (ws === provider.ws) {
+    provider.emit("connection-close", [event, provider]);
+    provider.ws = null;
+    ws.close();
+    provider.wsconnecting = false;
+    if (provider.wsconnected) {
+      provider.wsconnected = false;
+      provider.synced = false;
+      chunkY6FQDUJU_js.removeAwarenessStates(
+        provider.awareness,
+        Array.from(provider.awareness.getStates().keys()).filter(
+          (client) => client !== provider.doc.clientID
+        ),
+        provider
+      );
+      provider.emit("status", [{
+        status: "disconnected"
+      }]);
+    } else {
+      provider.wsUnsuccessfulReconnects++;
+    }
+    setTimeout(
+      setupWS,
+      chunkY6FQDUJU_js.min(
+        chunkY6FQDUJU_js.pow(2, provider.wsUnsuccessfulReconnects) * 100,
+        provider.maxBackoffTime
+      ),
+      provider
+    );
+  }
+};
+var setupWS = (provider) => {
+  if (provider.shouldConnect && provider.ws === null) {
+    const websocket = new provider._WS(provider.url, provider.protocols);
+    websocket.binaryType = "arraybuffer";
+    provider.ws = websocket;
+    provider.wsconnecting = true;
+    provider.wsconnected = false;
+    provider.synced = false;
+    websocket.onmessage = (event) => {
+      provider.wsLastMessageReceived = chunkY6FQDUJU_js.getUnixTime();
+      const encoder = readMessage(provider, new Uint8Array(event.data), true);
+      if (chunkY6FQDUJU_js.length(encoder) > 1) {
+        websocket.send(chunkY6FQDUJU_js.toUint8Array(encoder));
+      }
+    };
+    websocket.onerror = (event) => {
+      provider.emit("connection-error", [event, provider]);
+    };
+    websocket.onclose = (event) => {
+      closeWebsocketConnection(provider, websocket, event);
+    };
+    websocket.onopen = () => {
+      provider.wsLastMessageReceived = chunkY6FQDUJU_js.getUnixTime();
+      provider.wsconnecting = false;
+      provider.wsconnected = true;
+      provider.wsUnsuccessfulReconnects = 0;
+      provider.emit("status", [{
+        status: "connected"
+      }]);
+      const encoder = chunkY6FQDUJU_js.createEncoder();
+      chunkY6FQDUJU_js.writeVarUint(encoder, messageSync);
+      chunkY6FQDUJU_js.writeSyncStep1(encoder, provider.doc);
+      websocket.send(chunkY6FQDUJU_js.toUint8Array(encoder));
+      if (provider.awareness.getLocalState() !== null) {
+        const encoderAwarenessState = chunkY6FQDUJU_js.createEncoder();
+        chunkY6FQDUJU_js.writeVarUint(encoderAwarenessState, messageAwareness);
+        chunkY6FQDUJU_js.writeVarUint8Array(
+          encoderAwarenessState,
+          chunkY6FQDUJU_js.encodeAwarenessUpdate(provider.awareness, [
+            provider.doc.clientID
+          ])
+        );
+        websocket.send(chunkY6FQDUJU_js.toUint8Array(encoderAwarenessState));
+      }
+    };
+    provider.emit("status", [{
+      status: "connecting"
+    }]);
+  }
+};
+var broadcastMessage = (provider, buf) => {
+  const ws = provider.ws;
+  if (provider.wsconnected && ws && ws.readyState === ws.OPEN) {
+    ws.send(buf);
+  }
+  if (provider.bcconnected) {
+    chunkY6FQDUJU_js.publish(provider.bcChannel, buf, provider);
+  }
+};
+var WebsocketProvider = class extends chunkY6FQDUJU_js.ObservableV2 {
+  /**
+   * @param {string} serverUrl
+   * @param {string} roomname
+   * @param {Y.Doc} doc
+   * @param {object} opts
+   * @param {boolean} [opts.connect]
+   * @param {awarenessProtocol.Awareness} [opts.awareness]
+   * @param {Object<string,string>} [opts.params] specify url parameters
+   * @param {Array<string>} [opts.protocols] specify websocket protocols
+   * @param {typeof WebSocket} [opts.WebSocketPolyfill] Optionall provide a WebSocket polyfill
+   * @param {number} [opts.resyncInterval] Request server state every `resyncInterval` milliseconds
+   * @param {number} [opts.maxBackoffTime] Maximum amount of time to wait before trying to reconnect (we try to reconnect using exponential backoff)
+   * @param {boolean} [opts.disableBc] Disable cross-tab BroadcastChannel communication
+   */
+  constructor(serverUrl, roomname, doc, {
+    connect = true,
+    awareness = new chunkY6FQDUJU_js.Awareness(doc),
+    params = {},
+    protocols = [],
+    WebSocketPolyfill = WebSocket,
+    resyncInterval = -1,
+    maxBackoffTime = 2500,
+    disableBc = false
+  } = {}) {
+    super();
+    while (serverUrl[serverUrl.length - 1] === "/") {
+      serverUrl = serverUrl.slice(0, serverUrl.length - 1);
+    }
+    this.serverUrl = serverUrl;
+    this.bcChannel = serverUrl + "/" + roomname;
+    this.maxBackoffTime = maxBackoffTime;
+    this.params = params;
+    this.protocols = protocols;
+    this.roomname = roomname;
+    this.doc = doc;
+    this._WS = WebSocketPolyfill;
+    this.awareness = awareness;
+    this.wsconnected = false;
+    this.wsconnecting = false;
+    this.bcconnected = false;
+    this.disableBc = disableBc;
+    this.wsUnsuccessfulReconnects = 0;
+    this.messageHandlers = messageHandlers.slice();
+    this._synced = false;
+    this.ws = null;
+    this.wsLastMessageReceived = 0;
+    this.shouldConnect = connect;
+    this._resyncInterval = 0;
+    if (resyncInterval > 0) {
+      this._resyncInterval = /** @type {any} */
+      setInterval(() => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          const encoder = chunkY6FQDUJU_js.createEncoder();
+          chunkY6FQDUJU_js.writeVarUint(encoder, messageSync);
+          chunkY6FQDUJU_js.writeSyncStep1(encoder, doc);
+          this.ws.send(chunkY6FQDUJU_js.toUint8Array(encoder));
+        }
+      }, resyncInterval);
+    }
+    this._bcSubscriber = (data, origin) => {
+      if (origin !== this) {
+        const encoder = readMessage(this, new Uint8Array(data), false);
+        if (chunkY6FQDUJU_js.length(encoder) > 1) {
+          chunkY6FQDUJU_js.publish(this.bcChannel, chunkY6FQDUJU_js.toUint8Array(encoder), this);
+        }
+      }
+    };
+    this._updateHandler = (update, origin) => {
+      if (origin !== this) {
+        const encoder = chunkY6FQDUJU_js.createEncoder();
+        chunkY6FQDUJU_js.writeVarUint(encoder, messageSync);
+        chunkY6FQDUJU_js.writeUpdate(encoder, update);
+        broadcastMessage(this, chunkY6FQDUJU_js.toUint8Array(encoder));
+      }
+    };
+    this.doc.on("update", this._updateHandler);
+    this._awarenessUpdateHandler = ({ added, updated, removed }, _origin) => {
+      const changedClients = added.concat(updated).concat(removed);
+      const encoder = chunkY6FQDUJU_js.createEncoder();
+      chunkY6FQDUJU_js.writeVarUint(encoder, messageAwareness);
+      chunkY6FQDUJU_js.writeVarUint8Array(
+        encoder,
+        chunkY6FQDUJU_js.encodeAwarenessUpdate(awareness, changedClients)
+      );
+      broadcastMessage(this, chunkY6FQDUJU_js.toUint8Array(encoder));
+    };
+    this._exitHandler = () => {
+      chunkY6FQDUJU_js.removeAwarenessStates(
+        this.awareness,
+        [doc.clientID],
+        "app closed"
+      );
+    };
+    if (chunkY6FQDUJU_js.isNode && typeof process !== "undefined") {
+      process.on("exit", this._exitHandler);
+    }
+    awareness.on("update", this._awarenessUpdateHandler);
+    this._checkInterval = /** @type {any} */
+    setInterval(() => {
+      if (this.wsconnected && messageReconnectTimeout < chunkY6FQDUJU_js.getUnixTime() - this.wsLastMessageReceived) {
+        closeWebsocketConnection(
+          this,
+          /** @type {WebSocket} */
+          this.ws,
+          null
+        );
+      }
+    }, messageReconnectTimeout / 10);
+    if (connect) {
+      this.connect();
+    }
+  }
+  get url() {
+    const encodedParams = encodeQueryParams(this.params);
+    return this.serverUrl + "/" + this.roomname + (encodedParams.length === 0 ? "" : "?" + encodedParams);
+  }
+  /**
+   * @type {boolean}
+   */
+  get synced() {
+    return this._synced;
+  }
+  set synced(state) {
+    if (this._synced !== state) {
+      this._synced = state;
+      this.emit("synced", [state]);
+      this.emit("sync", [state]);
+    }
+  }
+  destroy() {
+    if (this._resyncInterval !== 0) {
+      clearInterval(this._resyncInterval);
+    }
+    clearInterval(this._checkInterval);
+    this.disconnect();
+    if (chunkY6FQDUJU_js.isNode && typeof process !== "undefined") {
+      process.off("exit", this._exitHandler);
+    }
+    this.awareness.off("update", this._awarenessUpdateHandler);
+    this.doc.off("update", this._updateHandler);
+    super.destroy();
+  }
+  connectBc() {
+    if (this.disableBc) {
+      return;
+    }
+    if (!this.bcconnected) {
+      chunkY6FQDUJU_js.subscribe(this.bcChannel, this._bcSubscriber);
+      this.bcconnected = true;
+    }
+    const encoderSync = chunkY6FQDUJU_js.createEncoder();
+    chunkY6FQDUJU_js.writeVarUint(encoderSync, messageSync);
+    chunkY6FQDUJU_js.writeSyncStep1(encoderSync, this.doc);
+    chunkY6FQDUJU_js.publish(this.bcChannel, chunkY6FQDUJU_js.toUint8Array(encoderSync), this);
+    const encoderState = chunkY6FQDUJU_js.createEncoder();
+    chunkY6FQDUJU_js.writeVarUint(encoderState, messageSync);
+    chunkY6FQDUJU_js.writeSyncStep2(encoderState, this.doc);
+    chunkY6FQDUJU_js.publish(this.bcChannel, chunkY6FQDUJU_js.toUint8Array(encoderState), this);
+    const encoderAwarenessQuery = chunkY6FQDUJU_js.createEncoder();
+    chunkY6FQDUJU_js.writeVarUint(encoderAwarenessQuery, messageQueryAwareness);
+    chunkY6FQDUJU_js.publish(
+      this.bcChannel,
+      chunkY6FQDUJU_js.toUint8Array(encoderAwarenessQuery),
+      this
+    );
+    const encoderAwarenessState = chunkY6FQDUJU_js.createEncoder();
+    chunkY6FQDUJU_js.writeVarUint(encoderAwarenessState, messageAwareness);
+    chunkY6FQDUJU_js.writeVarUint8Array(
+      encoderAwarenessState,
+      chunkY6FQDUJU_js.encodeAwarenessUpdate(this.awareness, [
+        this.doc.clientID
+      ])
+    );
+    chunkY6FQDUJU_js.publish(
+      this.bcChannel,
+      chunkY6FQDUJU_js.toUint8Array(encoderAwarenessState),
+      this
+    );
+  }
+  disconnectBc() {
+    const encoder = chunkY6FQDUJU_js.createEncoder();
+    chunkY6FQDUJU_js.writeVarUint(encoder, messageAwareness);
+    chunkY6FQDUJU_js.writeVarUint8Array(
+      encoder,
+      chunkY6FQDUJU_js.encodeAwarenessUpdate(this.awareness, [
+        this.doc.clientID
+      ], /* @__PURE__ */ new Map())
+    );
+    broadcastMessage(this, chunkY6FQDUJU_js.toUint8Array(encoder));
+    if (this.bcconnected) {
+      chunkY6FQDUJU_js.unsubscribe(this.bcChannel, this._bcSubscriber);
+      this.bcconnected = false;
+    }
+  }
+  disconnect() {
+    this.shouldConnect = false;
+    this.disconnectBc();
+    if (this.ws !== null) {
+      closeWebsocketConnection(this, this.ws, null);
+    }
+  }
+  connect() {
+    this.shouldConnect = true;
+    if (!this.wsconnected && this.ws === null) {
+      setupWS(this);
+      this.connectBc();
+    }
+  }
+};
+
+exports.WebsocketProvider = WebsocketProvider;
+exports.messageAuth = messageAuth;
+exports.messageAwareness = messageAwareness;
+exports.messageQueryAwareness = messageQueryAwareness;
+exports.messageSync = messageSync;

package/package.json

@@ -0,0 +1,141 @@
+{
+	"name": "@aixa-transformation/pptx-viewer",
+	"version": "2.0.2",
+	"publishConfig": {
+		"access": "public"
+	},
+	"description": "React PowerPoint viewer and editor component: render, edit, and export PPTX slides in the browser.",
+	"keywords": [
+		"editor",
+		"export",
+		"office",
+		"openxml",
+		"powerpoint",
+		"ppt",
+		"pptx",
+		"presentation",
+		"react",
+		"react-component",
+		"slides",
+		"slideshow",
+		"viewer"
+	],
+	"homepage": "https://github.com/Aixa-Transformation/Aixa-PptxViewer#readme",
+	"bugs": {
+		"url": "https://github.com/Aixa-Transformation/Aixa-PptxViewer/issues"
+	},
+	"license": "Apache-2.0",
+	"author": "Aixa Ltd",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Aixa-Transformation/Aixa-PptxViewer.git",
+		"directory": "packages/react"
+	},
+	"files": [
+		"dist/",
+		"CHANGELOG.md",
+		"LICENSE",
+		"NOTICE",
+		"README.md"
+	],
+	"main": "dist/index.mjs",
+	"module": "dist/index.mjs",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs",
+			"require": "./dist/index.js"
+		},
+		"./viewer": {
+			"types": "./dist/viewer/index.d.ts",
+			"import": "./dist/viewer/index.mjs",
+			"require": "./dist/viewer/index.js"
+		},
+		"./i18n": {
+			"types": "./dist/i18n.d.ts",
+			"import": "./dist/i18n.mjs",
+			"require": "./dist/i18n.js"
+		},
+		"./internals": {
+			"types": "./dist/internals.d.ts",
+			"import": "./dist/internals.mjs",
+			"require": "./dist/internals.js"
+		},
+		"./presentation": {
+			"types": "./dist/presentation.d.ts",
+			"import": "./dist/presentation.mjs",
+			"require": "./dist/presentation.js"
+		},
+		"./styles": "./dist/pptx-viewer.css",
+		"./styles.css": "./dist/pptx-viewer.css",
+		"./theme.css": "./src/styles/theme.css"
+	},
+	"scripts": {
+		"build": "tsup && node scripts/copy-public-types.mjs && npm run build:css",
+		"build:css": "npx @tailwindcss/cli -i src/styles/pptx-viewer.css -o dist/pptx-viewer.css --minify",
+		"dev": "tsup --watch",
+		"typecheck": "tsc --noEmit --pretty",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"pack": "bun run build && bun pm pack"
+	},
+	"dependencies": {
+		"clsx": "^2.1.1",
+		"dompurify": "^3.4.12",
+		"fast-xml-parser": "^5.10.1",
+		"framer-motion": "^12.42.2",
+		"html2canvas-pro": "^2.2.4",
+		"jspdf": "^4.2.1",
+		"jszip": "^3.10.1",
+		"mtx-decompressor": "^1.6.0",
+		"pptx-viewer-mcp": "^2.0.0",
+		"tailwind-merge": "^3.6.0",
+		"yjs": "^13.6.31"
+	},
+	"devDependencies": {
+		"@ai-sdk/react": "^4.0.34",
+		"@tailwindcss/cli": "^4.3.3",
+		"@types/dompurify": "^3.2.0",
+		"@types/react": "^19.2.17",
+		"@types/react-dom": "^19.2.3",
+		"pptx-viewer-core": "file:../core",
+		"pptx-viewer-shared": "file:../shared",
+		"tailwindcss": "^4.3.3",
+		"tsdown": "^0.22.12",
+		"tsup": "^8.5.1",
+		"typescript": "^7.0.2",
+		"vitest": "^4.1.10",
+		"y-webrtc": "^10.3.0",
+		"y-websocket": "^3.0.0",
+		"yjs": "^13.6.31"
+	},
+	"peerDependencies": {
+		"@ai-sdk/react": "^4.0.34",
+		"ai": ">=6 <8",
+		"fast-xml-parser": "^5.10.1",
+		"framer-motion": "^12.42.2",
+		"i18next": "^26.3.6",
+		"jspdf": "^4.2.1",
+		"jszip": "^3.10.1",
+		"lucide-react": "^1.24.0",
+		"react": "^19.2.7",
+		"react-dom": "^19.2.7",
+		"react-i18next": "^17.0.9",
+		"react-icons": "^5.7.0"
+	},
+	"peerDependenciesMeta": {
+		"@ai-sdk/react": {
+			"optional": true
+		},
+		"ai": {
+			"optional": true
+		}
+	},
+	"optionalDependencies": {
+		"three": "^0.185.1",
+		"y-webrtc": "^10.3.0",
+		"y-websocket": "^3.0.0",
+		"yjs": "^13.6.31"
+	}
+}