@difizen/libro-search-code-cell 0.1.2

package/es/search-highlighter.d.ts

@@ -0,0 +1,58 @@
+import type { IEditor, SearchMatch } from '@difizen/libro-code-editor';
+import { LibroSearchUtils } from '@difizen/libro-search';
+import type { CodeEditorSearchHighlighter } from './code-cell-search-protocol.js';
+/**
+ * Helper class to highlight texts in a code mirror editor.
+ *
+ * Highlighted texts (aka `matches`) must be provided through
+ * the `matches` attributes.
+ */
+export declare class GenericSearchHighlighter implements CodeEditorSearchHighlighter {
+    utils: LibroSearchUtils;
+    protected editor: IEditor | undefined;
+    _currentIndex: number | undefined;
+    protected _matches: SearchMatch[];
+    /**
+     * The list of matches
+     */
+    get matches(): SearchMatch[];
+    set matches(v: SearchMatch[]);
+    get currentIndex(): number | undefined;
+    set currentIndex(v: number | undefined);
+    /**
+     * Constructor
+     *
+     * @param editor The CodeMirror editor
+     */
+    constructor();
+    /**
+     * Clear all highlighted matches
+     */
+    clearHighlight(): void;
+    /**
+     * Clear the highlighted matches.
+     */
+    endQuery(): Promise<void>;
+    /**
+     * Highlight the next match
+     *
+     * @returns The next match if available
+     */
+    highlightNext(): Promise<SearchMatch | undefined>;
+    /**
+     * Highlight the previous match
+     *
+     * @returns The previous match if available
+     */
+    highlightPrevious(): Promise<SearchMatch | undefined>;
+    /**
+     * Set the editor
+     *
+     * @param editor Editor
+     */
+    setEditor(editor: IEditor): void;
+    protected _highlightCurrentMatch(): void;
+    protected refresh(): void;
+    protected _findNext(reverse: boolean): number | undefined;
+}
+//# sourceMappingURL=search-highlighter.d.ts.map

package/es/search-highlighter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-highlighter.d.ts","sourceRoot":"","sources":["../src/search-highlighter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAIzD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAElF;;;;;GAKG;AACH,qBACa,wBAAyB,YAAW,2BAA2B;IAChD,KAAK,EAAE,gBAAgB,CAAC;IAElD,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,QAAQ,EAAE,WAAW,EAAE,CAAC;IAE1C;;OAEG;IACH,IAAI,OAAO,IAAI,WAAW,EAAE,CAE3B;IACD,IAAI,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,EAK3B;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,SAAS,CAErC;IACD,IAAI,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,EAGrC;IAED;;;;OAIG;;IAMH;;OAEG;IACH,cAAc,IAAI,IAAI;IAKtB;;OAEG;IACH,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBzB;;;;OAIG;IACH,aAAa,IAAI,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAQjD;;;;OAIG;IACH,iBAAiB,IAAI,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAQrD;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAQhC,SAAS,CAAC,sBAAsB,IAAI,IAAI;IAwBxC,SAAS,CAAC,OAAO,IAAI,IAAI;IAQzB,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;CAgD1D"}

package/es/search-highlighter.js

