@prose-reader/enhancer-search 1.130.0 → 1.132.0

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@prose-reader/enhancer-search",
-  "version": "1.130.0",
+  "version": "1.132.0",
   "type": "module",
-  "main": "./dist/prose-reader-enhancer-search.umd.cjs",
-  "module": "./dist/prose-reader-enhancer-search.js",
+  "main": "./dist/index.umd.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/prose-reader-enhancer-search.js",
-      "require": "./dist/prose-reader-enhancer-search.umd.cjs"
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.cjs"
     }
   },
   "scripts": {
@@ -19,10 +19,10 @@
     "test": "vitest run --coverage"
   },
   "dependencies": {
-    "@prose-reader/core": "^1.130.0"
+    "@prose-reader/core": "^1.132.0"
   },
   "peerDependencies": {
     "rxjs": "*"
   },
-  "gitHead": "f0375b3979a4f56521ddd40e98784e5f20372213"
+  "gitHead": "c090e2540deebddc68038275846e7f01730593a8"
 }

package/src/index.ts

@@ -1,34 +1,17 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-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: 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
-  endCfi: string
-  pageIndex?: number
-  contextText: string
-  startOffset: number
-  endOffset: number
-}
-
-export type SearchResult = ResultItem[]
+import { deferIdle, Reader } from "@prose-reader/core"
+import { defer, forkJoin, Observable, of } from "rxjs"
+import { catchError, finalize, map, switchMap } from "rxjs/operators"
+import { searchInDocument, SearchResult } from "./search"
+import { report } from "./report"
 
 /**
+ * Contract of search enhancer.
  *
+ * - At best a result match should be navigable. It means the search needs to
+ * be done on a rendered document. This is because rendering can differ from the original
+ * item resource. A resource can be something indigest and very specific (.pdf). The search
+ * enhancer is agnostic and can only search into documents.
  */
 export const searchEnhancer =
   <InheritOptions, InheritOutput extends Reader>(next: (options: InheritOptions) => InheritOutput) =>
