Replace timeout-based HTML export completion with explicit signal (#1425)

* Fix HTML export completion and error signaling

* Handle already-loaded webview when signaling export completion

Author: evilz

src/ExportHTML.ts

@@ -16,17 +16,9 @@ export const exportHTML = async (options: IExportOptions) => {
   const filePath = path.join(folderPath ? folderPath : ".", file)
 
   if (data) {
-    try {
-      await jetpack.writeAsync(filePath, data)
-    } catch (error) {
-      console.error(error)
-    }
+    await jetpack.writeAsync(filePath, data)
   }
   else if (srcFilePath) {
-    try {
-      await jetpack.copyAsync(srcFilePath, filePath, { overwrite: true })
-    } catch (error) {
-      console.error(error)
-    }
+    await jetpack.copyAsync(srcFilePath, filePath, { overwrite: true })
   }
 }

src/MainController.ts

@@ -136,7 +136,8 @@ export default class MainController {
       logger,
       () => this.config,
       extensionContext.extensionPath,
-      this.isInExport
+      this.isInExport,
+      this.onExportError
     )
     this.diagnostics = languages.createDiagnosticCollection('vscode-revealjs')
     this.configByKey = new Map(configDesc.map((d) => [d.label, d]))
@@ -159,23 +160,41 @@ export default class MainController {
   }
   //#endregion
 
-  // active export during 5 seconds
-  private exportTimeout: NodeJS.Timeout | null = null
-  public isInExport = () => this.exportTimeout != null && this.exportTimeout != undefined
+  private exportState: {
+    resolve: (path: string) => void
+    reject: (error: Error) => void
+    path: string
+  } | null = null
+  public isInExport = () => this.exportState !== null
+
+  private readonly onExportError = (error: unknown) => {
+    if (!this.exportState) return
+
+    const normalizedError = error instanceof Error ? error : new Error(String(error))
+    this.exportState.reject(new Error(`HTML export failed: ${normalizedError.message}`))
+    this.exportState = null
+  }
 
   public shouldOpenFilemanagerAfterHTMLExport = () => this.currentContext?.configuration.openFilemanagerAfterHTMLExport ?? false
 
 
   public exportAsync = async () => {
-    if (this.exportTimeout) {
-      clearTimeout(this.exportTimeout)
+    if (!this.currentContext) {
+      throw new Error('No active markdown context to export')
+    }
+
+    if (this.exportState) {
+      this.exportState.reject(new Error('A previous HTML export was interrupted by a new export request'))
+      this.exportState = null
     }
-    if (this.currentContext) { await jetpack.removeAsync(this.currentContext.exportPath) }
 
-    const promise = new Promise<string>((resolve) => {
-      this.exportTimeout = setTimeout(() => resolve(this.currentContext?.exportPath ?? ''), 5000)
+    await jetpack.removeAsync(this.currentContext.exportPath)
+    const exportPath = this.currentContext.exportPath
+
+    const promise = new Promise<string>((resolve, reject) => {
+      this.exportState = { resolve, reject, path: exportPath }
     })
-    //await commands.executeCommand(SHOW_REVEALJS_IN_BROWSER)
+
     this.webViewPane ? this.refreshWebViewPane() : await commands.executeCommand(SHOW_REVEALJS)
 
     return promise
@@ -264,6 +283,14 @@ export default class MainController {
         if (!message || typeof message !== 'object') return
 
         const command = 'command' in message ? message.command : undefined
+        if (command === 'exportComplete') {
+          if (this.exportState) {
+            this.exportState.resolve(this.exportState.path)
+            this.exportState = null
+          }
+          return
+        }
+
         if (command !== 'slideChanged') return
 
         const horizontal = 'horizontal' in message ? Number(message.horizontal) : Number.NaN
@@ -284,7 +311,7 @@ export default class MainController {
     if (this.webViewPane && this.currentContext) {
       this.startServer()
       this.webViewPane.title = this.currentContext.configuration.title
-      void this.webViewPane.update(this.currentContext.uriWithPosition)
+      void this.webViewPane.update(this.currentContext.uriWithPosition, this.isInExport())
     }
   }
 

src/RevealContext.ts

@@ -29,7 +29,8 @@ export class RevealContext extends Disposable {
     public logger: Logger,
     public getConfiguration: () => Configuration,
     public extensionPath: string,
-    public isInExport: () => boolean
+    public isInExport: () => boolean,
+    public onExportError: (error: unknown) => void = () => {}
   ) {
     super()
     this.editor = editor
@@ -170,14 +171,15 @@ export class RevealContexts {
     private readonly logger: Logger,
     private readonly getConfiguration: () => Configuration,
     private readonly extensionPath: string,
-    private readonly isInExport: () => boolean
+    private readonly isInExport: () => boolean,
+    private readonly onExportError: (error: unknown) => void
   ) {
     this.logger = logger
   }
 
   getOrAdd(editor: TextEditor) {
     if (this.innerMap.has(editor.document.uri)) return this.innerMap.get(editor.document.uri)
-    const context = new RevealContext(editor, this.logger, this.getConfiguration, this.extensionPath, this.isInExport)
+    const context = new RevealContext(editor, this.logger, this.getConfiguration, this.extensionPath, this.isInExport, this.onExportError)
 
     context.onDidDispose(() => this.logger.info(`CONTEXT: ${editor.document.uri} disposed`))
 

src/RevealServer.ts

@@ -178,7 +178,8 @@ export class RevealServer extends Disposable {
             const opts: IExportOptions = { folderPath: exportPath, url: req.originalUrl.split('?')[0], srcFilePath: null, data: body }
             await exportfn(opts)
           } catch (error) {
-            this.context.logger.info(`Error : ${error}`)
+            this.context.logger.error(`Export error: ${error}`)
+            this.context.onExportError(error)
           }
 
           // @ts-ignore

src/WebViewPane.ts

@@ -36,15 +36,15 @@ export default class WebviewPane
         this.webviewPanel.title = title;
     }
 
-    public async update(url:string) {
+    public async update(url:string, sendExportSignal = false) {
         const parsedUrl = new URL(url)
         const slideHash = parsedUrl.hash || '#/'
         parsedUrl.hash = ''
 
         const response = await fetch(parsedUrl.toString())
         const html = await response.text()
         const htmlWithBase = this.injectBaseHref(html, parsedUrl.toString())
-        this.webviewPanel.webview.html = this.injectBridgeScript(htmlWithBase, slideHash)
+        this.webviewPanel.webview.html = this.injectBridgeScript(htmlWithBase, slideHash, sendExportSignal)
         this.#onDidUpdate.fire()
     }
 
@@ -57,7 +57,7 @@ export default class WebviewPane
       return `${baseTag}${html}`
     }
 
-    private injectBridgeScript(html: string, slideHash: string) {
+    private injectBridgeScript(html: string, slideHash: string, sendExportSignal: boolean) {
       const script = `
       <script>
         (function () {
@@ -93,6 +93,18 @@ export default class WebviewPane
           }
 
           setTimeout(postCurrentSlide, 0);
+
+          if (${sendExportSignal}) {
+            const postExportComplete = () => {
+              vscode.postMessage({ command: 'exportComplete' });
+            };
+
+            if (document.readyState === 'complete') {
+              postExportComplete();
+            } else {
+              window.addEventListener('load', postExportComplete, { once: true });
+            }
+          }
         }());
       </script>
       `

src/commands/exportHTML.ts

@@ -7,7 +7,8 @@ export const EXPORT_HTML = 'vscode-revealjs.exportHTML'
 export type EXPORT_HTML = typeof EXPORT_HTML
 
 export const exportHTML = (logger: Logger, startExport: () => Promise<string>, doOpenAfterExport: () => boolean) => async () => {
-  await window.withProgress(
+  try {
+    await window.withProgress(
     {
       location: ProgressLocation.Notification,
       title: 'Export',
@@ -27,6 +28,12 @@ export const exportHTML = (logger: Logger, startExport: () => Promise<string>, d
       }
     }
   )
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logger.error(`Export failed: ${message}`)
+    void window.showErrorMessage(`RevealJS HTML export failed: ${message}`)
+    throw error
+  }
 }
 
 function timeout(ms) {