@@ -0,0 +1,241 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _dec2, _dec3, _dec4, _class, _class2, _descriptor, _descriptor2, _descriptor3;
+function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
+/* eslint-disable no-param-reassign */
+
+import { deepEqual } from '@difizen/libro-common';
+import { LibroSearchUtils } from '@difizen/libro-search';
+import { prop } from '@difizen/mana-app';
+import { inject, transient } from '@difizen/mana-app';
+/**
+ * Helper class to highlight texts in a code mirror editor.
+ *
+ * Highlighted texts (aka `matches`) must be provided through
+ * the `matches` attributes.
+ */
+export var GenericSearchHighlighter = (_dec = transient(), _dec2 = inject(LibroSearchUtils), _dec3 = prop(), _dec4 = prop(), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  /**
+   * Constructor
+   *
+   * @param editor The CodeMirror editor
+   */
+  function GenericSearchHighlighter() {
+    _classCallCheck(this, GenericSearchHighlighter);
+    _initializerDefineProperty(this, "utils", _descriptor, this);
+    _initializerDefineProperty(this, "_currentIndex", _descriptor2, this);
+    _initializerDefineProperty(this, "_matches", _descriptor3, this);
+    this._matches = new Array();
+    this.currentIndex = undefined;
+  }
+
+  /**
+   * Clear all highlighted matches
+   */
+  _createClass(GenericSearchHighlighter, [{
+    key: "matches",
+    get:
+    /**
+     * The list of matches
+     */
+    function get() {
+      return this._matches;
+    },
+    set: function set(v) {
+      if (!deepEqual(this._matches, v)) {
+        this._matches = v;
+      }
+      this.refresh();
+    }
+  }, {
+    key: "currentIndex",
+    get: function get() {
+      return this._currentIndex;
+    },
+    set: function set(v) {
+      this._currentIndex = v;
+      this.refresh();
+    }
+  }, {
+    key: "clearHighlight",
+    value: function clearHighlight() {
+      this.currentIndex = undefined;
+      this._highlightCurrentMatch();
+    }
+
+    /**
+     * Clear the highlighted matches.
+     */
+  }, {
+    key: "endQuery",
+    value: function endQuery() {
+      this._currentIndex = undefined;
+      this._matches = [];
+      if (this.editor) {
+        this.editor.highlightMatches([], undefined);
+        var selection = this.editor.getSelection();
+        var start = this.editor.getOffsetAt(selection.start);
+        var end = this.editor.getOffsetAt(selection.end);
+
+        // Setting a reverse selection to allow search-as-you-type to maintain the
+        // current selected match. See comment in _findNext for more details.
+        if (start !== end) {
+          this.editor.setSelection(selection);
+        }
+      }
+      return Promise.resolve();
+    }
+
+    /**
+     * Highlight the next match
+     *
+     * @returns The next match if available
+     */
+  }, {
+    key: "highlightNext",
+    value: function highlightNext() {
+      this.currentIndex = this._findNext(false);
+      this._highlightCurrentMatch();
+      return Promise.resolve(this.currentIndex !== undefined ? this._matches[this.currentIndex] : undefined);
+    }
+
+    /**
+     * Highlight the previous match
+     *
+     * @returns The previous match if available
+     */
+  }, {
+    key: "highlightPrevious",
+    value: function highlightPrevious() {
+      this.currentIndex = this._findNext(true);
+      this._highlightCurrentMatch();
+      return Promise.resolve(this.currentIndex !== undefined ? this._matches[this.currentIndex] : undefined);
+    }
+
+    /**
+     * Set the editor
+     *
+     * @param editor Editor
+     */
+  }, {
+    key: "setEditor",
+    value: function setEditor(editor) {
+      this.editor = editor;
+      this.refresh();
+      if (this.currentIndex !== undefined) {
+        this._highlightCurrentMatch();
+      }
+    }
+  }, {
+    key: "_highlightCurrentMatch",
+    value: function _highlightCurrentMatch() {
+      if (!this.editor) {
+        // no-op
+        return;
+      }
+
+      // Highlight the current index
+      if (this.currentIndex !== undefined) {
+        var match = this.matches[this.currentIndex];
+        // this.cm.editor.focus();
+        var start = this.editor.getPositionAt(match.position);
+        var end = this.editor.getPositionAt(match.position + match.text.length);
+        if (start && end) {
+          this.editor.setSelection({
+            start: start,
+            end: end
+          });
+          this.editor.revealSelection({
+            start: start,
+            end: end
+          });
+        }
+      } else {
+        var _start = this.editor.getPositionAt(0);
+        var _end = this.editor.getPositionAt(0);
+        // Set cursor to remove any selection
+        this.editor.setSelection({
+          start: _start,
+          end: _end
+        });
+      }
+    }
+  }, {
+    key: "refresh",
+    value: function refresh() {
+      if (!this.editor) {
+        // no-op
+        return;
+      }
+      this.editor.highlightMatches(this.matches, this.currentIndex);
+    }
+  }, {
+    key: "_findNext",
+    value: function _findNext(reverse) {
+      var _this$editor, _this$editor2;
+      if (this.matches.length === 0) {
+        // No-op
+        return undefined;
+      }
+      if (!this.editor) {
+        return;
+      }
+      // In order to support search-as-you-type, we needed a way to allow the first
+      // match to be selected when a search is started, but prevent the selected
+      // search to move for each new keypress.  To do this, when a search is ended,
+      // the cursor is reversed, putting the head at the 'from' position.  When a new
+      // search is started, the cursor we want is at the 'from' position, so that the same
+      // match is selected when the next key is entered (if it is still a match).
+      //
+      // When toggling through a search normally, the cursor is always set in the forward
+      // direction, so head is always at the 'to' position.  That way, if reverse = false,
+      // the search proceeds from the 'to' position during normal toggling.  If reverse = true,
+      // the search always proceeds from the 'anchor' position, which is at the 'from'.
+
+      var selection = (_this$editor = this.editor) === null || _this$editor === void 0 ? void 0 : _this$editor.getSelection();
+      var start = (_this$editor2 = this.editor) === null || _this$editor2 === void 0 ? void 0 : _this$editor2.getOffsetAt(selection.start);
+      var end = this.editor.getOffsetAt(selection.end);
+      var lastPosition = reverse ? start : end;
+      if (lastPosition === 0 && reverse && this.currentIndex === undefined) {
+        // The default position is (0, 0) but we want to start from the end in that case
+        lastPosition = this.editor.model.value.length;
+      }
+      var position = lastPosition;
+      var found = this.utils.findNext(this.matches, position, 0, this.matches.length - 1);
+      if (found === undefined) {
+        // Don't loop
+        return reverse ? this.matches.length - 1 : undefined;
+      }
+      if (reverse) {
+        found -= 1;
+        if (found < 0) {
+          // Don't loop
+          return undefined;
+        }
+      }
+      return found;
+    }
+  }]);
+  return GenericSearchHighlighter;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "utils", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "_currentIndex", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "_matches", [_dec4], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class2)) || _class);

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@difizen/libro-search-code-cell",
+  "version": "0.1.2",
+  "description": "",
+  "keywords": [
+    "libro",
+    "notebook"
+  ],
+  "repository": "git@github.com:difizen/libro.git",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "typings": "./es/index.d.ts",
+      "default": "./es/index.js"
+    },
+    "./mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./es/mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "es/index.js",
+  "module": "es/index.js",
+  "typings": "es/index.d.ts",
+  "files": [
+    "es",
+    "src"
+  ],
+  "dependencies": {
+    "@difizen/libro-common": "^0.1.2",
+    "@difizen/libro-code-editor": "^0.1.2",
+    "@difizen/libro-code-cell": "^0.1.2",
+    "@difizen/libro-search": "^0.1.2",
+    "@difizen/libro-core": "^0.1.2",
+    "@difizen/mana-app": "latest",
+    "@codemirror/state": "^6.0.0",
+    "@codemirror/view": "^6.2.2"
+  },
+  "scripts": {
+    "setup": "father build",
+    "build": "father build",
+    "test": ": Note: lint task is delegated to test:* scripts",
+    "test:vitest": "vitest run",
+    "test:jest": "jest",
+    "coverage": ": Note: lint task is delegated to coverage:* scripts",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:jest": "jest --coverage",
+    "lint": ": Note: lint task is delegated to lint:* scripts",
+    "lint:eslint": "eslint src",
+    "lint:tsc": "tsc --noEmit"
+  }
+}

