Add reset method to Mediawiki, improve Renderer builder

src/MediaWiki.ts

@@ -27,9 +27,9 @@ class MediaWiki {
   public _base: string
   public baseUrl: URL
   public getCategories: boolean
-  public readonly namespaces: MWNamespaces = {}
-  public readonly namespacesToMirror: string[] = []
-  public mwArticleId = 'MediaWiki:Sidebar'
+  public namespaces: MWNamespaces = {}
+  public namespacesToMirror: string[] = []
+  public mwArticleId: string
 
   #wikiPath: string
   #restApiPath: string
@@ -48,8 +48,8 @@ class MediaWiki {
   public webUrl: URL
   public desktopRestApiUrl: URL
 
-  #hasWikimediaDesktopRestApi = false
-  #hasVisualEditorApi = false
+  #hasWikimediaDesktopRestApi: boolean | null
+  #hasVisualEditorApi: boolean | null
 
   set username(value: string) {
     this.#username = value
@@ -84,26 +84,37 @@ class MediaWiki {
     this._modulePathOpt = value
   }
 
-  private constructor() {
+  private initializeMediaWikiDefaults(): void {
     this.#domain = ''
     this.#username = ''
     this.#password = ''
     this.getCategories = false
 
+    this.namespaces = {}
+    this.namespacesToMirror = []
+
     this.#apiPath = 'w/api.php'
     this.#wikiPath = 'wiki/'
+    this.mwArticleId = 'MediaWiki:Sidebar'
+
+    this.#hasWikimediaDesktopRestApi = null
+    this.#hasVisualEditorApi = null
+  }
+
+  private constructor() {
+    this.initializeMediaWikiDefaults()
   }
 
   public async hasWikimediaDesktopRestApi(): Promise<boolean> {
-    if (!this.#hasWikimediaDesktopRestApi) {
+    if (this.#hasWikimediaDesktopRestApi === null) {
       this.#hasWikimediaDesktopRestApi = await checkApiAvailability(this.wikimediaDesktopUrlDirector.buildArticleURL(this.mwArticleId))
       return this.#hasWikimediaDesktopRestApi
     }
     return this.#hasWikimediaDesktopRestApi
   }
 
   public async hasVisualEditorApi(): Promise<boolean> {
-    if (!this.#hasVisualEditorApi) {
+    if (this.#hasVisualEditorApi === null) {
       this.#hasVisualEditorApi = await checkApiAvailability(this.visualEditorURLDirector.buildArticleURL(this.mwArticleId))
       return this.#hasVisualEditorApi
     }
@@ -360,6 +371,10 @@ class MediaWiki {
 
     return mwMetaData
   }
+
+  public reset(): void {
+    this.initializeMediaWikiDefaults()
+  }
 }
 
 const mw = MediaWiki.getInstance()

src/mwoffliner.lib.ts

@@ -639,6 +639,7 @@ async function execute(argv: any) {
     }
   }
 
+  MediaWiki.reset()
   redisStore.close()
 
   return dumps

src/util/renderers/renderer.builder.ts

@@ -9,44 +9,49 @@ export class RendererBuilder {
   private renderApi: 'VisualEditor' | 'WikimediaDesktop' | 'WikimediaMobile'
   private renderMode: 'auto' | 'desktop' | 'mobile' | 'specific'
 
-  public createRenderer(options: RendererBuilderOptions): Renderer {
+  public async createRenderer(options: RendererBuilderOptions): Promise<Renderer> {
     const { RendererMode, RendererAPI } = options
 
     this.renderMode = RendererMode
     this.renderApi = RendererAPI
 
+    const [hasVisualEditorApi, hasWikimediaDesktopRestApi] = await Promise.all([MediaWiki.hasVisualEditorApi(), MediaWiki.hasWikimediaDesktopRestApi()])
+
     switch (this.renderMode) {
       case 'desktop':
-        if (MediaWiki.hasVisualEditorApi && !MediaWiki.hasWikimediaDesktopRestApi) {
-          return new VisualEditorRenderer()
-        } else if (MediaWiki.hasWikimediaDesktopRestApi) {
+        if (hasWikimediaDesktopRestApi) {
+          // Choose WikimediaDesktopRenderer if it's present, regardless of hasVisualEditorApi value
           return new WikimediaDesktopRenderer()
+        } else if (hasVisualEditorApi) {
+          return new VisualEditorRenderer()
+        } else {
+          logger.error('No available renderer for desktop mode.')
+          process.exit(1)
         }
-        logger.error('No available renderer for desktop mode.')
-        process.exit(1)
       case 'mobile':
         // TODO: return WikimediaMobile renderer
         break
       case 'auto':
-        // Auto mode is code driven and based on mw api capabilities of specific wiki
-        if (MediaWiki.hasVisualEditorApi && !MediaWiki.hasWikimediaDesktopRestApi) {
-          return new VisualEditorRenderer()
-        } else if (MediaWiki.hasWikimediaDesktopRestApi) {
+        if (hasWikimediaDesktopRestApi) {
+          // Choose WikimediaDesktopRenderer if it's present, regardless of hasVisualEditorApi value
           return new WikimediaDesktopRenderer()
+        } else if (hasVisualEditorApi) {
+          return new VisualEditorRenderer()
+        } else {
+          logger.error('No available renderer for auto mode.')
+          process.exit(1)
         }
-        logger.error('No available renderer for auto mode.')
-        process.exit(1)
       case 'specific':
         // renderApi argument is required for 'specific' mode
         switch (this.renderApi) {
           case 'WikimediaDesktop':
-            if (MediaWiki.hasWikimediaDesktopRestApi) {
+            if (hasWikimediaDesktopRestApi) {
               return new WikimediaDesktopRenderer()
             }
             logger.error('Cannot create an instance of WikimediaDesktop renderer.')
             process.exit(1)
           case 'VisualEditor':
-            if (MediaWiki.hasVisualEditorApi) {
+            if (hasVisualEditorApi) {
               return new VisualEditorRenderer()
             }
             logger.error('Cannot create an instance of VisualEditor renderer.')

src/util/saveArticles.ts

@@ -277,9 +277,9 @@ export async function saveArticles(zimCreator: ZimCreator, downloader: Downloade
   const rendererBuilderOptions: RendererBuilderOptions = {
     RendererMode: 'auto',
   }
-  const mainPageRenderer = rendererBuilder.createRenderer(rendererBuilderOptions)
+  const mainPageRenderer = await rendererBuilder.createRenderer(rendererBuilderOptions)
   // TODO: article renderer will be switched to the mobiel mode later
-  const articlesRenderer = rendererBuilder.createRenderer(rendererBuilderOptions)
+  const articlesRenderer = await rendererBuilder.createRenderer(rendererBuilderOptions)
 
   if (dump.customProcessor?.shouldKeepArticle) {
     await getAllArticlesToKeep(downloader, articleDetailXId, dump, mainPageRenderer, articlesRenderer)

test/unit/renderers/renderer.builder.test.ts

@@ -16,19 +16,17 @@ describe('RendererBuilder', () => {
   it('should create a WikimediaDesktopRenderer for desktop mode', async () => {
     const { MediaWiki } = await setupScrapeClasses() // en wikipedia
 
-    const renderer = rendererBuilder.createRenderer({
+    const renderer = await rendererBuilder.createRenderer({
       MediaWiki,
       RendererMode: 'desktop',
     } as RendererBuilderOptions)
     expect(renderer).toBeInstanceOf(WikimediaDesktopRenderer)
   })
 
-  it('should create a WikimediaDesktopRenderer for auto mode as this is default for en wikipedia', async () => {
+  it('should create a WikimediaDesktopRenderer for auto mode for en wikipedia', async () => {
     const { MediaWiki } = await setupScrapeClasses() // en wikipedia
-    await MediaWiki.hasWikimediaDesktopRestApi()
-    await MediaWiki.hasVisualEditorApi()
 
-    const renderer = rendererBuilder.createRenderer({
+    const renderer = await rendererBuilder.createRenderer({
       MediaWiki,
       RendererMode: 'auto',
     } as RendererBuilderOptions)
@@ -38,38 +36,44 @@ describe('RendererBuilder', () => {
   it('should throw error for unknown render mode', async () => {
     const { MediaWiki } = await setupScrapeClasses() // en wikipedia
 
-    expect(() => {
-      rendererBuilder.createRenderer({
+    expect(async () => {
+      await rendererBuilder.createRenderer({
         MediaWiki,
         RendererMode: 'unknownMode' as any,
       } as RendererBuilderOptions)
-    }).toThrow('Unknown render mode: unknownMode')
+    }).rejects.toThrow('Unknown render mode: unknownMode')
   })
 
   it('should return VisualEditorRenderer for specific mode with RendererAPI as VisualEditor', async () => {
     const { MediaWiki } = await setupScrapeClasses() // en wikipedia
 
+    // Force MediaWiki to have capability for the VisualEditor for test purpose
+    jest.spyOn(MediaWiki, 'hasVisualEditorApi').mockResolvedValue(true)
+
     const rendererBuilderOptions = {
       MediaWiki,
       RendererMode: 'specific',
       RendererAPI: 'VisualEditor',
     }
 
-    const renderer = rendererBuilder.createRenderer(rendererBuilderOptions as RendererBuilderOptions)
+    const renderer = await rendererBuilder.createRenderer(rendererBuilderOptions as RendererBuilderOptions)
 
     expect(renderer).toBeInstanceOf(VisualEditorRenderer)
   })
 
   it('should return WikimediaDesktopRenderer for specific mode with RendererAPI as WikimediaDesktop', async () => {
     const { MediaWiki } = await setupScrapeClasses() // en wikipedia
 
+    // Force MediaWiki to have capability for the WikimediaDesktop for test purpose
+    jest.spyOn(MediaWiki, 'hasWikimediaDesktopRestApi').mockResolvedValue(true)
+
     const rendererBuilderOptions = {
       MediaWiki,
       RendererMode: 'specific',
       RendererAPI: 'WikimediaDesktop',
     }
 
-    const renderer = rendererBuilder.createRenderer(rendererBuilderOptions as RendererBuilderOptions)
+    const renderer = await rendererBuilder.createRenderer(rendererBuilderOptions as RendererBuilderOptions)
 
     expect(renderer).toBeInstanceOf(WikimediaDesktopRenderer)
   })
@@ -86,7 +90,7 @@ describe('RendererBuilder', () => {
       RendererAPI: 'UnknownAPI', // Using an invalid RendererAPI for the test
     }
 
-    expect(() => rendererBuilder.createRenderer(rendererBuilderOptions as RendererBuilderOptions)).toThrow(
+    expect(async () => await rendererBuilder.createRenderer(rendererBuilderOptions as RendererBuilderOptions)).rejects.toThrow(
       `Unknown RendererAPI for specific mode: ${rendererBuilderOptions.RendererAPI}`,
     )
   })