@embedpdf/plugin-search 1.4.1 → 2.0.0-next.0

package/dist/index.js

@@ -1,39 +1,149 @@
 import { BasePlugin, createBehaviorEmitter } from "@embedpdf/core";
-import { PdfTaskHelper } from "@embedpdf/models";
-const START_SEARCH_SESSION = "START_SEARCH_SESSION";
-const STOP_SEARCH_SESSION = "STOP_SEARCH_SESSION";
-const SET_SEARCH_FLAGS = "SET_SEARCH_FLAGS";
-const SET_SHOW_ALL_RESULTS = "SET_SHOW_ALL_RESULTS";
-const START_SEARCH = "START_SEARCH";
-const SET_SEARCH_RESULTS = "SET_SEARCH_RESULTS";
-const APPEND_SEARCH_RESULTS = "APPEND_SEARCH_RESULTS";
-const SET_ACTIVE_RESULT_INDEX = "SET_ACTIVE_RESULT_INDEX";
-function startSearchSession() {
-  return { type: START_SEARCH_SESSION };
+import { PdfErrorCode, PdfTaskHelper } from "@embedpdf/models";
+const INIT_SEARCH_STATE = "SEARCH/INIT_STATE";
+const CLEANUP_SEARCH_STATE = "SEARCH/CLEANUP_STATE";
+const START_SEARCH_SESSION = "SEARCH/START_SEARCH_SESSION";
+const STOP_SEARCH_SESSION = "SEARCH/STOP_SEARCH_SESSION";
+const SET_SEARCH_FLAGS = "SEARCH/SET_SEARCH_FLAGS";
+const SET_SHOW_ALL_RESULTS = "SEARCH/SET_SHOW_ALL_RESULTS";
+const START_SEARCH = "SEARCH/START_SEARCH";
+const SET_SEARCH_RESULTS = "SEARCH/SET_SEARCH_RESULTS";
+const APPEND_SEARCH_RESULTS = "SEARCH/APPEND_SEARCH_RESULTS";
+const SET_ACTIVE_RESULT_INDEX = "SEARCH/SET_ACTIVE_RESULT_INDEX";
+function initSearchState(documentId, state) {
+  return { type: INIT_SEARCH_STATE, payload: { documentId, state } };
 }
-function stopSearchSession() {
-  return { type: STOP_SEARCH_SESSION };
+function cleanupSearchState(documentId) {
+  return { type: CLEANUP_SEARCH_STATE, payload: documentId };
 }
-function setSearchFlags(flags) {
-  return { type: SET_SEARCH_FLAGS, payload: flags };
+function startSearchSession(documentId) {
+  return { type: START_SEARCH_SESSION, payload: { documentId } };
 }
-function setShowAllResults(showAll) {
-  return { type: SET_SHOW_ALL_RESULTS, payload: showAll };
+function stopSearchSession(documentId) {
+  return { type: STOP_SEARCH_SESSION, payload: { documentId } };
 }
-function startSearch(query) {
-  return { type: START_SEARCH, payload: query };
+function setSearchFlags(documentId, flags) {
+  return { type: SET_SEARCH_FLAGS, payload: { documentId, flags } };
 }
-function setSearchResults(results, total, activeResultIndex) {
-  return { type: SET_SEARCH_RESULTS, payload: { results, total, activeResultIndex } };
+function setShowAllResults(documentId, showAll) {
+  return { type: SET_SHOW_ALL_RESULTS, payload: { documentId, showAll } };
 }
-function appendSearchResults(results) {
-  return { type: APPEND_SEARCH_RESULTS, payload: { results } };
+function startSearch(documentId, query) {
+  return { type: START_SEARCH, payload: { documentId, query } };
 }
-function setActiveResultIndex(index) {
-  return { type: SET_ACTIVE_RESULT_INDEX, payload: index };
+function setSearchResults(documentId, results, total, activeResultIndex) {
+  return { type: SET_SEARCH_RESULTS, payload: { documentId, results, total, activeResultIndex } };
 }
+function appendSearchResults(documentId, results) {
+  return { type: APPEND_SEARCH_RESULTS, payload: { documentId, results } };
+}
+function setActiveResultIndex(documentId, index) {
+  return { type: SET_ACTIVE_RESULT_INDEX, payload: { documentId, index } };
+}
+const initialSearchDocumentState = {
+  flags: [],
+  results: [],
+  total: 0,
+  activeResultIndex: -1,
+  showAllResults: true,
+  query: "",
+  loading: false,
+  active: false
+};
+const initialState = {
+  documents: {}
+};
+const updateDocState = (state, documentId, newDocState) => {
+  const oldDocState = state.documents[documentId] || initialSearchDocumentState;
+  return {
+    ...state,
+    documents: {
+      ...state.documents,
+      [documentId]: {
+        ...oldDocState,
+        ...newDocState
+      }
+    }
+  };
+};
+const searchReducer = (state = initialState, action) => {
+  switch (action.type) {
+    case INIT_SEARCH_STATE:
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [action.payload.documentId]: action.payload.state
+        }
+      };
+    case CLEANUP_SEARCH_STATE: {
+      const documentId = action.payload;
+      const { [documentId]: removed, ...remaining } = state.documents;
+      return {
+        ...state,
+        documents: remaining
+      };
+    }
+    case START_SEARCH_SESSION:
+      return updateDocState(state, action.payload.documentId, { active: true });
+    case STOP_SEARCH_SESSION:
+      return updateDocState(state, action.payload.documentId, {
+        results: [],
+        total: 0,
+        activeResultIndex: -1,
+        query: "",
+        loading: false,
+        active: false
+      });
+    case SET_SEARCH_FLAGS:
+      return updateDocState(state, action.payload.documentId, { flags: action.payload.flags });
+    case SET_SHOW_ALL_RESULTS:
+      return updateDocState(state, action.payload.documentId, {
+        showAllResults: action.payload.showAll
+      });
+    case START_SEARCH:
+      return updateDocState(state, action.payload.documentId, {
+        loading: true,
+        query: action.payload.query,
+        // clear old results on new search start
+        results: [],
+        total: 0,
+        activeResultIndex: -1
+      });
+    case APPEND_SEARCH_RESULTS: {
+      const { documentId, results } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      const newResults = [...docState.results, ...results];
+      const firstHitIndex = docState.activeResultIndex === -1 && newResults.length > 0 ? 0 : docState.activeResultIndex;
+      return updateDocState(state, documentId, {
+        results: newResults,
+        total: newResults.length,
+        // total-so-far
+        activeResultIndex: firstHitIndex,
+        // keep loading true until final SET_SEARCH_RESULTS
+        loading: true
+      });
+    }
+    case SET_SEARCH_RESULTS: {
+      const { documentId, results, total, activeResultIndex } = action.payload;
+      return updateDocState(state, documentId, {
+        results,
+        total,
+        activeResultIndex,
+        loading: false
+      });
+    }
+    case SET_ACTIVE_RESULT_INDEX:
+      return updateDocState(state, action.payload.documentId, {
+        activeResultIndex: action.payload.index
+      });
+    default:
+      return state;
+  }
+};
 const _SearchPlugin = class _SearchPlugin extends BasePlugin {
-  constructor(id, registry) {
+  constructor(id, registry, config) {
     super(id, registry);
     this.searchStop$ = createBehaviorEmitter();
     this.searchStart$ = createBehaviorEmitter();
@@ -41,172 +151,250 @@ const _SearchPlugin = class _SearchPlugin extends BasePlugin {
     this.searchActiveResultChange$ = createBehaviorEmitter();
     this.searchResultState$ = createBehaviorEmitter();
     this.searchState$ = createBehaviorEmitter();
-    this.loader = this.registry.getPlugin("loader").provides();
-    this.loader.onDocumentLoaded(this.handleDocumentLoaded.bind(this));
-    this.loader.onLoaderEvent(this.handleLoaderEvent.bind(this));
+    this.currentTask = /* @__PURE__ */ new Map();
+    this.pluginConfig = config;
   }
-  handleDocumentLoaded(doc) {
-    this.currentDocument = doc;
-    if (this.state.active) {
-      this.startSearchSession();
-    }
+  onDocumentLoadingStarted(documentId) {
+    const initialState2 = {
+      ...initialSearchDocumentState,
+      flags: this.pluginConfig.flags || [],
+      showAllResults: this.pluginConfig.showAllResults ?? true
+    };
+    this.dispatch(initSearchState(documentId, initialState2));
   }
-  handleLoaderEvent(event) {
-    if (event.type === "error" || event.type === "start" && this.currentDocument) {
-      if (this.state.active) {
-        this.stopSearchSession();
-      }
-      this.currentDocument = void 0;
-    }
+  onDocumentClosed(documentId) {
+    this.stopSearchSession(documentId);
+    this.dispatch(cleanupSearchState(documentId));
+    this.currentTask.delete(documentId);
   }
-  async initialize(config) {
-    this.dispatch(setSearchFlags(config.flags || []));
-    this.dispatch(
-      setShowAllResults(config.showAllResults !== void 0 ? config.showAllResults : true)
-    );
+  async initialize() {
   }
-  onStoreUpdated(_prevState, newState) {
-    this.searchResultState$.emit({
-      results: newState.results,
-      activeResultIndex: newState.activeResultIndex,
-      showAllResults: newState.showAllResults,
-      active: newState.active
-    });
-    this.searchState$.emit(newState);
+  onStoreUpdated(prevState, newState) {
+    for (const documentId in newState.documents) {
+      const prevDocState = prevState.documents[documentId];
+      const newDocState = newState.documents[documentId];
+      if (prevDocState !== newDocState) {
+        this.searchState$.emit({ documentId, state: newDocState });
+        if (!prevDocState || prevDocState.results !== newDocState.results || prevDocState.activeResultIndex !== newDocState.activeResultIndex || prevDocState.showAllResults !== newDocState.showAllResults || prevDocState.active !== newDocState.active) {
+          this.searchResultState$.emit({
+            documentId,
+            state: {
+              results: newDocState.results,
+              activeResultIndex: newDocState.activeResultIndex,
+              showAllResults: newDocState.showAllResults,
+              active: newDocState.active
+            }
+          });
+        }
+      }
+    }
   }
   buildCapability() {
+    const getDocId = (documentId) => documentId ?? this.getActiveDocumentId();
+    const getDocState = (docId) => {
+      const id = getDocId(docId);
+      const state = this.state.documents[id];
+      if (!state) throw new Error(`Search state not found for document ${id}`);
+      return state;
+    };
     return {
-      startSearch: this.startSearchSession.bind(this),
-      stopSearch: this.stopSearchSession.bind(this),
-      searchAllPages: this.searchAllPages.bind(this),
-      nextResult: this.nextResult.bind(this),
-      previousResult: this.previousResult.bind(this),
-      goToResult: this.goToResult.bind(this),
-      setShowAllResults: (showAll) => this.dispatch(setShowAllResults(showAll)),
-      getShowAllResults: () => this.state.showAllResults,
+      startSearch: (docId) => this.startSearchSession(getDocId(docId)),
+      stopSearch: (docId) => this.stopSearchSession(getDocId(docId)),
+      searchAllPages: (keyword, docId) => this.searchAllPages(keyword, getDocId(docId)),
+      nextResult: (docId) => this.nextResult(getDocId(docId)),
+      previousResult: (docId) => this.previousResult(getDocId(docId)),
+      goToResult: (index, docId) => this.goToResult(index, getDocId(docId)),
+      setShowAllResults: (showAll, docId) => this.dispatch(setShowAllResults(getDocId(docId), showAll)),
+      getShowAllResults: (docId) => getDocState(docId).showAllResults,
+      getFlags: (docId) => getDocState(docId).flags,
+      setFlags: (flags, docId) => this.setFlags(flags, getDocId(docId)),
+      getState: (docId) => getDocState(docId),
+      forDocument: this.createSearchScope.bind(this),
       onSearchResult: this.searchResult$.on,
       onSearchStart: this.searchStart$.on,
       onSearchStop: this.searchStop$.on,
       onActiveResultChange: this.searchActiveResultChange$.on,
       onSearchResultStateChange: this.searchResultState$.on,
-      onStateChange: this.searchState$.on,
-      getFlags: () => this.state.flags,
-      setFlags: (flags) => this.setFlags(flags),
-      getState: () => this.state
+      onStateChange: this.searchState$.on
     };
   }
-  setFlags(flags) {
-    this.dispatch(setSearchFlags(flags));
-    if (this.state.active) {
-      this.searchAllPages(this.state.query, true);
+  createSearchScope(documentId) {
+    const getDocState = () => {
+      const state = this.state.documents[documentId];
+      if (!state) throw new Error(`Search state not found for document ${documentId}`);
+      return state;
+    };
+    return {
+      startSearch: () => this.startSearchSession(documentId),
+      stopSearch: () => this.stopSearchSession(documentId),
+      searchAllPages: (keyword) => this.searchAllPages(keyword, documentId),
+      nextResult: () => this.nextResult(documentId),
+      previousResult: () => this.previousResult(documentId),
+      goToResult: (index) => this.goToResult(index, documentId),
+      setShowAllResults: (showAll) => this.dispatch(setShowAllResults(documentId, showAll)),
+      getShowAllResults: () => getDocState().showAllResults,
+      getFlags: () => getDocState().flags,
+      setFlags: (flags) => this.setFlags(flags, documentId),
+      getState: getDocState,
+      onSearchResult: (listener) => this.searchResult$.on((event) => {
+        if (event.documentId === documentId) listener(event.results);
+      }),
+      onSearchStart: (listener) => this.searchStart$.on((event) => {
+        if (event.documentId === documentId) listener();
+      }),
+      onSearchStop: (listener) => this.searchStop$.on((event) => {
+        if (event.documentId === documentId) listener();
+      }),
+      onActiveResultChange: (listener) => this.searchActiveResultChange$.on((event) => {
+        if (event.documentId === documentId) listener(event.index);
+      }),
+      onSearchResultStateChange: (listener) => this.searchResultState$.on((event) => {
+        if (event.documentId === documentId) listener(event.state);
+      }),
+      onStateChange: (listener) => this.searchState$.on((event) => {
+        if (event.documentId === documentId) listener(event.state);
+      })
+    };
+  }
+  setFlags(flags, documentId) {
+    this.dispatch(setSearchFlags(documentId, flags));
+    const docState = this.state.documents[documentId];
+    if (docState == null ? void 0 : docState.active) {
+      this.searchAllPages(docState.query, documentId, true);
     }
   }
-  notifySearchStart() {
-    this.searchStart$.emit();
+  notifySearchStart(documentId) {
+    this.searchStart$.emit({ documentId });
   }
-  notifySearchStop() {
-    this.searchStop$.emit();
+  notifySearchStop(documentId) {
+    this.searchStop$.emit({ documentId });
   }
-  notifyActiveResultChange(index) {
-    this.searchActiveResultChange$.emit(index);
+  notifyActiveResultChange(documentId, index) {
+    this.searchActiveResultChange$.emit({ documentId, index });
   }
-  startSearchSession() {
-    if (!this.currentDocument) return;
-    this.dispatch(startSearchSession());
-    this.notifySearchStart();
+  startSearchSession(documentId) {
+    const coreDoc = this.getCoreDocument(documentId);
+    if (!coreDoc) return;
+    this.dispatch(startSearchSession(documentId));
+    this.notifySearchStart(documentId);
   }
-  stopSearchSession() {
-    var _a, _b;
-    if (!this.currentDocument || !this.state.active) return;
-    try {
-      (_b = (_a = this.currentTask) == null ? void 0 : _a.abort) == null ? void 0 : _b.call(_a, { type: "abort", code: "cancelled", message: "search stopped" });
-    } catch {
+  stopSearchSession(documentId) {
+    var _a;
+    const docState = this.state.documents[documentId];
+    if (!(docState == null ? void 0 : docState.active)) return;
+    const task = this.currentTask.get(documentId);
+    if (task) {
+      try {
+        (_a = task.abort) == null ? void 0 : _a.call(task, { code: PdfErrorCode.Cancelled, message: "search stopped" });
+      } catch {
+      }
+      this.currentTask.delete(documentId);
     }
-    this.currentTask = void 0;
-    this.dispatch(stopSearchSession());
-    this.notifySearchStop();
+    this.dispatch(stopSearchSession(documentId));
+    this.notifySearchStop(documentId);
   }
-  searchAllPages(keyword, force = false) {
-    var _a, _b;
+  searchAllPages(keyword, documentId, force = false) {
+    var _a;
+    const docState = this.state.documents[documentId];
+    if (!docState) {
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.NotFound,
+        message: "Search state not initialized"
+      });
+    }
+    const coreDoc = this.getCoreDocument(documentId);
+    if (!(coreDoc == null ? void 0 : coreDoc.document)) {
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not loaded" });
+    }
     const trimmedKeyword = keyword.trim();
-    if (this.state.query === trimmedKeyword && !force) {
+    if (docState.query === trimmedKeyword && !force) {
       return PdfTaskHelper.resolve({
-        results: this.state.results,
-        total: this.state.total
+        results: docState.results,
+        total: docState.total
       });
     }
-    if (this.currentTask) {
+    const oldTask = this.currentTask.get(documentId);
+    if (oldTask) {
       try {
-        (_b = (_a = this.currentTask).abort) == null ? void 0 : _b.call(_a, { type: "abort", code: "superseded", message: "new search" });
+        (_a = oldTask.abort) == null ? void 0 : _a.call(oldTask, { code: PdfErrorCode.Cancelled, message: "new search" });
       } catch {
       }
-      this.currentTask = void 0;
+      this.currentTask.delete(documentId);
     }
-    this.dispatch(startSearch(trimmedKeyword));
-    if (!trimmedKeyword || !this.currentDocument) {
-      this.dispatch(setSearchResults([], 0, -1));
+    this.dispatch(startSearch(documentId, trimmedKeyword));
+    if (!trimmedKeyword) {
+      this.dispatch(setSearchResults(documentId, [], 0, -1));
       return PdfTaskHelper.resolve({
         results: [],
         total: 0
       });
     }
-    if (!this.state.active) {
-      this.startSearchSession();
+    if (!docState.active) {
+      this.startSearchSession(documentId);
     }
-    const task = this.currentTask = this.engine.searchAllPages(
-      this.currentDocument,
-      trimmedKeyword,
-      { flags: this.state.flags }
-    );
+    const task = this.engine.searchAllPages(coreDoc.document, trimmedKeyword, {
+      flags: docState.flags
+    });
+    this.currentTask.set(documentId, task);
     task.onProgress((p) => {
       var _a2;
       if ((_a2 = p == null ? void 0 : p.results) == null ? void 0 : _a2.length) {
-        this.dispatch(appendSearchResults(p.results));
-        if (this.state.activeResultIndex === -1) {
-          this.dispatch(setActiveResultIndex(0));
-          this.notifyActiveResultChange(0);
+        if (this.currentTask.get(documentId) === task) {
+          this.dispatch(appendSearchResults(documentId, p.results));
+          if (this.state.documents[documentId].activeResultIndex === -1) {
+            this.dispatch(setActiveResultIndex(documentId, 0));
+            this.notifyActiveResultChange(documentId, 0);
+          }
         }
       }
     });
     task.wait(
       (results) => {
-        this.currentTask = void 0;
+        this.currentTask.delete(documentId);
         const activeResultIndex = results.total > 0 ? 0 : -1;
-        this.dispatch(setSearchResults(results.results, results.total, activeResultIndex));
-        this.searchResult$.emit(results);
+        this.dispatch(
+          setSearchResults(documentId, results.results, results.total, activeResultIndex)
+        );
+        this.searchResult$.emit({ documentId, results });
         if (results.total > 0) {
-          this.notifyActiveResultChange(0);
+          this.notifyActiveResultChange(documentId, 0);
         }
       },
       (error) => {
-        this.currentTask = void 0;
-        console.error("Error during search:", error);
-        this.dispatch(setSearchResults([], 0, -1));
+        var _a2;
+        if (((_a2 = error == null ? void 0 : error.reason) == null ? void 0 : _a2.code) !== PdfErrorCode.Cancelled) {
+          console.error("Error during search:", error);
+          this.dispatch(setSearchResults(documentId, [], 0, -1));
+        }
+        this.currentTask.delete(documentId);
       }
     );
     return task;
   }
-  nextResult() {
-    if (this.state.results.length === 0) return -1;
-    const nextIndex = this.state.activeResultIndex >= this.state.results.length - 1 ? 0 : this.state.activeResultIndex + 1;
-    return this.goToResult(nextIndex);
+  nextResult(documentId) {
+    const docState = this.state.documents[documentId];
+    if (!docState || docState.results.length === 0) return -1;
+    const nextIndex = docState.activeResultIndex >= docState.results.length - 1 ? 0 : docState.activeResultIndex + 1;
+    return this.goToResult(nextIndex, documentId);
   }
-  previousResult() {
-    if (this.state.results.length === 0) return -1;
-    const prevIndex = this.state.activeResultIndex <= 0 ? this.state.results.length - 1 : this.state.activeResultIndex - 1;
-    return this.goToResult(prevIndex);
+  previousResult(documentId) {
+    const docState = this.state.documents[documentId];
+    if (!docState || docState.results.length === 0) return -1;
+    const prevIndex = docState.activeResultIndex <= 0 ? docState.results.length - 1 : docState.activeResultIndex - 1;
+    return this.goToResult(prevIndex, documentId);
   }
-  goToResult(index) {
-    if (this.state.results.length === 0 || index < 0 || index >= this.state.results.length) {
+  goToResult(index, documentId) {
+    const docState = this.state.documents[documentId];
+    if (!docState || docState.results.length === 0 || index < 0 || index >= docState.results.length) {
       return -1;
     }
-    this.dispatch(setActiveResultIndex(index));
-    this.notifyActiveResultChange(index);
+    this.dispatch(setActiveResultIndex(documentId, index));
+    this.notifyActiveResultChange(documentId, index);
     return index;
   }
   async destroy() {
-    if (this.state.active && this.currentDocument) {
-      this.stopSearchSession();
+    for (const documentId of Object.keys(this.state.documents)) {
+      this.stopSearchSession(documentId);
     }
     this.searchResult$.clear();
     this.searchStart$.clear();
@@ -214,6 +402,7 @@ const _SearchPlugin = class _SearchPlugin extends BasePlugin {
     this.searchActiveResultChange$.clear();
     this.searchResultState$.clear();
     this.searchState$.clear();
+    super.destroy();
   }
 };
 _SearchPlugin.id = "search";
@@ -224,81 +413,16 @@ const manifest = {
   name: "Search Plugin",
   version: "1.0.0",
   provides: ["search"],
-  requires: ["loader"],
+  requires: [],
   optional: [],
   defaultConfig: {
     enabled: true,
     flags: []
   }
 };
-const initialState = {
-  flags: [],
-  results: [],
-  total: 0,
-  activeResultIndex: -1,
-  showAllResults: true,
-  query: "",
-  loading: false,
-  active: false
-};
-const searchReducer = (state = initialState, action) => {
-  switch (action.type) {
-    case START_SEARCH_SESSION:
-      return { ...state, active: true };
-    case STOP_SEARCH_SESSION:
-      return {
-        ...state,
-        results: [],
-        total: 0,
-        activeResultIndex: -1,
-        query: "",
-        loading: false,
-        active: false
-      };
-    case SET_SEARCH_FLAGS:
-      return { ...state, flags: action.payload };
-    case SET_SHOW_ALL_RESULTS:
-      return { ...state, showAllResults: action.payload };
-    case START_SEARCH:
-      return {
-        ...state,
-        loading: true,
-        query: action.payload,
-        // clear old results on new search start
-        results: [],
-        total: 0,
-        activeResultIndex: -1
-      };
-    case APPEND_SEARCH_RESULTS: {
-      const newResults = [...state.results, ...action.payload.results];
-      const firstHitIndex = state.activeResultIndex === -1 && newResults.length > 0 ? 0 : state.activeResultIndex;
-      return {
-        ...state,
-        results: newResults,
-        total: newResults.length,
-        // total-so-far
-        activeResultIndex: firstHitIndex,
-        // keep loading true until final SET_SEARCH_RESULTS
-        loading: true
-      };
-    }
-    case SET_SEARCH_RESULTS:
-      return {
-        ...state,
-        results: action.payload.results,
-        total: action.payload.total,
-        activeResultIndex: action.payload.activeResultIndex,
-        loading: false
-      };
-    case SET_ACTIVE_RESULT_INDEX:
-      return { ...state, activeResultIndex: action.payload };
-    default:
-      return state;
-  }
-};
 const SearchPluginPackage = {
   manifest,
-  create: (registry) => new SearchPlugin(SEARCH_PLUGIN_ID, registry),
+  create: (registry, config) => new SearchPlugin(SEARCH_PLUGIN_ID, registry, config),
   reducer: searchReducer,
   initialState
 };
@@ -306,6 +430,7 @@ export {
   SEARCH_PLUGIN_ID,
   SearchPlugin,
   SearchPluginPackage,
+  initialSearchDocumentState,
   initialState,
   manifest
 };