package/src/code-cell-search-protocol.ts

@@ -0,0 +1,40 @@
+import type { LibroCodeCellView } from '@difizen/libro-code-cell';
+import type { IEditor, SearchMatch } from '@difizen/libro-code-editor';
+import type { CellSearchProvider } from '@difizen/libro-search';
+
+export type CodeEditorSearchHighlighterFactory = (
+  editor: IEditor | undefined,
+) => CodeEditorSearchHighlighter;
+export const CodeEditorSearchHighlighterFactory = Symbol(
+  'CodeEditorSearchHighlighterFactory',
+);
+
+export const CodeCellSearchOption = Symbol('CodeCellSearchOption');
+export interface CodeCellSearchOption {
+  cell: LibroCodeCellView;
+}
+
+export const CodeCellSearchProviderFactory = Symbol('CodeCellSearchProviderFactory');
+export type CodeCellSearchProviderFactory = (
+  option: CodeCellSearchOption,
+) => CellSearchProvider;
+
+export interface CodeEditorSearchHighlighter {
+  /**
+   * The list of matches
+   */
+  get matches(): SearchMatch[];
+  set matches(v: SearchMatch[]);
+
+  get currentIndex(): number | undefined;
+  set currentIndex(v: number | undefined);
+
+  setEditor: (editor: IEditor) => void;
+
+  clearHighlight: () => void;
+
+  endQuery: () => Promise<void>;
+
+  highlightNext: () => Promise<SearchMatch | undefined>;
+  highlightPrevious: () => Promise<SearchMatch | undefined>;
+}

