@prose-reader/enhancer-search 1.117.0 → 1.119.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prose-reader/enhancer-search",
-  "version": "1.117.0",
+  "version": "1.119.0",
   "type": "module",
   "main": "./dist/prose-reader-enhancer-search.umd.cjs",
   "module": "./dist/prose-reader-enhancer-search.js",
@@ -19,10 +19,10 @@
     "test": "vitest run --coverage"
   },
   "dependencies": {
-    "@prose-reader/core": "^1.117.0"
+    "@prose-reader/core": "^1.119.0"
   },
   "peerDependencies": {
     "rxjs": "*"
   },
-  "gitHead": "7979b7ba99701920e600a1c3a798d141fa3679f3"
+  "gitHead": "8fba086fc519af1bef577817629bd55a914cd923"
 }

package/src/index.ts

@@ -3,14 +3,18 @@ import { Reader } from "@prose-reader/core"
 import { forkJoin, from, merge, Observable, of, Subject } from "rxjs"
 import { map, share, switchMap, takeUntil } from "rxjs/operators"
 
-const supportedContentType = [
-  `application/xhtml+xml` as const,
-  `application/xml` as const,
-  `image/svg+xml` as const,
-  `text/html` as const,
-  `text/xml` as const,
+const supportedContentType: DOMParserSupportedType[] = [
+  `application/xhtml+xml`,
+  `application/xml`,
+  `image/svg+xml`,
+  `text/html`,
+  `text/xml`,
 ]
 
+const isSupportedContentType = (contentType: string): contentType is DOMParserSupportedType => {
+  return supportedContentType.includes(contentType as DOMParserSupportedType)
+}
+
 type ResultItem = {
   spineItemIndex: number
   startCfi: string
@@ -97,19 +101,26 @@ export const searchEnhancer =
         return of([])
       }
 
-      return from(item.getResource()).pipe(
+      return from(item.resourcesHandler.fetchResource()).pipe(
         switchMap((response) => {
+          if (!(response instanceof Response)) {
+            return of([])
+          }
+
+          const contentType = response?.headers.get(`Content-Type`) ?? ``
+
           // small optimization since we already know DOMParser only accept some documents only
           // the reader returns us a valid HTML document anyway so it is not ultimately necessary.
           // however we can still avoid doing unnecessary HTML generation for images resources, etc.
-          if (!supportedContentType.includes(response?.headers.get(`Content-Type`) || (`` as any))) return of([])
+          if (!isSupportedContentType(contentType)) return of([])
 
-          return from(item.getHtmlFromResource(response)).pipe(
-            map((html) => {
+          return from(response.text()).pipe(
+            map((responseText) => {
               const parser = new DOMParser()
-              const doc = parser.parseFromString(html, `application/xhtml+xml`)
+              const doc = parser.parseFromString(responseText, contentType)
 
               const ranges = searchNodeContainingText(doc, text)
+
               const newResults = ranges.map((range) => {
                 const { end, start } = reader.cfi.generateCfiFromRange(range, item.item)
                 const { node, offset, spineItemIndex } = reader.cfi.resolveCfi({ cfi: start }) || {}