From 6142f3a2973d20493f784f323f3be57fa8deaeef Mon Sep 17 00:00:00 2001
From: undergroundwires <git@undergroundwires.dev>
Date: Wed, 14 Feb 2024 12:10:49 +0100
Subject: [PATCH] Extend search by including documentation content

This commit broadens the search functionality within privacy.sexy by
including documentation text in the search scope. Users can now find
scripts and categories not only by their names but also by content in
their documentation. This improvement aims to make the discovery of
relevant scripts and information more intuitive and comprehensive.

Key changes:

- Documentation text is now searchable, enhancing the ability to
  discover scripts and categories based on content details.

Other supporting changes:

- Remove interface prefixes (`I`) from related interfaces to adhere to
  naming conventions, enhancing code readability.
- Refactor filtering to separate actual filtering logic from filter
  state management, improving the structure for easier maintenance.
- Improve test coverage to ensure relability of existing and new search
  capabilities.
- Test coverage expanded to ensure the reliability of the new search
  capabilities.
---
 .../Context/State/CategoryCollectionState.ts  |  12 +-
 .../State/Filter/AdaptiveFilterContext.ts     |  35 +++
 .../State/Filter/Event/FilterChange.ts        |  16 +-
 .../State/Filter/Event/FilterChangeDetails.ts |  23 ++
 .../Filter/Event/IFilterChangeDetails.ts      |  23 --
 .../Context/State/Filter/FilterContext.ts     |  13 +
 .../Context/State/Filter/IUserFilter.ts       |  13 -
 .../AppliedFilterResult.ts}                   |   4 +-
 .../FilterResult.ts}                          |   2 +-
 .../State/Filter/Strategy/FilterStrategy.ts   |   9 +
 .../Filter/Strategy/LinearFilterStrategy.ts   |  80 +++++
 .../Context/State/Filter/UserFilter.ts        |  56 ----
 .../Context/State/ICategoryCollectionState.ts |   6 +-
 .../Scripts/Menu/TheScriptsMenu.vue           |   4 +-
 .../Scripts/View/TheScriptsView.vue           |   8 +-
 .../TreeViewAdapter/UseTreeViewFilterEvent.ts |  12 +-
 src/presentation/components/TheSearchBar.vue  |   8 +-
 .../State/CategoryCollectionState.spec.ts     |   6 +-
 .../Filter/AdaptiveFilterContext.spec.ts      | 130 ++++++++
 .../State/Filter/Event/FilterChange.spec.ts   |  80 ++---
 .../Context/State/Filter/FilterResult.spec.ts |  45 ---
 .../Filter/Result/AppliedFilterResult.spec.ts |  99 +++++++
 .../Strategy/LinearFilterStrategy.spec.ts     | 278 ++++++++++++++++++
 .../Context/State/Filter/UserFilter.spec.ts   | 194 ------------
 .../Scripts/View/TheScriptsView.spec.ts       |  50 ++--
 .../UseTreeViewFilterEvent.spec.ts            |  24 +-
 .../Stubs/CategoryCollectionStateStub.ts      |  10 +-
 tests/unit/shared/Stubs/CategoryStub.ts       |   7 +-
 .../shared/Stubs/FilterChangeDetailsStub.ts   |  10 +-
 .../Stubs/FilterChangeDetailsVisitorStub.ts   |  29 +-
 tests/unit/shared/Stubs/FilterContextStub.ts  |  55 ++++
 tests/unit/shared/Stubs/FilterResultStub.ts   |   8 +-
 tests/unit/shared/Stubs/FilterStrategyStub.ts |  24 ++
 tests/unit/shared/Stubs/ScriptStub.ts         |   7 +-
 .../shared/Stubs/UseCollectionStateStub.ts    |  14 +-
 tests/unit/shared/Stubs/UserFilterStub.ts     |  48 ---
 36 files changed, 917 insertions(+), 525 deletions(-)
 create mode 100644 src/application/Context/State/Filter/AdaptiveFilterContext.ts
 create mode 100644 src/application/Context/State/Filter/Event/FilterChangeDetails.ts
 delete mode 100644 src/application/Context/State/Filter/Event/IFilterChangeDetails.ts
 create mode 100644 src/application/Context/State/Filter/FilterContext.ts
 delete mode 100644 src/application/Context/State/Filter/IUserFilter.ts
 rename src/application/Context/State/Filter/{FilterResult.ts => Result/AppliedFilterResult.ts} (81%)
 rename src/application/Context/State/Filter/{IFilterResult.ts => Result/FilterResult.ts} (86%)
 create mode 100644 src/application/Context/State/Filter/Strategy/FilterStrategy.ts
 create mode 100644 src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
 delete mode 100644 src/application/Context/State/Filter/UserFilter.ts
 create mode 100644 tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts
 delete mode 100644 tests/unit/application/Context/State/Filter/FilterResult.spec.ts
 create mode 100644 tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
 create mode 100644 tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
 delete mode 100644 tests/unit/application/Context/State/Filter/UserFilter.spec.ts
 create mode 100644 tests/unit/shared/Stubs/FilterContextStub.ts
 create mode 100644 tests/unit/shared/Stubs/FilterStrategyStub.ts
 delete mode 100644 tests/unit/shared/Stubs/UserFilterStub.ts

diff --git a/src/application/Context/State/CategoryCollectionState.ts b/src/application/Context/State/CategoryCollectionState.ts
index 09efaf3a..c8a9936d 100644
--- a/src/application/Context/State/CategoryCollectionState.ts
+++ b/src/application/Context/State/CategoryCollectionState.ts
@@ -1,7 +1,7 @@
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { UserFilter } from './Filter/UserFilter';
-import { IUserFilter } from './Filter/IUserFilter';
+import { AdaptiveFilterContext } from './Filter/AdaptiveFilterContext';
+import { FilterContext } from './Filter/FilterContext';
 import { ApplicationCode } from './Code/ApplicationCode';
 import { UserSelection } from './Selection/UserSelection';
 import { ICategoryCollectionState } from './ICategoryCollectionState';
@@ -15,7 +15,7 @@ export class CategoryCollectionState implements ICategoryCollectionState {
 
   public readonly selection: UserSelection;
 
-  public readonly filter: IUserFilter;
+  public readonly filter: FilterContext;
 
   public constructor(
     public readonly collection: ICategoryCollection,
@@ -45,7 +45,7 @@ const DefaultSelectionFactory: SelectionFactory = (
 ) => new UserSelectionFacade(...params);
 
 export type FilterFactory = (
-  ...params: ConstructorParameters<typeof UserFilter>
-) => IUserFilter;
+  ...params: ConstructorParameters<typeof AdaptiveFilterContext>
+) => FilterContext;
 
-const DefaultFilterFactory: FilterFactory = (...params) => new UserFilter(...params);
+const DefaultFilterFactory: FilterFactory = (...params) => new AdaptiveFilterContext(...params);
diff --git a/src/application/Context/State/Filter/AdaptiveFilterContext.ts b/src/application/Context/State/Filter/AdaptiveFilterContext.ts
new file mode 100644
index 00000000..1a498f61
--- /dev/null
+++ b/src/application/Context/State/Filter/AdaptiveFilterContext.ts
@@ -0,0 +1,35 @@
+import { EventSource } from '@/infrastructure/Events/EventSource';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { FilterResult } from './Result/FilterResult';
+import { FilterContext } from './FilterContext';
+import { FilterChangeDetails } from './Event/FilterChangeDetails';
+import { FilterChange } from './Event/FilterChange';
+import { FilterStrategy } from './Strategy/FilterStrategy';
+import { LinearFilterStrategy } from './Strategy/LinearFilterStrategy';
+
+export class AdaptiveFilterContext implements FilterContext {
+  public readonly filterChanged = new EventSource<FilterChangeDetails>();
+
+  public currentFilter: FilterResult | undefined;
+
+  constructor(
+    private readonly collection: ICategoryCollection,
+    private readonly filterStrategy: FilterStrategy = new LinearFilterStrategy(),
+  ) {
+
+  }
+
+  public applyFilter(filter: string): void {
+    if (!filter) {
+      throw new Error('Filter must be defined and not empty. Use clearFilter() to remove the filter');
+    }
+    const result = this.filterStrategy.applyFilter(filter, this.collection);
+    this.currentFilter = result;
+    this.filterChanged.notify(FilterChange.forApply(this.currentFilter));
+  }
+
+  public clearFilter(): void {
+    this.currentFilter = undefined;
+    this.filterChanged.notify(FilterChange.forClear());
+  }
+}
diff --git a/src/application/Context/State/Filter/Event/FilterChange.ts b/src/application/Context/State/Filter/Event/FilterChange.ts
index bed54dc8..c4c0ffbd 100644
--- a/src/application/Context/State/Filter/Event/FilterChange.ts
+++ b/src/application/Context/State/Filter/Event/FilterChange.ts
@@ -1,24 +1,24 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { FilterActionType } from './FilterActionType';
 import {
-  IFilterChangeDetails, IFilterChangeDetailsVisitor,
+  FilterChangeDetails, FilterChangeDetailsVisitor,
   ApplyFilterAction, ClearFilterAction,
-} from './IFilterChangeDetails';
+} from './FilterChangeDetails';
 