package/src/code-cell-search-provider-contribution.ts

@@ -0,0 +1,39 @@
+import { LibroCodeCellView } from '@difizen/libro-code-cell';
+import type { CellView } from '@difizen/libro-core';
+import { CellSearchProviderContribution } from '@difizen/libro-search';
+import { ViewManager } from '@difizen/mana-app';
+import { inject, singleton } from '@difizen/mana-app';
+
+import { CodeCellSearchProviderFactory } from './code-cell-search-protocol.js';
+
+@singleton({ contrib: CellSearchProviderContribution })
+export class CodeCellSearchProviderContribution
+  implements CellSearchProviderContribution
+{
+  @inject(ViewManager) viewManager: ViewManager;
+  @inject(CodeCellSearchProviderFactory)
+  providerfactory: CodeCellSearchProviderFactory;
+  canHandle = (cell: CellView) => {
+    if (cell instanceof LibroCodeCellView) {
+      return 100;
+    }
+    return 0;
+  };
+  factory(cell: CellView) {
+    return this.providerfactory({ cell: cell as LibroCodeCellView });
+  }
+  /**
+   * Get an initial query value if applicable so that it can be entered
+   * into the search box as an initial query
+   *
+   * @returns Initial value used to populate the search box.
+   */
+  getInitialQuery = (cell: CellView): string => {
+    if (cell instanceof LibroCodeCellView) {
+      const selection = cell.editor?.getSelectionValue();
+      // if there are newlines, just return empty string
+      return selection?.search(/\r?\n|\r/g) === -1 ? selection : '';
+    }
+    return '';
+  };
+}

package/src/code-cell-search-provider.ts