@@ -36,64 +19,11 @@ export const searchEnhancer =
     options: InheritOptions,
   ): InheritOutput & {
     search: {
-      search: (text: string) => void
-      $: {
-        search$: Observable<{ type: `start` } | { type: `end`; data: SearchResult }>
-      }
+      search: (text: string) => Observable<SearchResult>
     }
   } => {
     const reader = next(options)
 
-    const searchSubject$ = new Subject<string>()
-
-    const searchNodeContainingText = (node: Node, text: string) => {
-      const nodeList = node.childNodes
-
-      if (node.nodeName === `head`) return []
-
-      const rangeList: {
-        startNode: Node
-        start: number
-        endNode: Node
-        end: number
-      }[] = []
-      for (let i = 0; i < nodeList.length; i++) {
-        const subNode = nodeList[i]
-
-        if (!subNode) {
-          continue
-        }
-
-        if (subNode?.hasChildNodes()) {
-          rangeList.push(...searchNodeContainingText(subNode, text))
-        }
-
-        if (subNode.nodeType === 3) {
-          const content = (subNode as Text).data.toLowerCase()
-          if (content) {
-            let match
-            const regexp = RegExp(`(${text})`, `g`)
-
-            while ((match = regexp.exec(content)) !== null) {
-              if (match.index >= 0 && subNode.ownerDocument) {
-                const range = subNode.ownerDocument.createRange()
-                range.setStart(subNode, match.index)
-                range.setEnd(subNode, match.index + text.length)
-                rangeList.push({
-                  startNode: subNode,
-                  start: match.index,
-                  endNode: subNode,
-                  end: match.index + text.length,
-                })
-              }
-            }
-          }
-        }
-      }
-
-      return rangeList
-    }
-
     const searchForItem = (index: number, text: string) => {
       const item = reader.spineItemsManager.get(index)
 
@@ -101,92 +31,49 @@ export const searchEnhancer =
         return of([])
       }
 
-      return from(item.resourcesHandler.fetchResource()).pipe(
-        switchMap((response) => {
-          if (!(response instanceof Response)) {
-            return of([])
-          }
-
-          const contentType = response?.headers.get(`Content-Type`) ?? ``
+      return deferIdle(() => item.renderer.renderHeadless()).pipe(
+        switchMap((result) => {
+          const { doc, release } = result || {}
 
-          // 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 (!isSupportedContentType(contentType)) return of([])
+          if (!doc) return of([])
 
-          return from(response.text()).pipe(
-            map((responseText) => {
-              const parser = new DOMParser()
-              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, spineItem } = reader.cfi.resolveCfi({ cfi: start }) || {}
-                const pageIndex =
-                  node && spineItem !== undefined
-                    ? reader.spine.locator.getSpineItemPageIndexFromNode(node, offset, spineItem.item.index)
-                    : undefined
-
-                return {
-                  spineItemIndex: index,
-                  startCfi: start,
-                  endCfi: end,
-                  pageIndex,
-                  contextText: range.startNode.parentElement?.textContent || ``,
-                  startOffset: range.start,
-                  endOffset: range.end,
-                }
-              })
+          return deferIdle(() => searchInDocument(reader, item, doc, text)).pipe(
+            finalize(() => {
+              release?.()
+            }),
+            catchError((e) => {
+              report.error(e)
 
-              return newResults
+              return of([])
             }),
           )
         }),
       )
     }
 
-    const search = (text: string) => {
-      searchSubject$.next(text)
-    }
+    const search = (text: string) =>
+      defer(() => {
+        if (text === ``) {
+          return of([])
+        }
 
-    /**
-     * Main search process stream
-     */
-    const search$ = merge(
-      searchSubject$.asObservable().pipe(map(() => ({ type: `start` as const }))),
-      searchSubject$.asObservable().pipe(
-        switchMap((text) => {
-          if (text === ``) {
-            return of([])
-          }
+        const searches$ = reader.context.manifest?.spineItems.map((_, index) => searchForItem(index, text)) || []
 
-          const searches$ = reader.context.manifest?.spineItems.map((_, index) => searchForItem(index, text)) || []
+        return forkJoin([...searches$, of([])])
+      }).pipe(
+        map((results) => {
+          const flattenedResults = results.flat()
 
-          return forkJoin(searches$).pipe(
-            map((results) => {
-              return results.reduce((acc, value) => [...acc, ...value], [])
-            }),
-          )
-        }),
-        map((data) => ({ type: `end` as const, data })),
-      ),
-    ).pipe(share(), takeUntil(reader.$.destroy$))
+          report.debug("results", flattenedResults)
 
-    const destroy = () => {
-      searchSubject$.complete()
-      reader.destroy()
-    }
+          return flattenedResults
+        }),
+      )
 
     return {
       ...reader,
-      destroy,
       search: {
         search,
-        $: {
-          search$,
-        },
       },
     }
   }

package/src/report.ts

@@ -0,0 +1,5 @@
+import { Report } from "@prose-reader/shared"
+
+const IS_DEBUG_ENABLED = true
+
+export const report = Report.namespace(`enhancer-search`, IS_DEBUG_ENABLED)

package/src/search.ts

@@ -0,0 +1,61 @@
+import { Reader, SpineItem } from "@prose-reader/core"
+import { Observable, of } from "rxjs"
+import { ResultItem } from "./types"
+
+export type SearchResult = ResultItem[]
+
+const searchNodeContainingText = (node: Node, text: string) => {
+  const nodeList = node.childNodes
+
+  if (node.nodeName === `head`) return []
+
+  const rangeList: Range[] = []
+
+  for (let i = 0; i < nodeList.length; i++) {
+    const subNode = nodeList[i]
+
+    if (!subNode) {
+      continue
+    }
+
+    if (subNode?.hasChildNodes()) {
+      rangeList.push(...searchNodeContainingText(subNode, text))
+    }
+
+    if (subNode.nodeType === 3) {
+      const content = (subNode as Text).data.toLowerCase()
+      if (content) {
+        let match
+        const regexp = RegExp(`(${text})`, `g`)
+
+        while ((match = regexp.exec(content)) !== null) {
+          if (match.index >= 0 && subNode.ownerDocument) {
+            const range = subNode.ownerDocument.createRange()
+            range.setStart(subNode, match.index)
+            range.setEnd(subNode, match.index + text.length)
+
+            rangeList.push(range)
+          }
+        }
+      }
+    }
+  }
+
+  return rangeList
+}
+
+export const searchInDocument = (reader: Reader, item: SpineItem, doc: Document, text: string): Observable<SearchResult> => {
+  const ranges = searchNodeContainingText(doc, text)
+
+  const newResults = ranges.map((range) => {
+    const { end, start } = reader.cfi.generateCfiFromRange(range, item.item)
+
+    return {
+      cfi: start,
+      startCfi: start,
+      endCfi: end,
+    } satisfies ResultItem
+  })
+
+  return of(newResults)
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+export type ResultItem = {
+  cfi: string
+  startCfi?: string
+  endCfi?: string
+}

package/{vite.config.js → vite.config.ts}

@@ -9,10 +9,11 @@ const libName = name.replace(`@`, ``).replace(`/`, `-`)
 export default defineConfig(({ mode }) => ({
   build: {
     minify: false,
+    target: "esnext",
     lib: {
       entry: resolve(__dirname, `src/index.ts`),
       name: libName,
-      fileName: libName,
+      fileName: `index`,
     },
     emptyOutDir: mode !== `development`,
     sourcemap: true,