-export class FilterChange implements IFilterChangeDetails {
+export class FilterChange implements FilterChangeDetails {
   public static forApply(
-    filter: IFilterResult,
-  ): IFilterChangeDetails {
+    filter: FilterResult,
+  ): FilterChangeDetails {
     return new FilterChange({ type: FilterActionType.Apply, filter });
   }
 
-  public static forClear(): IFilterChangeDetails {
+  public static forClear(): FilterChangeDetails {
     return new FilterChange({ type: FilterActionType.Clear });
   }
 
   private constructor(public readonly action: ApplyFilterAction | ClearFilterAction) { }
 
-  public visit(visitor: IFilterChangeDetailsVisitor): void {
+  public visit(visitor: FilterChangeDetailsVisitor): void {
     switch (this.action.type) {
       case FilterActionType.Apply:
         if (visitor.onApply) {
diff --git a/src/application/Context/State/Filter/Event/FilterChangeDetails.ts b/src/application/Context/State/Filter/Event/FilterChangeDetails.ts
new file mode 100644
index 00000000..58462505
--- /dev/null
+++ b/src/application/Context/State/Filter/Event/FilterChangeDetails.ts
@@ -0,0 +1,23 @@
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import type { FilterActionType } from './FilterActionType';
+
+export interface FilterChangeDetails {
+  readonly action: FilterAction;
+  visit(visitor: FilterChangeDetailsVisitor): void;
+}
+
+export interface FilterChangeDetailsVisitor {
+  readonly onClear?: () => void;
+  readonly onApply?: (filter: FilterResult) => void;
+}
+
+export type ApplyFilterAction = {
+  readonly type: FilterActionType.Apply,
+  readonly filter: FilterResult;
+};
+
+export type ClearFilterAction = {
+  readonly type: FilterActionType.Clear,
+};
+
+export type FilterAction = ApplyFilterAction | ClearFilterAction;
diff --git a/src/application/Context/State/Filter/Event/IFilterChangeDetails.ts b/src/application/Context/State/Filter/Event/IFilterChangeDetails.ts
deleted file mode 100644
index 1cf343e1..00000000
--- a/src/application/Context/State/Filter/Event/IFilterChangeDetails.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { FilterActionType } from './FilterActionType';
-
-export interface IFilterChangeDetails {
-  readonly action: FilterAction;
-  visit(visitor: IFilterChangeDetailsVisitor): void;
-}
-
-export interface IFilterChangeDetailsVisitor {
-  readonly onClear?: () => void;
-  readonly onApply?: (filter: IFilterResult) => void;
-}
-
-export type ApplyFilterAction = {
-  readonly type: FilterActionType.Apply,
-  readonly filter: IFilterResult;
-};
-
-export type ClearFilterAction = {
-  readonly type: FilterActionType.Clear,
-};
-
-export type FilterAction = ApplyFilterAction | ClearFilterAction;
diff --git a/src/application/Context/State/Filter/FilterContext.ts b/src/application/Context/State/Filter/FilterContext.ts
new file mode 100644
index 00000000..2c5f592f
--- /dev/null
+++ b/src/application/Context/State/Filter/FilterContext.ts
@@ -0,0 +1,13 @@
+import { IEventSource } from '@/infrastructure/Events/IEventSource';
+import { FilterResult } from './Result/FilterResult';
+import { FilterChangeDetails } from './Event/FilterChangeDetails';
+
+export interface ReadonlyFilterContext {
+  readonly currentFilter: FilterResult | undefined;
+  readonly filterChanged: IEventSource<FilterChangeDetails>;
+}
+
+export interface FilterContext extends ReadonlyFilterContext {
+  applyFilter(filter: string): void;
+  clearFilter(): void;
+}
diff --git a/src/application/Context/State/Filter/IUserFilter.ts b/src/application/Context/State/Filter/IUserFilter.ts
deleted file mode 100644
index 60403187..00000000
--- a/src/application/Context/State/Filter/IUserFilter.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { IEventSource } from '@/infrastructure/Events/IEventSource';
-import { IFilterResult } from './IFilterResult';
-import { IFilterChangeDetails } from './Event/IFilterChangeDetails';
-
-export interface IReadOnlyUserFilter {
-  readonly currentFilter: IFilterResult | undefined;
-  readonly filterChanged: IEventSource<IFilterChangeDetails>;
-}
-
-export interface IUserFilter extends IReadOnlyUserFilter {
-  applyFilter(filter: string): void;
-  clearFilter(): void;
-}
diff --git a/src/application/Context/State/Filter/FilterResult.ts b/src/application/Context/State/Filter/Result/AppliedFilterResult.ts
similarity index 81%
rename from src/application/Context/State/Filter/FilterResult.ts
rename to src/application/Context/State/Filter/Result/AppliedFilterResult.ts
index 5c949ebe..a3aa2cb2 100644
--- a/src/application/Context/State/Filter/FilterResult.ts
+++ b/src/application/Context/State/Filter/Result/AppliedFilterResult.ts
@@ -1,8 +1,8 @@
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
-import { IFilterResult } from './IFilterResult';
+import { FilterResult } from './FilterResult';
 
-export class FilterResult implements IFilterResult {
+export class AppliedFilterResult implements FilterResult {
   constructor(
     public readonly scriptMatches: ReadonlyArray<IScript>,
     public readonly categoryMatches: ReadonlyArray<ICategory>,
diff --git a/src/application/Context/State/Filter/IFilterResult.ts b/src/application/Context/State/Filter/Result/FilterResult.ts
similarity index 86%
rename from src/application/Context/State/Filter/IFilterResult.ts
rename to src/application/Context/State/Filter/Result/FilterResult.ts
index 8391dc82..d9613df1 100644
--- a/src/application/Context/State/Filter/IFilterResult.ts
+++ b/src/application/Context/State/Filter/Result/FilterResult.ts
@@ -1,6 +1,6 @@
 import { IScript, ICategory } from '@/domain/ICategory';
 
-export interface IFilterResult {
+export interface FilterResult {
   readonly categoryMatches: ReadonlyArray<ICategory>;
   readonly scriptMatches: ReadonlyArray<IScript>;
   readonly query: string;
diff --git a/src/application/Context/State/Filter/Strategy/FilterStrategy.ts b/src/application/Context/State/Filter/Strategy/FilterStrategy.ts
new file mode 100644
index 00000000..2bda8de2
--- /dev/null
+++ b/src/application/Context/State/Filter/Strategy/FilterStrategy.ts
@@ -0,0 +1,9 @@
+import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import type { FilterResult } from '../Result/FilterResult';
+
+export interface FilterStrategy {
+  applyFilter(
+    filter: string,
+    collection: ICategoryCollection,
+  ): FilterResult;
+}
diff --git a/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts b/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
new file mode 100644
index 00000000..c9c978ee
--- /dev/null
+++ b/src/application/Context/State/Filter/Strategy/LinearFilterStrategy.ts
@@ -0,0 +1,80 @@
+import type { ICategory, IScript } from '@/domain/ICategory';
+import type { IScriptCode } from '@/domain/IScriptCode';
+import type { IDocumentable } from '@/domain/IDocumentable';
+import type { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { AppliedFilterResult } from '../Result/AppliedFilterResult';
+import type { FilterStrategy } from './FilterStrategy';
+import type { FilterResult } from '../Result/FilterResult';
+
+export class LinearFilterStrategy implements FilterStrategy {
+  applyFilter(filter: string, collection: ICategoryCollection): FilterResult {
+    const filterLowercase = filter.toLocaleLowerCase();
+    const filteredScripts = collection.getAllScripts().filter(
+      (script) => matchesScript(script, filterLowercase),
+    );
+    const filteredCategories = collection.getAllCategories().filter(
+      (category) => matchesCategory(category, filterLowercase),
+    );
+    return new AppliedFilterResult(
+      filteredScripts,
+      filteredCategories,
+      filter,
+    );
+  }
+}
+
+function matchesCategory(
+  category: ICategory,
+  filterLowercase: string,
+): boolean {
+  return matchesAny(
+    () => matchName(category.name, filterLowercase),
+    () => matchDocumentation(category, filterLowercase),
+  );
+}
+
+function matchesScript(
+  script: IScript,
+  filterLowercase: string,
+): boolean {
+  return matchesAny(
+    () => matchName(script.name, filterLowercase),
+    () => matchCode(script.code, filterLowercase),
+    () => matchDocumentation(script, filterLowercase),
+  );
+}
+
+function matchesAny(
+  ...predicates: ReadonlyArray<() => boolean>
+): boolean {
+  return predicates.some((predicate) => predicate());
+}
+
+function matchName(
+  name: string,
+  filterLowercase: string,
+): boolean {
+  return name.toLowerCase().includes(filterLowercase);
+}
+
+function matchCode(
+  code: IScriptCode,
+  filterLowercase: string,
+): boolean {
+  if (code.execute.toLowerCase().includes(filterLowercase)) {
+    return true;
+  }
+  if (code.revert?.toLowerCase().includes(filterLowercase)) {
+    return true;
+  }
+  return false;
+}
+
+function matchDocumentation(
+  documentable: IDocumentable,
+  filterLowercase: string,
+): boolean {
+  return documentable.docs.some(
+    (doc) => doc.toLocaleLowerCase().includes(filterLowercase),
+  );
+}
diff --git a/src/application/Context/State/Filter/UserFilter.ts b/src/application/Context/State/Filter/UserFilter.ts
deleted file mode 100644
index 5e1e026d..00000000
--- a/src/application/Context/State/Filter/UserFilter.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { IScript } from '@/domain/IScript';
-import { EventSource } from '@/infrastructure/Events/EventSource';
-import { ICategoryCollection } from '@/domain/ICategoryCollection';
-import { FilterResult } from './FilterResult';
-import { IFilterResult } from './IFilterResult';
-import { IUserFilter } from './IUserFilter';
-import { IFilterChangeDetails } from './Event/IFilterChangeDetails';
-import { FilterChange } from './Event/FilterChange';
-
-export class UserFilter implements IUserFilter {
-  public readonly filterChanged = new EventSource<IFilterChangeDetails>();
-
-  public currentFilter: IFilterResult | undefined;
-
-  constructor(private collection: ICategoryCollection) {
-
-  }
-
-  public applyFilter(filter: string): void {
-    if (!filter) {
-      throw new Error('Filter must be defined and not empty. Use clearFilter() to remove the filter');
-    }
-    const filterLowercase = filter.toLocaleLowerCase();
-    const filteredScripts = this.collection.getAllScripts().filter(
-      (script) => isScriptAMatch(script, filterLowercase),
-    );
-    const filteredCategories = this.collection.getAllCategories().filter(
-      (category) => category.name.toLowerCase().includes(filterLowercase),
-    );
-    const matches = new FilterResult(
-      filteredScripts,
-      filteredCategories,
-      filter,
-    );
-    this.currentFilter = matches;
-    this.filterChanged.notify(FilterChange.forApply(this.currentFilter));
-  }
-
-  public clearFilter(): void {
-    this.currentFilter = undefined;
-    this.filterChanged.notify(FilterChange.forClear());
-  }
-}
-
-function isScriptAMatch(script: IScript, filterLowercase: string) {
-  if (script.name.toLowerCase().includes(filterLowercase)) {
-    return true;
-  }
-  if (script.code.execute.toLowerCase().includes(filterLowercase)) {
-    return true;
-  }
-  if (script.code.revert) {
-    return script.code.revert.toLowerCase().includes(filterLowercase);
-  }
-  return false;
-}
diff --git a/src/application/Context/State/ICategoryCollectionState.ts b/src/application/Context/State/ICategoryCollectionState.ts
index 815aa413..3ae0e197 100644
--- a/src/application/Context/State/ICategoryCollectionState.ts
+++ b/src/application/Context/State/ICategoryCollectionState.ts
@@ -1,18 +1,18 @@
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { IReadOnlyUserFilter, IUserFilter } from './Filter/IUserFilter';
+import { ReadonlyFilterContext, FilterContext } from './Filter/FilterContext';
 import { ReadonlyUserSelection, UserSelection } from './Selection/UserSelection';
 import { IApplicationCode } from './Code/IApplicationCode';
 
 export interface IReadOnlyCategoryCollectionState {
   readonly code: IApplicationCode;
   readonly os: OperatingSystem;
-  readonly filter: IReadOnlyUserFilter;
+  readonly filter: ReadonlyFilterContext;
   readonly selection: ReadonlyUserSelection;
   readonly collection: ICategoryCollection;
 }
 
 export interface ICategoryCollectionState extends IReadOnlyCategoryCollectionState {
-  readonly filter: IUserFilter;
+  readonly filter: FilterContext;
   readonly selection: UserSelection;
 }
diff --git a/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue b/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
index f44c5062..8f3c24c1 100644
--- a/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
+++ b/src/presentation/components/Scripts/Menu/TheScriptsMenu.vue
@@ -16,7 +16,7 @@
 <script lang="ts">
 import { defineComponent, ref } from 'vue';
 import { injectKey } from '@/presentation/injectionSymbols';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
 import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
 import TheOsChanger from './TheOsChanger.vue';
 import TheViewChanger from './View/TheViewChanger.vue';
@@ -49,7 +49,7 @@ export default defineComponent({
     }, { immediate: true });
 
     function subscribeToFilterChanges(
-      filter: IReadOnlyUserFilter,
+      filter: ReadonlyFilterContext,
     ): IEventSubscription {
       return filter.filterChanged.on((event) => {
         event.visit({
diff --git a/src/presentation/components/Scripts/View/TheScriptsView.vue b/src/presentation/components/Scripts/View/TheScriptsView.vue
index 5b2c5b02..de43ceb7 100644
--- a/src/presentation/components/Scripts/View/TheScriptsView.vue
+++ b/src/presentation/components/Scripts/View/TheScriptsView.vue
@@ -43,8 +43,8 @@ import { injectKey } from '@/presentation/injectionSymbols';
 import ScriptsTree from '@/presentation/components/Scripts/View/Tree/ScriptsTree.vue';
 import CardList from '@/presentation/components/Scripts/View/Cards/CardList.vue';
 import { ViewType } from '@/presentation/components/Scripts/Menu/View/ViewType';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import FlatButton from '@/presentation/components/Shared/FlatButton.vue';
 
 export default defineComponent({
@@ -94,12 +94,12 @@ export default defineComponent({
       });
     }
 
-    function updateFromInitialFilter(filter?: IFilterResult) {
+    function updateFromInitialFilter(filter?: FilterResult) {
       searchQuery.value = filter?.query;
       searchHasMatches.value = filter?.hasAnyMatches() ?? false;
     }
 
-    function subscribeToFilterChanges(filter: IReadOnlyUserFilter) {
+    function subscribeToFilterChanges(filter: ReadonlyFilterContext) {
       return filter.filterChanged.on((event) => {
         event.visit({
           onApply: (newFilter) => {
diff --git a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
index ee031914..8f5327c7 100644
--- a/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
+++ b/src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts
@@ -4,8 +4,8 @@ import {
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
 import { injectKey } from '@/presentation/injectionSymbols';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { TreeViewFilterEvent, createFilterRemovedEvent, createFilterTriggeredEvent } from '../TreeView/Bindings/TreeInputFilterEvent';
 import { NodeMetadata } from '../NodeContent/NodeMetadata';
 import { ReadOnlyTreeNode } from '../TreeView/Node/TreeNode';
@@ -14,7 +14,7 @@ import { getCategoryNodeId, getScriptNodeId } from './CategoryNodeMetadataConver
 
 type TreeNodeFilterResultPredicate = (
   node: ReadOnlyTreeNode,
-  filterResult: IFilterResult,
+  filterResult: FilterResult,
 ) => boolean;
 
 export function useTreeViewFilterEvent() {
@@ -41,7 +41,7 @@ export function useTreeViewFilterEvent() {
 }
 
 function subscribeToFilterChanges(
-  filter: IReadOnlyUserFilter,
+  filter: ReadonlyFilterContext,
   latestFilterEvent: Ref<TreeViewFilterEvent | undefined>,
   filterPredicate: TreeNodeFilterResultPredicate,
 ) {
@@ -60,7 +60,7 @@ function subscribeToFilterChanges(
 }
 
 function createFilterEvent(
-  filter: IFilterResult | undefined,
+  filter: FilterResult | undefined,
   filterPredicate: TreeNodeFilterResultPredicate,
 ): TreeViewFilterEvent {
   if (!filter) {
@@ -71,7 +71,7 @@ function createFilterEvent(
   );
 }
 
-function filterMatches(node: NodeMetadata, filter: IFilterResult): boolean {
+function filterMatches(node: NodeMetadata, filter: FilterResult): boolean {
   return containsScript(node, filter.scriptMatches)
     || containsCategory(node, filter.categoryMatches);
 }
diff --git a/src/presentation/components/TheSearchBar.vue b/src/presentation/components/TheSearchBar.vue
index 422c1e84..9e84d7b5 100644
--- a/src/presentation/components/TheSearchBar.vue
+++ b/src/presentation/components/TheSearchBar.vue
@@ -19,8 +19,8 @@ import {
 import { injectKey } from '@/presentation/injectionSymbols';
 import { NonCollapsing } from '@/presentation/components/Scripts/View/Cards/NonCollapsingDirective';
 import AppIcon from '@/presentation/components/Shared/Icon/AppIcon.vue';
-import { IReadOnlyUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { IEventSubscription } from '@/infrastructure/Events/IEventSource';
 
 export default defineComponent({
@@ -61,12 +61,12 @@ export default defineComponent({
       ]);
     }, { immediate: true });
 
-    function updateFromInitialFilter(filter?: IFilterResult) {
+    function updateFromInitialFilter(filter?: FilterResult) {
       searchQuery.value = filter?.query;
     }
 
     function subscribeToFilterChanges(
-      filter: IReadOnlyUserFilter,
+      filter: ReadonlyFilterContext,
     ): IEventSubscription {
       return filter.filterChanged.on((event) => {
         event.visit({
diff --git a/tests/unit/application/Context/State/CategoryCollectionState.spec.ts b/tests/unit/application/Context/State/CategoryCollectionState.spec.ts
index 45b05424..5f7f9ce5 100644
--- a/tests/unit/application/Context/State/CategoryCollectionState.spec.ts
+++ b/tests/unit/application/Context/State/CategoryCollectionState.spec.ts
@@ -11,8 +11,8 @@ import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 import { ReadonlyScriptSelection } from '@/application/Context/State/Selection/Script/ScriptSelection';
 import { ScriptSelectionStub } from '@tests/unit/shared/Stubs/ScriptSelectionStub';
 import { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
-import { UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
 import type { CodeFactory, FilterFactory, SelectionFactory } from '@/application/Context/State/CategoryCollectionState';
+import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
 
 describe('CategoryCollectionState', () => {
   describe('code', () => {
@@ -113,7 +113,7 @@ describe('CategoryCollectionState', () => {
       let actualCollection: ICategoryCollection | undefined;
       const filterFactoryMock: FilterFactory = (collection) => {
         actualCollection = collection;
-        return new UserFilterStub();
+        return new FilterContextStub();
       };
       // act
       new CategoryCollectionStateBuilder()
@@ -134,7 +134,7 @@ class CategoryCollectionStateBuilder {
 
   private selectionFactory: SelectionFactory = () => new UserSelectionStub();
 
-  private filterFactory: FilterFactory = () => new UserFilterStub();
+  private filterFactory: FilterFactory = () => new FilterContextStub();
 
   public withCollection(collection: ICategoryCollection): this {
     this.collection = collection;
diff --git a/tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts b/tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts
new file mode 100644
index 00000000..37cf6795
--- /dev/null
+++ b/tests/unit/application/Context/State/Filter/AdaptiveFilterContext.spec.ts
@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
+import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import { expectExists } from '@tests/shared/Assertions/ExpectExists';
+import { AdaptiveFilterContext } from '@/application/Context/State/Filter/AdaptiveFilterContext';
+import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
+import { FilterStrategyStub } from '@tests/unit/shared/Stubs/FilterStrategyStub';
+import type { FilterStrategy } from '@/application/Context/State/Filter/Strategy/FilterStrategy';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+
+describe('AdaptiveFilterContext', () => {
+  describe('clearFilter', () => {
+    it('emits clear event on filter removal', () => {
+      // arrange
+      const expectedChange = FilterChangeDetailsStub.forClear();
+      let actualChange: FilterChangeDetails | undefined;
+      const context = new ContextBuilder().build();
+      context.filterChanged.on((change) => {
+        actualChange = change;
+      });
+      // act
+      context.clearFilter();
+      // assert
+      expectExists(actualChange);
+      expect(actualChange).to.deep.equal(expectedChange);
+    });
+    it('clears current filter', () => {
+      // arrange
+      const context = new ContextBuilder().build();
+      // act
+      context.applyFilter('non-important');
+      context.clearFilter();
+      // assert
+      expect(context.currentFilter).to.be.equal(undefined);
+    });
+  });
+  describe('applyFilter', () => {
+    it('updates current filter correctly', () => {
+      // arrange
+      const expectedFilter = new FilterResultStub();
+      const strategy = new FilterStrategyStub()
+        .withApplyFilterResult(expectedFilter);
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .build();
+      // act
+      context.applyFilter('non-important');
+      // assert
+      const actualFilter = context.currentFilter;
+      expect(actualFilter).to.equal(expectedFilter);
+    });
+    it('emits apply event with correct filter', () => {
+      // arrange
+      const expectedFilter = new FilterResultStub();
+      const strategy = new FilterStrategyStub()
+        .withApplyFilterResult(expectedFilter);
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .build();
+      let actualFilter: FilterResult | undefined;
+      context.filterChanged.on((filterResult) => {
+        filterResult.visit({
+          onApply: (result) => {
+            actualFilter = result;
+          },
+        });
+      });
+      // act
+      context.applyFilter('non-important');
+      // assert
+      expect(actualFilter).to.equal(expectedFilter);
+    });
+    it('applies filter using current collection', () => {
+      // arrange
+      const expectedCollection = new CategoryCollectionStub();
+      const strategy = new FilterStrategyStub();
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .withCategoryCollection(expectedCollection)
+        .build();
+      // act
+      context.applyFilter('non-important');
+      // assert
+      const applyFilterCalls = strategy.callHistory.filter((c) => c.methodName === 'applyFilter');
+      expect(applyFilterCalls).to.have.lengthOf(1);
+      const [, actualCollection] = applyFilterCalls[0].args;
+      expect(actualCollection).to.equal(expectedCollection);
+    });
+    it('applies filter with given query', () => {
+      // arrange
+      const expectedQuery = 'expected-query';
+      const strategy = new FilterStrategyStub();
+      const context = new ContextBuilder()
+        .withStrategy(strategy)
+        .build();
+      // act
+      context.applyFilter(expectedQuery);
+      // assert
+      const applyFilterCalls = strategy.callHistory.filter((c) => c.methodName === 'applyFilter');
+      expect(applyFilterCalls).to.have.lengthOf(1);
+      const [actualQuery] = applyFilterCalls[0].args;
+      expect(actualQuery).to.equal(expectedQuery);
+    });
+  });
+});
+
+class ContextBuilder {
+  private categoryCollection: ICategoryCollection = new CategoryCollectionStub();
+
+  private filterStrategy: FilterStrategy = new FilterStrategyStub();
+
+  public build(): AdaptiveFilterContext {
+    return new AdaptiveFilterContext(
+      this.categoryCollection,
+      this.filterStrategy,
+    );
+  }
+
+  public withStrategy(strategy: FilterStrategy): this {
+    this.filterStrategy = strategy;
+    return this;
+  }
+
+  public withCategoryCollection(categoryCollection: ICategoryCollection): this {
+    this.categoryCollection = categoryCollection;
+    return this;
+  }
+}
diff --git a/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts b/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts
index 6ed05667..02031d34 100644
--- a/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts
+++ b/tests/unit/application/Context/State/Filter/Event/FilterChange.spec.ts
@@ -3,7 +3,8 @@ import { FilterChange } from '@/application/Context/State/Filter/Event/FilterCha
 import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
 import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
 import { FilterChangeDetailsVisitorStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub';
-import { ApplyFilterAction } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
+import { ApplyFilterAction } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
 describe('FilterChange', () => {
   describe('forApply', () => {
@@ -48,14 +49,48 @@ describe('FilterChange', () => {
   });
   describe('visit', () => {
     describe('onClear', () => {
-      itVisitsOnce(
-        () => FilterChange.forClear(),
-      );
+      it('visits once', () => {
+        // arrange
+        const sut = FilterChange.forClear();
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        expect(visitor.callHistory).to.have.lengthOf(1);
+      });
+
+      it('visits onClear', () => {
+        // arrange
+        const sut = FilterChange.forClear();
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        const call = visitor.callHistory.find((c) => c.methodName === 'onClear');
+        expect(call).toBeDefined();
+      });
     });
     describe('onApply', () => {
-      itVisitsOnce(
-        () => FilterChange.forApply(new FilterResultStub()),
-      );
+      it('visits once', () => {
+        // arrange
+        const sut = FilterChange.forApply(new FilterResultStub());
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        expect(visitor.callHistory).to.have.lengthOf(1);
+      });
+
+      it('visits onApply', () => {
+        // arrange
+        const sut = FilterChange.forApply(new FilterResultStub());
+        const visitor = new FilterChangeDetailsVisitorStub();
+        // act
+        sut.visit(visitor);
+        // assert
+        const call = visitor.callHistory.find((c) => c.methodName === 'onApply');
+        expect(call).toBeDefined();
+      });
 
       it('visits with expected filter', () => {
         // arrange
@@ -65,34 +100,11 @@ describe('FilterChange', () => {
         // act
         sut.visit(visitor);
         // assert
-        expect(visitor.visitedResults).to.have.lengthOf(1);
-        expect(visitor.visitedResults).to.include(expectedFilter);
+        const call = visitor.callHistory.find((c) => c.methodName === 'onApply');
+        expectExists(call);
+        const [actualFilter] = call.args;
+        expect(actualFilter).to.equal(expectedFilter);
       });
     });
   });
 });
-
-function itVisitsOnce(sutFactory: () => FilterChange) {
-  it('visits', () => {
-    // arrange
-    const sut = sutFactory();
-    const expectedType = sut.action.type;
-    const visitor = new FilterChangeDetailsVisitorStub();
-    // act
-    sut.visit(visitor);
-    // assert
-    expect(visitor.visitedEvents).to.include(expectedType);
-  });
-  it('visits once', () => {
-    // arrange
-    const sut = sutFactory();
-    const expectedType = sut.action.type;
-    const visitor = new FilterChangeDetailsVisitorStub();
-    // act
-    sut.visit(visitor);
-    // assert
-    expect(
-      visitor.visitedEvents.filter((action) => action === expectedType),
-    ).to.have.lengthOf(1);
-  });
-}
diff --git a/tests/unit/application/Context/State/Filter/FilterResult.spec.ts b/tests/unit/application/Context/State/Filter/FilterResult.spec.ts
deleted file mode 100644
index b39492e0..00000000
--- a/tests/unit/application/Context/State/Filter/FilterResult.spec.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { FilterResult } from '@/application/Context/State/Filter/FilterResult';
-import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
-import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
-
-describe('FilterResult', () => {
-  describe('hasAnyMatches', () => {
-    it('false when no matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [],
-        /* categoryMatches */ [],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(false);
-    });
-    it('true when script matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [new ScriptStub('id')],
-        /* categoryMatches */ [],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(true);
-    });
-    it('true when category matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [],
-        /* categoryMatches */ [new CategoryStub(5)],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(true);
-    });
-    it('true when script + category matches', () => {
-      const sut = new FilterResult(
-        /* scriptMatches */ [new ScriptStub('id')],
-        /* categoryMatches */ [new CategoryStub(5)],
-        'query',
-      );
-      const actual = sut.hasAnyMatches();
-      expect(actual).to.equal(true);
-    });
-  });
-});
diff --git a/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts b/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
new file mode 100644
index 00000000..f20c42aa
--- /dev/null
+++ b/tests/unit/application/Context/State/Filter/Result/AppliedFilterResult.spec.ts
@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
+import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
+import { AppliedFilterResult } from '@/application/Context/State/Filter/Result/AppliedFilterResult';
+import { ICategory, IScript } from '@/domain/ICategory';
+
+describe('AppliedFilterResult', () => {
+  describe('constructor', () => {
+    it('initializes query correctly', () => {
+      // arrange
+      const expectedQuery = 'expected query';
+      const builder = new ResultBuilder()
+        .withQuery(expectedQuery);
+      // act
+      const result = builder.build();
+      // assert
+      const actualQuery = result.query;
+      expect(actualQuery).to.equal(expectedQuery);
+    });
+  });
+  describe('hasAnyMatches', () => {
+    it('returns false with no matches', () => {
+      // arrange
+      const expected = false;
+      const result = new ResultBuilder()
+        .withScriptMatches([])
+        .withCategoryMatches([])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      // assert
+      expect(actual).to.equal(expected);
+    });
+    it('returns true with script matches', () => {
+      // arrange
+      const expected = true;
+      const result = new ResultBuilder()
+        .withScriptMatches([new ScriptStub('id')])
+        .withCategoryMatches([])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      expect(actual).to.equal(expected);
+    });
+    it('returns true with category matches', () => {
+      // arrange
+      const expected = true;
+      const result = new ResultBuilder()
+        .withScriptMatches([])
+        .withCategoryMatches([new CategoryStub(5)])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      expect(actual).to.equal(expected);
+    });
+    it('returns true with script and category matches', () => {
+      // arrange
+      const expected = true;
+      const result = new ResultBuilder()
+        .withScriptMatches([new ScriptStub('id')])
+        .withCategoryMatches([new CategoryStub(5)])
+        .build();
+      // act
+      const actual = result.hasAnyMatches();
+      expect(actual).to.equal(expected);
+    });
+  });
+});
+
+class ResultBuilder {
+  private scriptMatches: readonly IScript[] = [new ScriptStub('id')];
+
+  private categoryMatches: readonly ICategory[] = [new CategoryStub(5)];
+
+  private query: string = `[${ResultBuilder.name}]query`;
+
+  public withScriptMatches(scriptMatches: readonly IScript[]): this {
+    this.scriptMatches = scriptMatches;
+    return this;
+  }
+
+  public withCategoryMatches(categoryMatches: readonly ICategory[]): this {
+    this.categoryMatches = categoryMatches;
+    return this;
+  }
+
+  public withQuery(query: string) {
+    this.query = query;
+    return this;
+  }
+
+  public build(): AppliedFilterResult {
+    return new AppliedFilterResult(
+      this.scriptMatches,
+      this.categoryMatches,
+      this.query,
+    );
+  }
+}
diff --git a/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts b/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
new file mode 100644
index 00000000..87e20896
--- /dev/null
+++ b/tests/unit/application/Context/State/Filter/Strategy/LinearFilterStrategy.spec.ts
@@ -0,0 +1,278 @@
+import { describe, it, expect } from 'vitest';
+import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
+import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
+import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { ICategory } from '@/domain/ICategory';
+import { IScript } from '@/domain/IScript';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { LinearFilterStrategy } from '@/application/Context/State/Filter/Strategy/LinearFilterStrategy';
+
+describe('LinearFilterStrategy', () => {
+  describe('applyFilter', () => {
+    describe('query', () => {
+      it('returns provided filter', () => {
+        // arrange
+        const expectedQuery = 'non matching filter';
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(expectedQuery);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.query).to.equal(expectedQuery);
+      });
+    });
+    describe('hasAnyMatches', () => {
+      it('returns false when there are no matches', () => {
+        // arrange
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter('non matching filter')
+          .withCollection(new CategoryCollectionStub());
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(false);
+      });
+      it('returns true for a script match', () => {
+        // arrange
+        const matchingFilter = 'matching filter';
+        const collection = new CategoryCollectionStub()
+          .withAction(new CategoryStub(2).withScript(createMatchingScript(matchingFilter)));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(matchingFilter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(true);
+      });
+      it('returns true for a category match', () => {
+        // arrange
+        const matchingFilter = 'matching filter';
+        const collection = new CategoryCollectionStub()
+          .withAction(createMatchingCategory(matchingFilter));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(matchingFilter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(true);
+      });
+      it('returns true for script and category matches', () => {
+        // arrange
+        const matchingFilter = 'matching filter';
+        const collection = new CategoryCollectionStub()
+          .withAction(createMatchingCategory(matchingFilter))
+          .withAction(new CategoryStub(2).withScript(createMatchingScript(matchingFilter)));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(matchingFilter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.hasAnyMatches()).be.equal(true);
+      });
+    });
+    describe('scriptMatches', () => {
+      it('returns empty when there are no matches', () => {
+        // arrange
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter('non matching filter')
+          .withCollection(new CategoryCollectionStub());
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.scriptMatches).to.have.lengthOf(0);
+      });
+      describe('returns single matching script', () => {
+        interface ScriptMatchTestScenario {
+          readonly description: string;
+          readonly filter: string;
+          readonly matchingScript: IScript;
+        }
+        const testScenarios: readonly ScriptMatchTestScenario[] = [
+          {
+            description: 'case-insensitive code',
+            filter: 'Hello WoRLD',
+            matchingScript: new ScriptStub('id').withCode('HELLO world'),
+          },
+          {
+            description: 'case-insensitive revert code',
+            filter: 'Hello WoRLD',
+            matchingScript: new ScriptStub('id').withRevertCode('HELLO world'),
+          },
+          {
+            description: 'case-insensitive name',
+            filter: 'Hello WoRLD',
+            matchingScript: new ScriptStub('id').withName('HELLO world'),
+          },
+          {
+            description: 'case-insensitive documentation',
+            filter: 'MaTChing doC',
+            matchingScript: new ScriptStub('id').withDocs(['unrelated docs', 'matching Docs']),
+          },
+        ];
+        testScenarios.forEach(({
+          description, filter, matchingScript,
+        }) => {
+          it(description, () => {
+            // arrange
+            const expectedMatches = [matchingScript];
+            const collection = new CategoryCollectionStub()
+              .withAction(new CategoryStub(33).withScript(matchingScript));
+            const strategy = new FilterStrategyTestBuilder()
+              .withFilter(filter)
+              .withCollection(collection);
+            // act
+            const result = strategy.applyFilter();
+            // assert
+            expectScriptMatches(result, expectedMatches);
+          });
+        });
+      });
+      it('returns multiple matching scripts', () => {
+        // arrange
+        const filter = 'matching filter';
+        const matchingScripts: readonly IScript[] = [
+          createMatchingScript(filter),
+          createMatchingScript(filter),
+        ];
+        const expectedMatches = [...matchingScripts];
+        const collection = new CategoryCollectionStub()
+          .withAction(new CategoryStub(0).withScripts(...matchingScripts));
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(filter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expectScriptMatches(result, expectedMatches);
+      });
+    });
+    describe('categoryMatches', () => {
+      it('returns empty when there are no matches', () => {
+        // arrange
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter('non matching filter')
+          .withCollection(new CategoryCollectionStub());
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expect(result.categoryMatches).to.have.lengthOf(0);
+      });
+      describe('returns single matching category', () => {
+        interface CategoryMatchTestScenario {
+          readonly description: string;
+          readonly filter: string;
+          readonly matchingCategory: ICategory;
+        }
+        const testScenarios: readonly CategoryMatchTestScenario[] = [
+          {
+            description: 'match with case-insensitive name',
+            filter: 'Hello WoRLD',
+            matchingCategory: new CategoryStub(55).withName('HELLO world'),
+          },
+          {
+            description: 'case-sensitive documentation',
+            filter: 'Hello WoRLD',
+            matchingCategory: new CategoryStub(55).withDocs(['unrelated-docs', 'HELLO world']),
+          },
+        ];
+        testScenarios.forEach(({
+          description, filter, matchingCategory,
+        }) => {
+          it(description, () => {
+            // arrange
+            const expectedMatches = [matchingCategory];
+            const collection = new CategoryCollectionStub()
+              .withAction(matchingCategory);
+            const strategy = new FilterStrategyTestBuilder()
+              .withFilter(filter)
+              .withCollection(collection);
+            // act
+            const result = strategy.applyFilter();
+            // assert
+            expectCategoryMatches(result, expectedMatches);
+          });
+        });
+      });
+      it('returns multiple matching categories', () => {
+        // arrange
+        const filter = 'matching filter';
+        const matchingCategories: readonly ICategory[] = [
+          createMatchingCategory(filter),
+          createMatchingCategory(filter),
+        ];
+        const expectedMatches = [...matchingCategories];
+        const collection = new CategoryCollectionStub()
+          .withActions(...matchingCategories);
+        const strategy = new FilterStrategyTestBuilder()
+          .withFilter(filter)
+          .withCollection(collection);
+        // act
+        const result = strategy.applyFilter();
+        // assert
+        expectCategoryMatches(result, expectedMatches);
+      });
+    });
+  });
+});
+
+function createMatchingScript(
+  matchingFilter: string,
+): ScriptStub {
+  return new ScriptStub('matching-script')
+    .withCode(matchingFilter)
+    .withName(matchingFilter);
+}
+
+function createMatchingCategory(
+  matchingFilter: string,
+): CategoryStub {
+  return new CategoryStub(1)
+    .withName(matchingFilter)
+    .withDocs([matchingFilter]);
+}
+
+function expectCategoryMatches(
+  actualFilter: FilterResult,
+  expectedMatches: readonly ICategory[],
+): void {
+  expect(actualFilter.hasAnyMatches()).be.equal(true);
+  expect(actualFilter.categoryMatches).to.have.lengthOf(expectedMatches.length);
+  expect(actualFilter.categoryMatches).to.have.members(expectedMatches);
+}
+
+function expectScriptMatches(
+  actualFilter: FilterResult,
+  expectedMatches: readonly IScript[],
+): void {
+  expect(actualFilter.hasAnyMatches()).be.equal(true);
+  expect(actualFilter.scriptMatches).to.have.lengthOf(expectedMatches.length);
+  expect(actualFilter.scriptMatches).to.have.members(expectedMatches);
+}
+
+class FilterStrategyTestBuilder {
+  private filter: string = `[${FilterStrategyTestBuilder.name}]filter`;
+
+  private collection: ICategoryCollection = new CategoryCollectionStub();
+
+  public withCollection(collection: ICategoryCollection): this {
+    this.collection = collection;
+    return this;
+  }
+
+  public withFilter(filter: string): this {
+    this.filter = filter;
+    return this;
+  }
+
+  public applyFilter(): ReturnType<LinearFilterStrategy['applyFilter']> {
+    const strategy = new LinearFilterStrategy();
+    return strategy.applyFilter(
+      this.filter,
+      this.collection,
+    );
+  }
+}
diff --git a/tests/unit/application/Context/State/Filter/UserFilter.spec.ts b/tests/unit/application/Context/State/Filter/UserFilter.spec.ts
deleted file mode 100644
index 356a45a3..00000000
--- a/tests/unit/application/Context/State/Filter/UserFilter.spec.ts
+++ /dev/null
@@ -1,194 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { UserFilter } from '@/application/Context/State/Filter/UserFilter';
-import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
-import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
-import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
-import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollectionStub';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { ICategoryCollection } from '@/domain/ICategoryCollection';
-import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-
-describe('UserFilter', () => {
-  describe('clearFilter', () => {
-    it('signals when removing filter', () => {
-      // arrange
-      const expectedChange = FilterChangeDetailsStub.forClear();
-      let actualChange: IFilterChangeDetails | undefined;
-      const sut = new UserFilter(new CategoryCollectionStub());
-      sut.filterChanged.on((change) => {
-        actualChange = change;
-      });
-      // act
-      sut.clearFilter();
-      // assert
-      expectExists(actualChange);
-      expect(actualChange).to.deep.equal(expectedChange);
-    });
-    it('sets currentFilter to undefined', () => {
-      // arrange
-      const sut = new UserFilter(new CategoryCollectionStub());
-      // act
-      sut.applyFilter('non-important');
-      sut.clearFilter();
-      // assert
-      expect(sut.currentFilter).to.be.equal(undefined);
-    });
-  });
-  describe('applyFilter', () => {
-    interface IApplyFilterTestCase {
-      readonly name: string;
-      readonly filter: string;
-      readonly collection: ICategoryCollection;
-      readonly assert: (result: IFilterResult) => void;
-    }
-    const testCases: readonly IApplyFilterTestCase[] = [
-      (() => {
-        const nonMatchingFilter = 'non matching filter';
-        return {
-          name: 'given no matches',
-          filter: nonMatchingFilter,
-          collection: new CategoryCollectionStub(),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(false);
-            expect(filter.query).to.equal(nonMatchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const code = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('id').withCode(code);
-        return {
-          name: 'given script match with case-insensitive code',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(new CategoryStub(33).withScript(script)),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(0);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const revertCode = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('id').withRevertCode(revertCode);
-        return {
-          name: 'given script match with case-insensitive revertCode',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(new CategoryStub(33).withScript(script)),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(0);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const name = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('id').withName(name);
-        return {
-          name: 'given script match with case-insensitive name',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(new CategoryStub(33).withScript(script)),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(0);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const categoryName = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const category = new CategoryStub(55).withName(categoryName);
-        return {
-          name: 'given category match with case-insensitive name',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(category),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(1);
-            expect(filter.categoryMatches[0]).to.deep.equal(category);
-            expect(filter.scriptMatches).to.have.lengthOf(0);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-      (() => {
-        const matchingText = 'HELLO world';
-        const matchingFilter = 'Hello WoRLD';
-        const script = new ScriptStub('script')
-          .withName(matchingText);
-        const category = new CategoryStub(55)
-          .withName(matchingText)
-          .withScript(script);
-        return {
-          name: 'given category and script matches with case-insensitive names',
-          filter: matchingFilter,
-          collection: new CategoryCollectionStub()
-            .withAction(category),
-          assert: (filter) => {
-            expect(filter.hasAnyMatches()).be.equal(true);
-            expect(filter.categoryMatches).to.have.lengthOf(1);
-            expect(filter.categoryMatches[0]).to.deep.equal(category);
-            expect(filter.scriptMatches).to.have.lengthOf(1);
-            expect(filter.scriptMatches[0]).to.deep.equal(script);
-            expect(filter.query).to.equal(matchingFilter);
-          },
-        };
-      })(),
-    ];
-    describe('sets currentFilter as expected', () => {
-      testCases.forEach(({
-        name, filter, collection, assert,
-      }) => {
-        it(name, () => {
-          // arrange
-          const sut = new UserFilter(collection);
-          // act
-          sut.applyFilter(filter);
-          // assert
-          const actual = sut.currentFilter;
-          expectExists(actual);
-          assert(actual);
-        });
-      });
-    });
-    describe('signals as expected', () => {
-      testCases.forEach(({
-        name, filter, collection, assert,
-      }) => {
-        it(name, () => {
-          // arrange
-          const sut = new UserFilter(collection);
-          let actualFilterResult: IFilterResult | undefined;
-          sut.filterChanged.on((filterResult) => {
-            filterResult.visit({
-              onApply: (result) => {
-                actualFilterResult = result;
-              },
-            });
-          });
-          // act
-          sut.applyFilter(filter);
-          // assert
-          expectExists(actualFilterResult);
-          assert(actualFilterResult);
-        });
-      });
-    });
-  });
-});
diff --git a/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts b/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts
index 3a911449..5dc1af8d 100644
--- a/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/TheScriptsView.spec.ts
@@ -9,12 +9,12 @@ import { useCollectionState } from '@/presentation/components/Shared/Hooks/UseCo
 import { UseCollectionStateStub } from '@tests/unit/shared/Stubs/UseCollectionStateStub';
 import { InjectionKeys } from '@/presentation/injectionSymbols';
 import { UseApplicationStub } from '@tests/unit/shared/Stubs/UseApplicationStub';
-import { UserFilterMethod, UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
 import { FilterResultStub } from '@tests/unit/shared/Stubs/FilterResultStub';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
 import { UseAutoUnsubscribedEventsStub } from '@tests/unit/shared/Stubs/UseAutoUnsubscribedEventsStub';
 import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
+import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 
 const DOM_SELECTOR_NO_MATCHES = '.search-no-matches';
 const DOM_SELECTOR_CLOSE_BUTTON = '.search__query__close-button';
@@ -22,12 +22,12 @@ const DOM_SELECTOR_CLOSE_BUTTON = '.search__query__close-button';
 describe('TheScriptsView.vue', () => {
   describe('view types', () => {
     describe('initially', () => {
-      interface IInitialViewTypeTestCase {
+      interface InitialViewTypeTestCase {
         readonly initialView: ViewType;
         readonly expectedComponent: Component;
         readonly absentComponents: readonly Component[];
       }
-      const testCases: readonly IInitialViewTypeTestCase[] = [
+      const testCases: readonly InitialViewTypeTestCase[] = [
         {
           initialView: ViewType.Tree,
           expectedComponent: ScriptsTree,
@@ -96,20 +96,20 @@ describe('TheScriptsView.vue', () => {
   });
 
   describe('switching views', () => {
-    interface ISwitchingViewTestCase {
+    interface ViewSwitchTestScenario {
       readonly name: string;
       readonly initialView: ViewType;
-      readonly changeEvents: readonly IFilterChangeDetails[];
+      readonly changeEvents: readonly FilterChangeDetails[];
       readonly componentsToDisappear: readonly Component[];
       readonly expectedComponent: Component;
-      readonly setupFilter?: (filter: UserFilterStub) => UserFilterStub;
+      readonly setupFilter?: (filter: FilterContextStub) => FilterContextStub;
     }
-    const testCases: readonly ISwitchingViewTestCase[] = [
+    const testCases: readonly ViewSwitchTestScenario[] = [
       {
         name: 'tree on initial search with card view',
         initialView: ViewType.Cards,
-        setupFilter: (filter: UserFilterStub) => filter
-          .withCurrentFilterResult(
+        setupFilter: (filter: FilterContextStub) => filter
+          .withCurrentFilter(
             new FilterResultStub().withQueryAndSomeMatches(),
           ),
         changeEvents: [],
@@ -119,8 +119,8 @@ describe('TheScriptsView.vue', () => {
       {
         name: 'restore card after initial search',
         initialView: ViewType.Cards,
-        setupFilter: (filter: UserFilterStub) => filter
-          .withCurrentFilterResult(
+        setupFilter: (filter: FilterContextStub) => filter
+          .withCurrentFilter(
             new FilterResultStub().withQueryAndSomeMatches(),
           ),
         changeEvents: [
@@ -171,7 +171,7 @@ describe('TheScriptsView.vue', () => {
     }) => {
       it(name, async () => {
         // arrange
-        let filterStub = new UserFilterStub();
+        let filterStub = new FilterContextStub();
         if (setupFilter) {
           filterStub = setupFilter(filterStub);
         }
@@ -201,7 +201,7 @@ describe('TheScriptsView.vue', () => {
       describe('does not show close button when not searching', () => {
         it('not searching initially', () => {
           // arrange
-          const filterStub = new UserFilterStub()
+          const filterStub = new FilterContextStub()
             .withNoCurrentFilter();
           const stateStub = new UseCollectionStateStub()
             .withFilter(filterStub);
@@ -217,7 +217,7 @@ describe('TheScriptsView.vue', () => {
         });
         it('stop searching', async () => {
           // arrange
-          const filterStub = new UserFilterStub();
+          const filterStub = new FilterContextStub();
           const stateStub = new UseCollectionStateStub().withFilter(filterStub);
           const wrapper = mountComponent({
             useCollectionState: stateStub.get(),
@@ -239,8 +239,8 @@ describe('TheScriptsView.vue', () => {
       describe('shows close button when searching', () => {
         it('searching initially', () => {
           // arrange
-          const filterStub = new UserFilterStub()
-            .withCurrentFilterResult(
+          const filterStub = new FilterContextStub()
+            .withCurrentFilter(
               new FilterResultStub().withQueryAndSomeMatches(),
             );
           const stateStub = new UseCollectionStateStub()
@@ -257,7 +257,7 @@ describe('TheScriptsView.vue', () => {
         });
         it('start searching', async () => {
           // arrange
-          const filterStub = new UserFilterStub()
+          const filterStub = new FilterContextStub()
             .withNoCurrentFilter();
           const stateStub = new UseCollectionStateStub().withFilter(filterStub);
           const wrapper = mountComponent({
@@ -279,7 +279,7 @@ describe('TheScriptsView.vue', () => {
 
     it('clears search query on close button click', async () => {
       // arrange
-      const filterStub = new UserFilterStub();
+      const filterStub = new FilterContextStub();
       const stateStub = new UseCollectionStateStub().withFilter(filterStub);
       const wrapper = mountComponent({
         useCollectionState: stateStub.get(),
@@ -296,14 +296,14 @@ describe('TheScriptsView.vue', () => {
 
       // assert
       expect(filterStub.callHistory).to.have.lengthOf(1);
-      expect(filterStub.callHistory).to.include(UserFilterMethod.ClearFilter);
+      expect(filterStub.callHistory.find((c) => c.methodName === 'clearFilter')).toBeDefined();
     });
   });
 
   describe('no matches text', () => {
     interface NoMatchesTextTestCase {
       readonly name: string;
-      readonly filter: IFilterResult;
+      readonly filter: FilterResult;
       readonly shouldNoMatchesExist: boolean;
     }
     const commonTestCases: readonly NoMatchesTextTestCase[] = [
@@ -322,7 +322,7 @@ describe('TheScriptsView.vue', () => {
     ];
     describe('initial state', () => {
       interface InitialStateTestCase extends Omit<NoMatchesTextTestCase, 'filter'> {
-        readonly filter?: IFilterResult;
+        readonly filter?: FilterResult;
       }
       const initialStateTestCases: readonly InitialStateTestCase[] = [
         ...commonTestCases,
@@ -355,7 +355,7 @@ describe('TheScriptsView.vue', () => {
         it(name, async () => {
           // arrange
           const expected = shouldNoMatchesExist;
-          const filterStub = new UserFilterStub();
+          const filterStub = new FilterContextStub();
           const stateStub = new UseCollectionStateStub()
             .withFilter(filterStub);
           const wrapper = mountComponent({
@@ -375,7 +375,7 @@ describe('TheScriptsView.vue', () => {
       });
       it('shows no text if filter is removed after matches', async () => {
         // arrange
-        const filter = new UserFilterStub();
+        const filter = new FilterContextStub();
         const stub = new UseCollectionStateStub()
           .withFilter(filter);
         const wrapper = mountComponent({
diff --git a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts
index 033d5c76..b120c6cb 100644
--- a/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts
+++ b/tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.spec.ts
@@ -14,14 +14,14 @@ import { HierarchyAccessStub } from '@tests/unit/shared/Stubs/HierarchyAccessStu
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
 import { TreeNode } from '@/presentation/components/Scripts/View/Tree/TreeView/Node/TreeNode';
-import { UserFilterStub } from '@tests/unit/shared/Stubs/UserFilterStub';
 import { FilterChangeDetailsStub } from '@tests/unit/shared/Stubs/FilterChangeDetailsStub';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
 import { CategoryCollectionStateStub } from '@tests/unit/shared/Stubs/CategoryCollectionStateStub';
 import { NodeMetadataStub } from '@tests/unit/shared/Stubs/NodeMetadataStub';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
+import { FilterContextStub } from '@tests/unit/shared/Stubs/FilterContextStub';
 
 describe('UseTreeViewFilterEvent', () => {
   describe('initially', () => {
@@ -45,8 +45,8 @@ describe('UseTreeViewFilterEvent', () => {
         // arrange
         const newFilter = filterChange;
         const initialFilter = new FilterResultStub().withSomeMatches();
-        const filterStub = new UserFilterStub()
-          .withCurrentFilterResult(initialFilter);
+        const filterStub = new FilterContextStub()
+          .withCurrentFilter(initialFilter);
         const stateStub = new UseCollectionStateStub()
           .withFilter(filterStub);
         const { returnObject } = mountWrapperComponent({ useStateStub: stateStub });
@@ -63,8 +63,8 @@ describe('UseTreeViewFilterEvent', () => {
         // arrange
         const newFilter = filterChange;
         const initialFilter = new FilterResultStub().withSomeMatches();
-        const filterStub = new UserFilterStub()
-          .withCurrentFilterResult(initialFilter);
+        const filterStub = new FilterContextStub()
+          .withCurrentFilter(initialFilter);
         const stateStub = new UseCollectionStateStub()
           .withFilter(filterStub);
         const { returnObject } = mountWrapperComponent({ useStateStub: stateStub });
@@ -90,7 +90,7 @@ describe('UseTreeViewFilterEvent', () => {
       testFilterEvents((_, filterResult) => {
         // arrange
         const newCollection = new CategoryCollectionStateStub()
-          .withFilter(new UserFilterStub().withCurrentFilterResult(filterResult));
+          .withFilter(new FilterContextStub().withCurrentFilter(filterResult));
         const initialCollection = new CategoryCollectionStateStub();
         const useCollectionStateStub = new UseCollectionStateStub()
           .withState(initialCollection);
@@ -113,9 +113,9 @@ describe('UseTreeViewFilterEvent', () => {
         // arrange
         const newFilter = filterChange;
         const initialFilter = new FilterResultStub().withSomeMatches();
-        const filterStub = new UserFilterStub();
+        const filterStub = new FilterContextStub();
         const newCollection = new CategoryCollectionStateStub()
-          .withFilter(filterStub.withCurrentFilterResult(initialFilter));
+          .withFilter(filterStub.withCurrentFilter(initialFilter));
         const initialCollection = new CategoryCollectionStateStub();
         const useCollectionStateStub = new UseCollectionStateStub()
           .withState(initialCollection);
@@ -170,8 +170,8 @@ function mountWrapperComponent(options?: {
 }
 
 type FilterChangeTestScenario = (
-  result: IFilterChangeDetails,
-  filter: IFilterResult | undefined,
+  result: FilterChangeDetails,
+  filter: FilterResult | undefined,
 ) => Promise<{
   readonly event: Ref<TreeViewFilterEvent | undefined>,
 }>;
diff --git a/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts b/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
index 986c0e79..bdb197f8 100644
--- a/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
+++ b/tests/unit/shared/Stubs/CategoryCollectionStateStub.ts
@@ -1,5 +1,4 @@
 import { IApplicationCode } from '@/application/Context/State/Code/IApplicationCode';
-import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
 import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { IScript } from '@/domain/IScript';
@@ -7,9 +6,10 @@ import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { UserSelection } from '@/application/Context/State/Selection/UserSelection';
 import { SelectedScript } from '@/application/Context/State/Selection/Script/SelectedScript';
+import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
 import { CategoryCollectionStub } from './CategoryCollectionStub';
 import { UserSelectionStub } from './UserSelectionStub';
-import { UserFilterStub } from './UserFilterStub';
+import { FilterContextStub } from './FilterContextStub';
 import { ApplicationCodeStub } from './ApplicationCodeStub';
 import { CategoryStub } from './CategoryStub';
 import { ScriptSelectionStub } from './ScriptSelectionStub';
@@ -17,7 +17,7 @@ import { ScriptSelectionStub } from './ScriptSelectionStub';
 export class CategoryCollectionStateStub implements ICategoryCollectionState {
   public code: IApplicationCode = new ApplicationCodeStub();
 
-  public filter: IUserFilter = new UserFilterStub();
+  public filter: FilterContext = new FilterContextStub();
 
   public get os(): OperatingSystem {
     return this.collection.os;
@@ -55,7 +55,7 @@ export class CategoryCollectionStateStub implements ICategoryCollectionState {
     return this;
   }
 
-  public withFilter(filter: IUserFilter): this {
+  public withFilter(filter: FilterContext): this {
     this.filter = filter;
     return this;
   }
@@ -69,7 +69,7 @@ export class CategoryCollectionStateStub implements ICategoryCollectionState {
     );
   }
 
-  public withSelection(selection: UserSelection) {
+  public withSelection(selection: UserSelection): this {
     this.selection = selection;
     return this;
   }
diff --git a/tests/unit/shared/Stubs/CategoryStub.ts b/tests/unit/shared/Stubs/CategoryStub.ts
index 95fe0af6..e1267c33 100644
--- a/tests/unit/shared/Stubs/CategoryStub.ts
+++ b/tests/unit/shared/Stubs/CategoryStub.ts
@@ -10,7 +10,7 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
 
   public readonly scripts = new Array<IScript>();
 
-  public readonly docs = new Array<string>();
+  public docs: readonly string[] = new Array<string>();
 
   private allScriptsRecursively: (readonly IScript[]) | undefined;
 
@@ -82,4 +82,9 @@ export class CategoryStub extends BaseEntity<number> implements ICategory {
     this.name = categoryName;
     return this;
   }
+
+  public withDocs(docs: readonly string[]): this {
+    this.docs = docs;
+    return this;
+  }
 }
diff --git a/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts b/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts
index da741b11..b4efb078 100644
--- a/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts
+++ b/tests/unit/shared/Stubs/FilterChangeDetailsStub.ts
@@ -1,9 +1,9 @@
 import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
-import { FilterAction, IFilterChangeDetails, IFilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import type { FilterAction, FilterChangeDetails, FilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 
-export class FilterChangeDetailsStub implements IFilterChangeDetails {
-  public static forApply(filter: IFilterResult) {
+export class FilterChangeDetailsStub implements FilterChangeDetails {
+  public static forApply(filter: FilterResult) {
     return new FilterChangeDetailsStub({
       type: FilterActionType.Apply,
       filter,
@@ -20,7 +20,7 @@ export class FilterChangeDetailsStub implements IFilterChangeDetails {
     public readonly action: FilterAction,
   ) { /* Private constructor to enforce factory methods */ }
 
-  visit(visitor: IFilterChangeDetailsVisitor): void {
+  visit(visitor: FilterChangeDetailsVisitor): void {
     if (this.action.type === FilterActionType.Apply) {
       if (visitor.onApply) {
         visitor.onApply(this.action.filter);
diff --git a/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts b/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts
index 8ee90a76..dabe554a 100644
--- a/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts
+++ b/tests/unit/shared/Stubs/FilterChangeDetailsVisitorStub.ts
@@ -1,18 +1,21 @@
-import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
-import { IFilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import type { FilterChangeDetailsVisitor } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
-export class FilterChangeDetailsVisitorStub implements IFilterChangeDetailsVisitor {
-  public readonly visitedEvents = new Array<FilterActionType>();
-
-  public readonly visitedResults = new Array<IFilterResult>();
-
-  onClear(): void {
-    this.visitedEvents.push(FilterActionType.Clear);
+export class FilterChangeDetailsVisitorStub
+  extends StubWithObservableMethodCalls<Required<FilterChangeDetailsVisitor>>
+  implements FilterChangeDetailsVisitor {
+  public onClear(): void {
+    this.registerMethodCall({
+      methodName: 'onClear',
+      args: [],
+    });
   }
 
-  onApply(filter: IFilterResult): void {
-    this.visitedEvents.push(FilterActionType.Apply);
-    this.visitedResults.push(filter);
+  public onApply(filter: FilterResult): void {
+    this.registerMethodCall({
+      methodName: 'onApply',
+      args: [filter],
+    });
   }
 }
diff --git a/tests/unit/shared/Stubs/FilterContextStub.ts b/tests/unit/shared/Stubs/FilterContextStub.ts
new file mode 100644
index 00000000..6ba05c40
--- /dev/null
+++ b/tests/unit/shared/Stubs/FilterContextStub.ts
@@ -0,0 +1,55 @@
+import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
+import { IEventSource } from '@/infrastructure/Events/IEventSource';
+import { FilterChangeDetails } from '@/application/Context/State/Filter/Event/FilterChangeDetails';
+import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { FilterResultStub } from './FilterResultStub';
+import { EventSourceStub } from './EventSourceStub';
+import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
+
+export enum FilterMethod {
+  ApplyFilter,
+  ClearFilter,
+}
+
+export class FilterContextStub
+  extends StubWithObservableMethodCalls<FilterContext>
+  implements FilterContext {
+  private readonly filterChangedSource = new EventSourceStub<FilterChangeDetails>();
+
+  public currentFilter: FilterResult | undefined = new FilterResultStub();
+
+  public filterChanged: IEventSource<FilterChangeDetails> = this.filterChangedSource;
+
+  public notifyFilterChange(change: FilterChangeDetails): void {
+    this.filterChangedSource.notify(change);
+    if (change.action.type === FilterActionType.Apply) {
+      this.currentFilter = change.action.filter;
+    } else {
+      this.currentFilter = undefined;
+    }
+  }
+
+  public withNoCurrentFilter(): this {
+    return this.withCurrentFilter(undefined);
+  }
+
+  public withCurrentFilter(filter: FilterResult | undefined): this {
+    this.currentFilter = filter;
+    return this;
+  }
+
+  public applyFilter(...args: Parameters<FilterContext['applyFilter']>): void {
+    this.registerMethodCall({
+      methodName: 'applyFilter',
+      args: [...args],
+    });
+  }
+
+  public clearFilter(): void {
+    this.registerMethodCall({
+      methodName: 'clearFilter',
+      args: [],
+    });
+  }
+}
diff --git a/tests/unit/shared/Stubs/FilterResultStub.ts b/tests/unit/shared/Stubs/FilterResultStub.ts
index 30154fa7..b61c0d6f 100644
--- a/tests/unit/shared/Stubs/FilterResultStub.ts
+++ b/tests/unit/shared/Stubs/FilterResultStub.ts
@@ -1,10 +1,10 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { ICategory } from '@/domain/ICategory';
-import { IScript } from '@/domain/IScript';
+import type { ICategory } from '@/domain/ICategory';
+import type { IScript } from '@/domain/IScript';
+import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { CategoryStub } from './CategoryStub';
 import { ScriptStub } from './ScriptStub';
 
-export class FilterResultStub implements IFilterResult {
+export class FilterResultStub implements FilterResult {
   public categoryMatches: readonly ICategory[] = [];
 
   public scriptMatches: readonly IScript[] = [];
diff --git a/tests/unit/shared/Stubs/FilterStrategyStub.ts b/tests/unit/shared/Stubs/FilterStrategyStub.ts
new file mode 100644
index 00000000..71c7117d
--- /dev/null
+++ b/tests/unit/shared/Stubs/FilterStrategyStub.ts
@@ -0,0 +1,24 @@
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
+import { FilterStrategy } from '@/application/Context/State/Filter/Strategy/FilterStrategy';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+import { FilterResultStub } from './FilterResultStub';
+import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
+
+export class FilterStrategyStub
+  extends StubWithObservableMethodCalls<FilterStrategy>
+  implements FilterStrategy {
+  private predeterminedResult: FilterResult = new FilterResultStub();
+
+  public applyFilter(filter: string, collection: ICategoryCollection): FilterResult {
+    this.registerMethodCall({
+      methodName: 'applyFilter',
+      args: [filter, collection],
+    });
+    return this.predeterminedResult;
+  }
+
+  public withApplyFilterResult(predeterminedResult: FilterResult): this {
+    this.predeterminedResult = predeterminedResult;
+    return this;
+  }
+}
diff --git a/tests/unit/shared/Stubs/ScriptStub.ts b/tests/unit/shared/Stubs/ScriptStub.ts
index 3830bcef..fe4faeb0 100644
--- a/tests/unit/shared/Stubs/ScriptStub.ts
+++ b/tests/unit/shared/Stubs/ScriptStub.ts
@@ -12,7 +12,7 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
     revert: `REM revert-code (${this.id})`,
   };
 
-  public readonly docs = new Array<string>();
+  public docs: readonly string[] = new Array<string>();
 
   public level? = RecommendationLevel.Standard;
 
@@ -60,6 +60,11 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
     return this;
   }
 
+  public withDocs(docs: readonly string[]): this {
+    this.docs = docs;
+    return this;
+  }
+
   public toSelectedScript(): SelectedScriptStub {
     return new SelectedScriptStub(this);
   }
diff --git a/tests/unit/shared/Stubs/UseCollectionStateStub.ts b/tests/unit/shared/Stubs/UseCollectionStateStub.ts
index 53679075..48c4a51c 100644
--- a/tests/unit/shared/Stubs/UseCollectionStateStub.ts
+++ b/tests/unit/shared/Stubs/UseCollectionStateStub.ts
@@ -4,12 +4,12 @@ import {
   StateModifier, useCollectionState,
 } from '@/presentation/components/Shared/Hooks/UseCollectionState';
 import { ICategoryCollectionState } from '@/application/Context/State/ICategoryCollectionState';
-import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
+import { FilterContext } from '@/application/Context/State/Filter/FilterContext';
 import { IApplicationContext } from '@/application/Context/IApplicationContext';
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
+import { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
 import { CategoryCollectionStateStub } from './CategoryCollectionStateStub';
 import { ApplicationContextStub } from './ApplicationContextStub';
-import { UserFilterStub } from './UserFilterStub';
+import { FilterContextStub } from './FilterContextStub';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
 export class UseCollectionStateStub
@@ -20,7 +20,7 @@ export class UseCollectionStateStub
     new CategoryCollectionStateStub(),
   );
 
-  public withFilter(filter: IUserFilter) {
+  public withFilter(filter: FilterContext) {
     const state = new CategoryCollectionStateStub()
       .withFilter(filter);
     const context = new ApplicationContextStub()
@@ -30,9 +30,9 @@ export class UseCollectionStateStub
       .withContext(context);
   }
 
-  public withFilterResult(filterResult: IFilterResult | undefined) {
-    const filter = new UserFilterStub()
-      .withCurrentFilterResult(filterResult);
+  public withFilterResult(filterResult: FilterResult | undefined) {
+    const filter = new FilterContextStub()
+      .withCurrentFilter(filterResult);
     return this.withFilter(filter);
   }
 
diff --git a/tests/unit/shared/Stubs/UserFilterStub.ts b/tests/unit/shared/Stubs/UserFilterStub.ts
deleted file mode 100644
index 464aee53..00000000
--- a/tests/unit/shared/Stubs/UserFilterStub.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { IFilterResult } from '@/application/Context/State/Filter/IFilterResult';
-import { IUserFilter } from '@/application/Context/State/Filter/IUserFilter';
-import { IEventSource } from '@/infrastructure/Events/IEventSource';
-import { IFilterChangeDetails } from '@/application/Context/State/Filter/Event/IFilterChangeDetails';
-import { FilterActionType } from '@/application/Context/State/Filter/Event/FilterActionType';
-import { FilterResultStub } from './FilterResultStub';
-import { EventSourceStub } from './EventSourceStub';
-
-export enum UserFilterMethod {
-  ApplyFilter,
-  ClearFilter,
-}
-
-export class UserFilterStub implements IUserFilter {
-  private readonly filterChangedSource = new EventSourceStub<IFilterChangeDetails>();
-
-  public readonly callHistory = new Array<UserFilterMethod>();
-
-  public currentFilter: IFilterResult | undefined = new FilterResultStub();
-
-  public filterChanged: IEventSource<IFilterChangeDetails> = this.filterChangedSource;
-
-  public notifyFilterChange(change: IFilterChangeDetails) {
-    this.filterChangedSource.notify(change);
-    if (change.action.type === FilterActionType.Apply) {
-      this.currentFilter = change.action.filter;
-    } else {
-      this.currentFilter = undefined;
-    }
-  }
-
-  public withNoCurrentFilter() {
-    return this.withCurrentFilterResult(undefined);
-  }
-
-  public withCurrentFilterResult(filter: IFilterResult | undefined) {
-    this.currentFilter = filter;
-    return this;
-  }
-
-  public applyFilter(): void {
-    this.callHistory.push(UserFilterMethod.ApplyFilter);
-  }
-
-  public clearFilter(): void {
-    this.callHistory.push(UserFilterMethod.ClearFilter);
-  }
-}