@@ -0,0 +1,227 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { SearchMatch } from '@difizen/libro-code-editor';
+import type { GenericSearchProvider, SearchFilters } from '@difizen/libro-search';
+import { GenericSearchProviderFactory } from '@difizen/libro-search';
+import { inject, prop, transient, watch } from '@difizen/mana-app';
+
+import {
+  CodeCellSearchOption,
+  CodeEditorSearchHighlighterFactory,
+} from './code-cell-search-protocol.js';
+import { CodeEditorCellSearchProvider } from './code-editor-cell-search-provider.js';
+
+@transient()
+export class CodeCellSearchProvider extends CodeEditorCellSearchProvider {
+  protected genericSearchProviderFactory: GenericSearchProviderFactory;
+  @prop() protected outputsProvider: GenericSearchProvider[];
+  @prop() protected currentProviderIndex: number;
+  /**
+   * Constructor
+   *
+   * @param cell Cell widget
+   */
+  constructor(
+    @inject(CodeEditorSearchHighlighterFactory)
+    highlighterFactory: CodeEditorSearchHighlighterFactory,
+    @inject(GenericSearchProviderFactory)
+    genericSearchProviderFactory: GenericSearchProviderFactory,
+    @inject(CodeCellSearchOption) option: CodeCellSearchOption,
+  ) {
+    super(highlighterFactory, option.cell);
+    this.genericSearchProviderFactory = genericSearchProviderFactory;
+    this.currentProviderIndex = -1;
+    this.outputsProvider = [];
+    this.setupOutputProvider();
+    this.cell.outputArea.onUpdate(() => {
+      this.setupOutputProvider();
+    });
+
+    this.toDispose.push(
+      watch(this.cell.model, 'hasOutputHidden', async () => {
+        await this.refresh();
+      }),
+    );
+    this.toDispose.push(
+      watch(this.cell, 'hasInputHidden', async () => {
+        await this.refresh();
+      }),
+    );
+  }
+
+  /**
+   * Number of matches in the cell.
+   */
+  override get matchesCount(): number {
+    if (!this.isActive) {
+      return 0;
+    }
+
+    return (
+      super.matchesCount +
+      this.outputsProvider.reduce(
+        (sum, provider) => sum + (provider.matchesCount ?? 0),
+        0,
+      )
+    );
+  }
+
+  /**
+   * Clear currently highlighted match.
+   */
+  override async clearHighlight(): Promise<void> {
+    await super.clearHighlight();
+    await Promise.all(
+      this.outputsProvider.map((provider) => provider.clearHighlight()),
+    );
+  }
+
+  /**
+   * Dispose the search provider
+   */
+  override dispose(): void {
+    if (this.isDisposed) {
+      return;
+    }
+    super.dispose();
+    this.outputsProvider.map((provider) => {
+      provider.dispose();
+    });
+    this.outputsProvider.length = 0;
+  }
+
+  /**
+   * Highlight the next match.
+   *
+   * @returns The next match if there is one.
+   */
+  override async highlightNext(): Promise<SearchMatch | undefined> {
+    if (this.matchesCount === 0 || !this.isActive) {
+      this.currentIndex = undefined;
+    } else {
+      if (this.currentProviderIndex === -1) {
+        const match = await super.highlightNext();
+        if (match) {
+          this.currentIndex = this.editorHighlighter.currentIndex;
+          return match;
+        } else {
+          this.currentProviderIndex = 0;
+        }
+      }
+
+      while (this.currentProviderIndex < this.outputsProvider.length) {
+        const provider = this.outputsProvider[this.currentProviderIndex];
+        const match = await provider.highlightNext(false);
+        if (match) {
+          this.currentIndex =
+            super.matchesCount +
+            this.outputsProvider
+              .slice(0, this.currentProviderIndex)
+              .reduce((sum, p) => (sum += p.matchesCount ?? 0), 0) +
+            provider.currentMatchIndex!;
+          return match;
+        } else {
+          this.currentProviderIndex += 1;
+        }
+      }
+
+      this.currentProviderIndex = -1;
+      this.currentIndex = undefined;
+      return undefined;
+    }
+    return;
+  }
+
+  /**
+   * Highlight the previous match.
+   *
+   * @returns The previous match if there is one.
+   */
+  override async highlightPrevious(): Promise<SearchMatch | undefined> {
+    if (this.matchesCount === 0 || !this.isActive) {
+      this.currentIndex = undefined;
+    } else {
+      if (this.currentIndex === undefined) {
+        this.currentProviderIndex = this.outputsProvider.length - 1;
+      }
+
+      while (this.currentProviderIndex >= 0) {
+        const provider = this.outputsProvider[this.currentProviderIndex];
+
+        const match = await provider.highlightPrevious(false);
+        if (match) {
+          this.currentIndex =
+            super.matchesCount +
+            this.outputsProvider
+              .slice(0, this.currentProviderIndex)
+              .reduce((sum, p) => (sum += p.matchesCount ?? 0), 0) +
+            provider.currentMatchIndex!;
+          return match;
+        } else {
+          this.currentProviderIndex -= 1;
+        }
+      }
+
+      const match = await super.highlightPrevious();
+      if (match) {
+        this.currentIndex = this.editorHighlighter.currentIndex;
+        return match;
+      } else {
+        this.currentIndex = undefined;
+        return undefined;
+      }
+    }
+    return;
+  }
+
+  /**
+   * Initialize the search using the provided options. Should update the UI to highlight
+   * all matches and "select" the first match.
+   *
+   * @param query A RegExp to be use to perform the search
+   * @param filters Filter parameters to pass to provider
+   */
+  override async startQuery(
+    query: RegExp | null,
+    filters?: SearchFilters,
+  ): Promise<void> {
+    await super.startQuery(query, filters);
+    // Search outputs
+    if (filters?.searchCellOutput) {
+      await Promise.all(
+        this.outputsProvider.map((provider) => {
+          provider.startQuery(query, this.filters);
+        }),
+      );
+    }
+  }
+
+  override async endQuery(): Promise<void> {
+    await super.endQuery();
+    if (this.filters?.searchCellOutput !== false && this.isActive) {
+      await Promise.all(this.outputsProvider.map((provider) => provider.endQuery()));
+    }
+  }
+
+  async refresh() {
+    await this.endQuery();
+    await this.clearHighlight();
+    await this.startQuery(this.query, this.filters);
+  }
+
+  protected setupOutputProvider = async () => {
+    this.outputsProvider.forEach((provider) => {
+      provider.dispose();
+    });
+    this.outputsProvider.length = 0;
+
+    this.currentProviderIndex = -1;
+    this.outputsProvider = this.cell.outputArea.outputs.map((output) => {
+      return this.genericSearchProviderFactory({ view: output });
+    });
+    if (this.isActive && this.query && this.filters?.searchCellOutput !== false) {
+      this.refresh();
+    }
+    this.stateChangedEmitter.fire();
+  };
+}