diff --git a/package.json b/package.json
index a9bd3d3c..acffec77 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@grapoza/vue-tree",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "Tree components for Vue 3",
   "author": "Gregg Rapoza <grapoza@gmail.com>",
   "license": "MIT",
diff --git a/src/components/TreeView.vue b/src/components/TreeView.vue
index f5163243..c7e659c7 100644
--- a/src/components/TreeView.vue
+++ b/src/components/TreeView.vue
@@ -28,7 +28,7 @@
         @treeNodeAdd="(t, p)=>$emit(TreeEvent.Add, t, p)"
         @treeNodeDelete="handleChildDeletion"
         @treeNodeAriaFocusableChange="handleFocusableChange"
-        @treeNodeAriaRequestFirstFocus="focusFirst(model)"
+        @treeNodeAriaRequestFirstFocus="(keepCurrentDomFocus) => focusFirst(model, keepCurrentDomFocus)"
         @treeNodeAriaRequestLastFocus="focusLast(model)"
         @treeNodeAriaRequestPreviousFocus="(t) => focusPrevious(model, t)"
         @treeNodeAriaRequestNextFocus="(t, f) => focusNext(model, t, f)"
@@ -55,13 +55,14 @@
 </template>
 
 <script setup>
-import { computed, nextTick, ref, readonly, onMounted, toRef } from 'vue'
+import { computed, nextTick, ref, readonly, onMounted, provide, toRef } from 'vue'
 import SelectionMode from '../enums/selectionMode.js';
 import { useIdGeneration } from '../composables/idGeneration.js'
 import { useTreeViewTraversal } from '../composables/treeViewTraversal.js'
 import { useFocus } from '../composables/focus/focus.js';
 import { useTreeViewFocus } from '../composables/focus/treeViewFocus.js';
 import { useSelection } from '../composables/selection/selection.js';
+import { useTreeViewFilter } from '../composables/filter/treeViewFilter.js';
 import { useTreeViewSelection } from '../composables/selection/treeViewSelection.js';
 import { useTreeViewDragAndDrop } from '../composables/dragDrop/treeViewDragAndDrop.js';
 import { useTreeViewConvenienceMethods } from '../composables/treeViewConvenienceMethods.js';
@@ -87,6 +88,11 @@ const props = defineProps({
       return true;
     }
   },
+  filterMethod: {
+    type: Function,
+    required: false,
+    default: null
+  },
   initialModel: {
     type: Array,
     required: false,
@@ -186,7 +192,6 @@ const {
   handleNodeSelectedChange,
 } = useTreeViewSelection(model, toRef(props, "selectionMode"), focusableNodeModel, emit);
 
-
 const {
   isSelectable,
   isSelected,
@@ -204,6 +209,8 @@ const {
 
 const { dragMoveNode, drop } = useTreeViewDragAndDrop(model, uniqueId, findById, removeById);
 
+useTreeViewFilter(model);
+
 // COMPUTED
 
 const areNodesLoaded = computed(() => {
@@ -323,6 +330,10 @@ function handleNodeDeletion(node) {
   }
 }
 
+// PROVIDE/INJECT
+
+provide("filterMethod", toRef(props, 'filterMethod'));
+
 // CREATION LOGIC
 
 // Force a unique tree ID. This will generate a unique ID internally, but on mount
diff --git a/src/components/TreeViewNode.spec.js b/src/components/TreeViewNode.spec.js
index de8ed958..a26c8208 100644
--- a/src/components/TreeViewNode.spec.js
+++ b/src/components/TreeViewNode.spec.js
@@ -34,7 +34,12 @@ async function createWrapper(customPropsData, slotsData) {
     sync: false,
     props: customPropsData || getDefaultPropsData(),
     slots: slotsData,
-    attachTo: '#root'
+    attachTo: '#root',
+    global: {
+      provide: {
+        filterMethod: null
+      }
+    }
   });
 
   await w.setProps({ isMounted: true });
diff --git a/src/components/TreeViewNode.vue b/src/components/TreeViewNode.vue
index 6ff1aa3c..c99e0cb9 100644
--- a/src/components/TreeViewNode.vue
+++ b/src/components/TreeViewNode.vue
@@ -6,8 +6,11 @@
   <li :id="nodeId"
       ref="nodeElement"
       class="grtvn"
-      :class="[customClasses.treeViewNode,
-      tns._.dragging ? 'grtvn-dragging' : '']"
+      :class="[
+        customClasses.treeViewNode,
+        tns._.dragging ? 'grtvn-dragging' : '',
+        filterIncludesNode ? '' : 'grtvn-hidden'
+      ]"
       role="treeitem"
       :tabindex="tabIndex"
       :aria-expanded="ariaExpanded"
@@ -197,7 +200,7 @@
                       @treeNodeDelete="handleChildDeletion"
                       @treeNodeAriaFocusableChange="(t)=>$emit(TreeEvent.FocusableChange, t)"
                       @treeNodeAriaRequestParentFocus="()=>focusNode()"
-                      @treeNodeAriaRequestFirstFocus="()=>$emit(TreeEvent.RequestFirstFocus)"
+                      @treeNodeAriaRequestFirstFocus="(keepCurrentDomFocus)=>$emit(TreeEvent.RequestFirstFocus, keepCurrentDomFocus)"
                       @treeNodeAriaRequestLastFocus="()=>$emit(TreeEvent.RequestLastFocus)"
                       @treeNodeAriaRequestPreviousFocus="focusPreviousNode"
                       @treeNodeAriaRequestNextFocus="focusNextNode"
@@ -231,6 +234,7 @@ import { useFocus } from '../composables/focus/focus.js';
 import { useTreeViewNodeFocus } from '../composables/focus/treeViewNodeFocus.js';
 import { useTreeViewNodeSelection } from '../composables/selection/treeViewNodeSelection.js';
 import { useTreeViewNodeExpansion } from '../composables/expansion/treeViewNodeExpansion.js';
+import { useTreeViewNodeFilter } from '../composables/filter/treeViewNodeFilter.js';
 import SelectionMode from '../enums/selectionMode.js';
 import TreeEvent from '../enums/event.js';
 
@@ -349,9 +353,14 @@ const {
   children,
   deleteChild,
   hasChildren,
-  mayHaveChildren,
 } = useTreeViewNodeChildren(model, emit);
 
+const {
+  filteredChildren,
+  filterIncludesNode,
+  mayHaveFilteredChildren
+} = useTreeViewNodeFilter(model, emit);
+
 const {
   focus,
   isFocused,
@@ -484,9 +493,9 @@ function onKeyDown(event) {
     // When focus is on a closed node, opens the node; focus does not move.
     // When focus is on a open node, moves focus to the first child node.
     // When focus is on an end node, does nothing.
-    if (mayHaveChildren.value && !areChildrenLoading.value) {
+    if (mayHaveFilteredChildren.value && !areChildrenLoading.value) {
       if (!expandNode() && isNodeExpanded()) {
-        focus(children.value[0]);
+        focus(filteredChildren.value[0]);
       }
     }
   }
@@ -551,12 +560,12 @@ function onKeyDown(event) {
 function handleChildDeletion(node) {
   // Remove the node from the array of children if this is an immediate child.
   // Note that only the node that was deleted fires these, not any subnode.
-  let targetIndex = children.value.indexOf(node);
+  let targetIndex = filteredChildren.value.indexOf(node);
   if (targetIndex > -1) {
     if (isFocused(node)) {
       // When this is the first of several siblings, focus the next node.
       // Otherwise, focus the previous node.
-      if (children.value.length > 1 && children.value.indexOf(node) === 0) {
+      if (filteredChildren.value.length > 1 && filteredChildren.value.indexOf(node) === 0) {
         focusNextNode(node);
       }
       else {
@@ -736,4 +745,8 @@ if (!label.value || typeof label.value !== 'string') {
     padding: 0;
     list-style: none;
   }
+
+  .grtv-wrapper.grtv-default-skin .grtvn.grtvn-hidden {
+    display: none;
+  }
 </style>
diff --git a/src/composables/children/children.js b/src/composables/children/children.js
new file mode 100644
index 00000000..ed7dbed2
--- /dev/null
+++ b/src/composables/children/children.js
@@ -0,0 +1,16 @@
+import { unref } from 'vue';
+
+/**
+ * Composable dealing with children on an arbitrary node.
+ * @returns {Object} Methods to deal with children arbitrary nodes
+ */
+export function useChildren() {
+
+  function getChildren(targetNodeModel) {
+    return unref(targetNodeModel)[unref(targetNodeModel).treeNodeSpec.childrenProperty ?? 'children'];
+  }
+
+  return {
+    getChildren,
+  };
+}
\ No newline at end of file
diff --git a/src/composables/children/children.spec.js b/src/composables/children/children.spec.js
new file mode 100644
index 00000000..cc3ef064
--- /dev/null
+++ b/src/composables/children/children.spec.js
@@ -0,0 +1,33 @@
+import { expect, describe, it } from 'vitest';
+import { useChildren } from './children.js';
+import { generateNodes } from 'tests/data/node-generator.js';
+
+const { getChildren } = useChildren();
+
+describe('children.js', () => {
+
+  describe('when getting children', () => {
+
+    describe('and the node model has a specified childrenProperty', () => {
+
+      it('should get the children from that property', () => {
+        const node = generateNodes(['e', ['e', 'e']])[0];
+        node.newChildrenProp = node.children;
+        node.treeNodeSpec.childrenProperty = 'newChildrenProp';
+        delete node.children;
+
+        const children = getChildren(node);
+        expect(children.length).to.equal(2);
+      });
+    });
+
+    describe('and the node model does not have a specified childrenProperty', () => {
+
+      it('should get the children from the children property', () => {
+        const node = generateNodes(['e', ['e', 'e']])[0];
+        const children = getChildren(node);
+        expect(children.length).to.equal(node.children.length);
+      });
+    });
+  });
+});
\ No newline at end of file
diff --git a/src/composables/children/treeViewNodeChildren.js b/src/composables/children/treeViewNodeChildren.js
index 2e853dc3..5c1dc6be 100644
--- a/src/composables/children/treeViewNodeChildren.js
+++ b/src/composables/children/treeViewNodeChildren.js
@@ -1,4 +1,5 @@
 import { computed } from 'vue';
+import { useChildren } from './children.js';
 import TreeEvent from '../../enums/event.js';
 
 /**
@@ -9,11 +10,15 @@ import TreeEvent from '../../enums/event.js';
  */
 export function useTreeViewNodeChildren(nodeModel, emit) {
 
+  const {
+    getChildren
+  } = useChildren();
+
   const areChildrenLoaded = computed(() => typeof nodeModel.value.treeNodeSpec.loadChildrenAsync !== 'function' || nodeModel.value.treeNodeSpec._.state.areChildrenLoaded);
 
   const areChildrenLoading = computed(() => nodeModel.value.treeNodeSpec._.state.areChildrenLoading);
 
-  const children = computed(() => nodeModel.value[nodeModel.value.treeNodeSpec.childrenProperty ?? 'children']);
+  const children = computed(() => getChildren(nodeModel));
 
   const hasChildren = computed(() => children.value && children.value.length > 0);
 
diff --git a/src/composables/dragDrop/TreeViewNodeDragAndDrop.spec.js b/src/composables/dragDrop/TreeViewNodeDragAndDrop.spec.js
index 92f9e5ed..f673775e 100644
--- a/src/composables/dragDrop/TreeViewNodeDragAndDrop.spec.js
+++ b/src/composables/dragDrop/TreeViewNodeDragAndDrop.spec.js
@@ -5,7 +5,7 @@ import { generateNodes } from '../../../tests/data/node-generator.js';
 import { dropEffect as DropEffect, effectAllowed as EffectAllowed } from '../../enums/dragDrop';
 import MimeType from '../../enums/mimeType';
 
-const serializedNodeData = '{"id":"n0","label":"Node 0","children":[],"treeNodeSpec":{"_":{"dragging":false,"state":{"areChildrenLoaded":true,"areChildrenLoading":false}},"childrenProperty":"children","idProperty":"id","labelProperty":"label","loadChildrenAsync":null,"expandable":false,"selectable":true,"deletable":false,"focusable":false,"input":{"type":"checkbox","name":"n0-cbx"},"state":{"expanded":false,"selected":false,"input":{"disabled":false,"value":false}},"addChildCallback":null,"draggable":false,"allowDrop":false,"dataTransferEffectAllowed":"copyMove","title":null,"expanderTitle":null,"addChildTitle":null,"deleteTitle":null,"customizations":{}}}';
+const serializedNodeData = '{"id":"n0","label":"Node 0","children":[],"treeNodeSpec":{"_":{"dragging":false,"state":{"areChildrenLoaded":true,"areChildrenLoading":false,"matchesFilter":true,"subnodeMatchesFilter":false}},"childrenProperty":"children","idProperty":"id","labelProperty":"label","loadChildrenAsync":null,"expandable":false,"selectable":true,"deletable":false,"focusable":false,"input":{"type":"checkbox","name":"n0-cbx"},"state":{"expanded":false,"selected":false,"input":{"disabled":false,"value":false}},"addChildCallback":null,"draggable":false,"allowDrop":false,"dataTransferEffectAllowed":"copyMove","title":null,"expanderTitle":null,"addChildTitle":null,"deleteTitle":null,"customizations":{}}}';
 
 const getDefaultPropsData = function () {
   return {
@@ -43,7 +43,12 @@ function createWrapper(customPropsData, customAttrs) {
     sync: false,
     props: customPropsData || getDefaultPropsData(),
     attrs: customAttrs,
-    attachTo: elem
+    attachTo: elem,
+    global: {
+      provide: {
+        filterMethod: null
+      }
+    }
   });
 };
 
diff --git a/src/composables/dragDrop/treeViewDragAndDrop.js b/src/composables/dragDrop/treeViewDragAndDrop.js
index bf93122b..107ddca8 100644
--- a/src/composables/dragDrop/treeViewDragAndDrop.js
+++ b/src/composables/dragDrop/treeViewDragAndDrop.js
@@ -7,6 +7,14 @@ const { resolveNodeIdConflicts } = useIdGeneration();
 const { cheapCopyObject } = useObjectMethods();
 const { unfocus } = useFocus();
 
+/**
+ * Composable dealing with drag-and-drop handling at the top level of the tree view.
+ * @param {Ref<TreeViewNode[]>} treeModel A Ref to the top level model of the tree
+ * @param {Ref<string>} uniqueId A Ref to the unique ID for the tree.
+ * @param {Function} findById A function to find a node by ID
+ * @param {Function} removeById A function to remove a node by ID
+ * @returns {Object} Methods to deal with tree view level drag-and-drop
+ */
 export function useTreeViewDragAndDrop(treeModel, uniqueId, findById, removeById) {
   /**
    * Removes the given node from this node's children
diff --git a/src/composables/dragDrop/treeViewNodeDragAndDrop.js b/src/composables/dragDrop/treeViewNodeDragAndDrop.js
index e70ae7fe..e625544f 100644
--- a/src/composables/dragDrop/treeViewNodeDragAndDrop.js
+++ b/src/composables/dragDrop/treeViewNodeDragAndDrop.js
@@ -9,6 +9,14 @@ import { useFocus } from '../focus/focus.js';
 
 const { closest } = useDomMethods();
 
+/**
+ * Composable dealing with drag-and-drop handling at the tree view node.
+ * @param {Ref<TreeViewNode>} model A Ref to the model of the node
+ * @param {Ref<TreeViewNode[]>} children A Ref to the children of the node
+ * @param {Ref<string>} treeId A Ref to the tree ID
+ * @param {Function} emit The TreeViewNode's emit function, used to emit selection events on the node's behalf
+ * @returns {Object} Methods to deal with tree view node level drag-and-drop
+ */
 export function useTreeViewNodeDragAndDrop(model, children, treeId, emit) {
 
   const { unfocus } = useFocus();
diff --git a/src/composables/expansion/expansion.spec.js b/src/composables/expansion/expansion.spec.js
index 7c0d2eea..eec8d740 100644
--- a/src/composables/expansion/expansion.spec.js
+++ b/src/composables/expansion/expansion.spec.js
@@ -1,4 +1,4 @@
-import { beforeEach, expect, describe, it, vi } from 'vitest';
+import { expect, describe, it } from 'vitest';
 import { ref } from 'vue';
 import { useExpansion } from './expansion.js';
 import { generateNodes } from '../../../tests/data/node-generator.js';
diff --git a/src/composables/expansion/treeViewNodeExpansion.js b/src/composables/expansion/treeViewNodeExpansion.js
index 4b3033c4..3cea4de7 100644
--- a/src/composables/expansion/treeViewNodeExpansion.js
+++ b/src/composables/expansion/treeViewNodeExpansion.js
@@ -1,6 +1,7 @@
 import { computed, watch } from 'vue';
 import { useExpansion } from './expansion.js';
 import { useTreeViewNodeChildren } from '../children/treeViewNodeChildren.js';
+import { useTreeViewNodeFilter } from '../filter/treeViewNodeFilter.js';
 import TreeEvent from '../../enums/event.js';
 
 /**
@@ -18,13 +19,16 @@ export function useTreeViewNodeExpansion(nodeModel, emit) {
 
   const {
     loadChildren,
-    mayHaveChildren,
   } = useTreeViewNodeChildren(nodeModel, emit);
 
+  const {
+    mayHaveFilteredChildren,
+  } = useTreeViewNodeFilter(nodeModel, emit);
+
   const ariaExpanded = computed(() => canExpand.value ? isNodeExpanded() : null);
 
   const canExpand = computed(() => {
-    return mayHaveChildren.value && isNodeExpandable();
+    return isNodeExpandable() && mayHaveFilteredChildren.value;
   });
 
   watch(() => nodeModel.value.treeNodeSpec.state.expanded, async function () {
diff --git a/src/composables/expansion/treeViewNodeExpansion.spec.js b/src/composables/expansion/treeViewNodeExpansion.spec.js
index 16736c81..f8bfbcf6 100644
--- a/src/composables/expansion/treeViewNodeExpansion.spec.js
+++ b/src/composables/expansion/treeViewNodeExpansion.spec.js
@@ -1,12 +1,29 @@
 import { beforeEach, expect, describe, it, vi } from 'vitest';
-import { flushPromises } from '@vue/test-utils';
-import { ref } from 'vue';
+import { flushPromises, mount } from '@vue/test-utils';
+import { defineComponent, ref } from 'vue';
 import { useTreeViewNodeExpansion } from './treeViewNodeExpansion.js';
 import { generateNodes } from '../../../tests/data/node-generator.js';
 import TreeEvent from '../../enums/event.js';
 
 let emit;
 
+function createTestComponent(node) {
+  const TestComponent = defineComponent({
+    template: "<div></div>",
+    setup() { return useTreeViewNodeExpansion(node, emit) }
+  });
+
+  const wrapper = mount(TestComponent, {
+    global: {
+      provide: {
+        'filterMethod': null
+      }
+    }
+  });
+
+  return wrapper;
+}
+
 describe('treeViewNodeExpansion.js', () => {
 
   beforeEach(() => {
@@ -19,8 +36,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return null', () => {
         const node = ref(generateNodes(['s'])[0]);
-        const { ariaExpanded } = useTreeViewNodeExpansion(node, emit);
-        expect(ariaExpanded.value).to.be.null;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.ariaExpanded).to.be.null;
       })
     });
 
@@ -30,8 +47,8 @@ describe('treeViewNodeExpansion.js', () => {
 
         it('should return false', () => {
           const node = ref(generateNodes(['es', ['s']])[0]);
-          const { ariaExpanded } = useTreeViewNodeExpansion(node, emit);
-          expect(ariaExpanded.value).to.be.false;
+          const wrapper = createTestComponent(node);
+          expect(wrapper.vm.ariaExpanded).to.be.false;
         });
       });
 
@@ -39,8 +56,8 @@ describe('treeViewNodeExpansion.js', () => {
 
         it('should return true', () => {
           const node = ref(generateNodes(['Es', ['s']])[0]);
-          const { ariaExpanded } = useTreeViewNodeExpansion(node, emit);
-          expect(ariaExpanded.value).to.be.true;
+          const wrapper = createTestComponent(node);
+          expect(wrapper.vm.ariaExpanded).to.be.true;
         });
       });
     });
@@ -52,8 +69,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return false', () => {
         const node = ref(generateNodes(['es'])[0]);
-        const { canExpand } = useTreeViewNodeExpansion(node, emit);
-        expect(canExpand.value).to.be.false;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.canExpand).to.be.false;
       });
     });
 
@@ -61,8 +78,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return false', () => {
         const node = ref(generateNodes(['s', ['s']])[0]);
-        const { canExpand } = useTreeViewNodeExpansion(node, emit);
-        expect(canExpand.value).to.be.false;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.canExpand).to.be.false;
       });
     });
 
@@ -70,8 +87,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return true', () => {
         const node = ref(generateNodes(['es', ['s']])[0]);
-        const { canExpand } = useTreeViewNodeExpansion(node, emit);
-        expect(canExpand.value).to.be.true;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.canExpand).to.be.true;
       });
     });
   });
@@ -80,7 +97,7 @@ describe('treeViewNodeExpansion.js', () => {
 
     it('should emit the expanded event', async () => {
       const node = ref(generateNodes(['es', ['s']])[0]);
-      const { canExpand } = useTreeViewNodeExpansion(node, emit);
+      createTestComponent(node);
       node.value.treeNodeSpec.state.expanded = true;
       await flushPromises();
       expect(emit).toHaveBeenCalledWith(TreeEvent.ExpandedChange, node.value);
@@ -93,8 +110,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return true', () => {
         const node = ref(generateNodes(['es'])[0]);
-        const { isNodeExpandable } = useTreeViewNodeExpansion(node, emit);
-        expect(isNodeExpandable()).to.be.true;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.isNodeExpandable()).to.be.true;
       });
     });
 
@@ -102,8 +119,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return false', () => {
         const node = ref(generateNodes(['s'])[0]);
-        const { isNodeExpandable } = useTreeViewNodeExpansion(node, emit);
-        expect(isNodeExpandable()).to.be.false;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.isNodeExpandable()).to.be.false;
       });
     });
   });
@@ -114,8 +131,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return true', () => {
         const node = ref(generateNodes(['Es'])[0]);
-        const { isNodeExpanded } = useTreeViewNodeExpansion(node, emit);
-        expect(isNodeExpanded(node)).to.be.true;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.isNodeExpanded()).to.be.true;
       });
     });
 
@@ -123,8 +140,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return false', () => {
         const node = ref(generateNodes(['es'])[0]);
-        const { isNodeExpanded } = useTreeViewNodeExpansion(node, emit);
-        expect(isNodeExpanded(node)).to.be.false;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.isNodeExpanded()).to.be.false;
       });
     });
   });
@@ -135,15 +152,15 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should set the node as not expanded', () => {
         const node = ref(generateNodes(['Es', ['s']])[0]);
-        const { collapseNode } = useTreeViewNodeExpansion(node, emit);
-        collapseNode();
+        const wrapper = createTestComponent(node);
+        wrapper.vm.collapseNode();
         expect(node.value.treeNodeSpec.state.expanded).to.be.false;
       });
 
       it('should return true', () => {
         const node = ref(generateNodes(['Es', ['s']])[0]);
-        const { collapseNode } = useTreeViewNodeExpansion(node, emit);
-        expect(collapseNode()).to.be.true;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.collapseNode()).to.be.true;
       });
     });
 
@@ -151,8 +168,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return false', () => {
         const node = ref(generateNodes(['es', ['s']])[0]);
-        const { collapseNode } = useTreeViewNodeExpansion(node, emit);
-        expect(collapseNode()).to.be.false;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.collapseNode()).to.be.false;
       });
     });
   });
@@ -163,8 +180,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should return false', () => {
         const node = ref(generateNodes(['Es', ['s']])[0]);
-        const { expandNode } = useTreeViewNodeExpansion(node, emit);
-        expect(expandNode()).to.be.false;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.expandNode()).to.be.false;
       });
     });
 
@@ -172,15 +189,15 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should set the node as expanded', () => {
         const node = ref(generateNodes(['es', ['s']])[0]);
-        const { expandNode } = useTreeViewNodeExpansion(node, emit);
-        expandNode();
+        const wrapper = createTestComponent(node);
+        wrapper.vm.expandNode();
         expect(node.value.treeNodeSpec.state.expanded).to.be.true;
       });
 
       it('should return true', () => {
         const node = ref(generateNodes(['es', ['s']])[0]);
-        const { expandNode } = useTreeViewNodeExpansion(node, emit);
-        expect(expandNode()).to.be.true;
+        const wrapper = createTestComponent(node);
+        expect(wrapper.vm.expandNode()).to.be.true;
       });
     });
   });
@@ -191,8 +208,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should set the node as not expanded', () => {
         const node = ref(generateNodes(['Es', ['s']])[0]);
-        const { toggleNodeExpanded } = useTreeViewNodeExpansion(node, emit);
-        toggleNodeExpanded();
+        const wrapper = createTestComponent(node);
+        wrapper.vm.toggleNodeExpanded();
         expect(node.value.treeNodeSpec.state.expanded).to.be.false;
       });
     });
@@ -201,8 +218,8 @@ describe('treeViewNodeExpansion.js', () => {
 
       it('should set the node as expanded', () => {
         const node = ref(generateNodes(['es', ['s']])[0]);
-        const { toggleNodeExpanded } = useTreeViewNodeExpansion(node, emit);
-        toggleNodeExpanded();
+        const wrapper = createTestComponent(node);
+        wrapper.vm.toggleNodeExpanded();
         expect(node.value.treeNodeSpec.state.expanded).to.be.true;
       });
     });
diff --git a/src/composables/filter/filter.js b/src/composables/filter/filter.js
new file mode 100644
index 00000000..c4a3cf83
--- /dev/null
+++ b/src/composables/filter/filter.js
@@ -0,0 +1,26 @@
+import { unref } from 'vue';
+import { useChildren } from '../children/children.js';
+
+/**
+ * Composable dealing with filter handling on an arbitrary node.
+ * @returns {Object} Methods to deal with filtering of arbitrary nodes
+ */
+export function useFilter() {
+
+  const {
+    getChildren
+  } = useChildren();
+
+  function getFilteredChildren(targetNodeModel) {
+    return getFilteredNodes(getChildren(targetNodeModel));
+  }
+
+  function getFilteredNodes(targetNodeModels) {
+    return unref(targetNodeModels).filter(c => c.treeNodeSpec?._?.state?.matchesFilter || c.treeNodeSpec?._?.state?.subnodeMatchesFilter);
+  }
+
+  return {
+    getFilteredChildren,
+    getFilteredNodes,
+  };
+}
\ No newline at end of file
diff --git a/src/composables/filter/filter.spec.js b/src/composables/filter/filter.spec.js
new file mode 100644
index 00000000..2d4c70ba
--- /dev/null
+++ b/src/composables/filter/filter.spec.js
@@ -0,0 +1,61 @@
+import { beforeEach, expect, describe, it } from 'vitest';
+import { useFilter } from './filter.js';
+import { generateNodes } from '../../../tests/data/node-generator.js';
+
+describe('filter.js', () => {
+
+  let nodes;
+
+  beforeEach(() => {
+    nodes = generateNodes(['e', ['e', ['e'], 'es', ['e'], 'e', ['es']]]);
+    //mimic filter matching the sectable nodes
+    nodes[0].treeNodeSpec._.state.matchesFilter = false;
+    nodes[0].treeNodeSpec._.state.subnodeMatchesFilter = true;
+    nodes[0].children[0].treeNodeSpec._.state.matchesFilter = false;
+    nodes[0].children[0].treeNodeSpec._.state.subnodeMatchesFilter = false;
+    nodes[0].children[0].children[0].treeNodeSpec._.state.matchesFilter = false;
+    nodes[0].children[0].children[0].treeNodeSpec._.state.subnodeMatchesFilter = false;
+    nodes[0].children[1].treeNodeSpec._.state.matchesFilter = true;
+    nodes[0].children[1].treeNodeSpec._.state.subnodeMatchesFilter = false;
+    nodes[0].children[1].children[0].treeNodeSpec._.state.matchesFilter = false;
+    nodes[0].children[1].children[0].treeNodeSpec._.state.subnodeMatchesFilter = false;
+    nodes[0].children[2].treeNodeSpec._.state.matchesFilter = false;
+    nodes[0].children[2].treeNodeSpec._.state.subnodeMatchesFilter = true;
+    nodes[0].children[2].children[0].treeNodeSpec._.state.matchesFilter = true;
+    nodes[0].children[2].children[0].treeNodeSpec._.state.subnodeMatchesFilter = false;
+  });
+
+  describe('when getting filtered children', () => {
+
+    it('should get the children of the given node that match the filter', () => {
+      const { getFilteredChildren } = useFilter();
+      const filteredNodes = getFilteredChildren(nodes[0]);
+      expect(filteredNodes.length).to.equal(2);
+      expect(filteredNodes[0].id).to.equal('n0n2');
+    });
+
+    it('should get the children of the given node that have children matching the filter', () => {
+      const { getFilteredChildren } = useFilter();
+      const filteredNodes = getFilteredChildren(nodes[0]);
+      expect(filteredNodes.length).to.equal(2);
+      expect(filteredNodes[1].id).to.equal('n0n4');
+    });
+  });
+
+  describe('when getting filtered nodes', () => {
+
+    it('should get the nodes that match the filter', () => {
+      const { getFilteredNodes } = useFilter();
+      const filteredNodes = getFilteredNodes(nodes[0].children);
+      expect(filteredNodes.length).to.equal(2);
+      expect(filteredNodes[0].id).to.equal('n0n2');
+    });
+
+    it('should get the nodes that have children matching the filter', () => {
+      const { getFilteredNodes } = useFilter();
+      const filteredNodes = getFilteredNodes(nodes[0].children);
+      expect(filteredNodes.length).to.equal(2);
+      expect(filteredNodes[1].id).to.equal('n0n4');
+    });
+  });
+});
\ No newline at end of file
diff --git a/src/composables/filter/treeViewFilter.js b/src/composables/filter/treeViewFilter.js
new file mode 100644
index 00000000..bf5d537f
--- /dev/null
+++ b/src/composables/filter/treeViewFilter.js
@@ -0,0 +1,34 @@
+import { watch } from 'vue';
+import { useFilter } from './filter.js';
+import { useFocus } from '../focus/focus.js';
+
+/**
+ * Composable dealing with filter handling at the top level of the tree view.
+ * @param {Ref<TreeViewNode[]>} treeModel A Ref to the top level model of the tree
+ * @returns {Object} Methods to deal with tree view level filtering
+ */
+export function useTreeViewFilter(treeModel) {
+
+  const { getFilteredNodes } = useFilter();
+
+  const { focusFirst } = useFocus();
+
+  let needsRefocusing = getFilteredNodes(treeModel).length === 0;
+
+  // When the filter changes, see if all nodes were removed.
+  // If they were, manually restore focus the next time the filtered list changes.
+  watch(() => getFilteredNodes(treeModel), () => {
+    if (getFilteredNodes(treeModel).length > 0) {
+      if (needsRefocusing) {
+        focusFirst(treeModel, true);
+      }
+
+      needsRefocusing = false;
+    }
+    else {
+      needsRefocusing = true;
+    }
+  })
+
+  return {};
+}
\ No newline at end of file
diff --git a/src/composables/filter/treeViewFilter.spec.js b/src/composables/filter/treeViewFilter.spec.js
new file mode 100644
index 00000000..d385d871
--- /dev/null
+++ b/src/composables/filter/treeViewFilter.spec.js
@@ -0,0 +1,59 @@
+import { beforeEach, expect, describe, it } from 'vitest';
+import { flushPromises, mount } from '@vue/test-utils';
+import { defineComponent, ref } from 'vue';
+import { useTreeViewFilter } from './treeViewFilter.js';
+import { generateNodes } from '../../../tests/data/node-generator.js';
+
+function createTestComponent(nodes) {
+  const TestComponent = defineComponent({
+    template: "<div></div>",
+    setup() { return useTreeViewFilter(nodes) }
+  });
+
+  const wrapper = mount(TestComponent, {
+    global: {
+      provide: {
+        'filterMethod': null // unused here; the composable just reacts to state this sets elsewhere
+      }
+    }
+  });
+
+  return wrapper;
+}
+
+describe('treeViewFilter.js', () => {
+
+  let nodes;
+  let wrapper;
+
+  beforeEach(() => {
+    nodes = ref(generateNodes(['e', 'ef']));
+    //mimic filter matching the sectable nodes
+    nodes.value[0].treeNodeSpec._.state.matchesFilter = true;
+    nodes.value[0].treeNodeSpec._.state.subnodeMatchesFilter = false;
+    nodes.value[1].treeNodeSpec._.state.matchesFilter = true;
+    nodes.value[1].treeNodeSpec._.state.subnodeMatchesFilter = false;
+    wrapper = createTestComponent(nodes);
+  });
+
+  describe('when all nodes are filtered', () => {
+
+    beforeEach(async () => {
+      nodes.value[0].treeNodeSpec._.state.matchesFilter = false;
+      nodes.value[1].treeNodeSpec._.state.matchesFilter = false;
+      await flushPromises();
+    });
+
+    describe('and then nodes are unfiltered', () => {
+
+      beforeEach(async () => {
+        nodes.value[0].treeNodeSpec._.state.matchesFilter = true;
+        await flushPromises();
+      });
+
+      it('should set the first node as focusable', () => {
+        expect(nodes.value[0].treeNodeSpec.focusable).to.be.true;
+      });
+    });
+  });
+});
\ No newline at end of file
diff --git a/src/composables/filter/treeViewNodeFilter.js b/src/composables/filter/treeViewNodeFilter.js
new file mode 100644
index 00000000..e3353ac9
--- /dev/null
+++ b/src/composables/filter/treeViewNodeFilter.js
@@ -0,0 +1,56 @@
+import { computed, inject, unref, watchEffect } from "vue";
+import { useTreeViewNodeChildren } from '../children/treeViewNodeChildren.js';
+import { useFilter } from "./filter.js";
+import { useFocus } from "../focus/focus.js";
+import TreeEvent from '../../enums/event.js';
+
+/**
+ * Composable dealing with filtering at the tree view node.
+ * @param {Ref<TreeViewNode>} nodeModel A Ref to the model of the node
+ * @returns {Object} Methods to deal with filtering for a tree view node
+ */
+export function useTreeViewNodeFilter(nodeModel, emit) {
+
+  const filterMethod = inject("filterMethod");
+
+  const {
+    isFocused,
+    unfocus
+  } = useFocus();
+
+  const {
+    areChildrenLoaded,
+  } = useTreeViewNodeChildren(nodeModel);
+
+  const {
+    getFilteredChildren
+  } = useFilter();
+
+  const filteredChildren = computed(() => getFilteredChildren(nodeModel));
+
+  const isFilteringEnabled = computed(() => typeof unref(filterMethod) === 'function');
+
+  const filterIncludesNode = computed(() => nodeModel.value.treeNodeSpec._.state.matchesFilter || nodeModel.value.treeNodeSpec._.state.subnodeMatchesFilter || false);
+
+  const hasFilteredChildren = computed(() => filteredChildren.value && filteredChildren.value.length > 0);
+
+  const mayHaveFilteredChildren = computed(() => hasFilteredChildren.value || !areChildrenLoaded.value);
+
+  watchEffect(() => {
+    const tns = nodeModel.value.treeNodeSpec;
+    tns._.state.matchesFilter = !isFilteringEnabled.value || unref(filterMethod)(nodeModel.value);
+    tns._.state.subnodeMatchesFilter = filteredChildren.value.length > 0;
+
+    if (!filterIncludesNode.value && isFocused(nodeModel)) {
+      unfocus(nodeModel);
+      emit(TreeEvent.RequestFirstFocus, true);
+    }
+  });
+
+  return {
+    filteredChildren,
+    filterIncludesNode,
+    isFilteringEnabled,
+    mayHaveFilteredChildren,
+  };
+}
\ No newline at end of file
diff --git a/src/composables/filter/treeViewNodeFilter.spec.js b/src/composables/filter/treeViewNodeFilter.spec.js
new file mode 100644
index 00000000..3297ea74
--- /dev/null
+++ b/src/composables/filter/treeViewNodeFilter.spec.js
@@ -0,0 +1,216 @@
+import { beforeEach, expect, describe, it, vi } from 'vitest';
+import { flushPromises, mount } from '@vue/test-utils';
+import { defineComponent, ref } from 'vue';
+import { useTreeViewNodeFilter } from './treeViewNodeFilter.js';
+import { generateNodes } from '../../../tests/data/node-generator.js';
+import TreeEvent from '../../enums/event.js';
+
+let emit;
+
+function createTestComponent(node, filterMethod) {
+  const TestComponent = defineComponent({
+    template: "<div></div>",
+    setup() { return useTreeViewNodeFilter(node, emit) }
+  });
+
+  const wrapper = mount(TestComponent, {
+    global: {
+      provide: {
+        'filterMethod': filterMethod
+      }
+    }
+  });
+
+  return wrapper;
+}
+
+function setChildFilteredState(child, forNode, forSubnodes) {
+  // The composable only filters for the current node; in a real tree, each node would have its own watch.
+  // Simulate the subnodes states here.
+  child.treeNodeSpec._.state.matchesFilter = forNode;
+  child.treeNodeSpec._.state.subnodeMatchesFilter = forSubnodes;
+}
+
+describe('treeViewNodeFilter.js', () => {
+
+  let node;
+  let wrapper;
+
+  beforeEach(() => {
+    emit = vi.fn();
+  });
+
+  describe('when the filterMethod is set', () => {
+
+    describe('always', () => {
+
+      beforeEach(async () => {
+        node = ref(generateNodes(['fe', ['e', 's']])[0]);
+        wrapper = createTestComponent(node, (n) => n.treeNodeSpec.expandable);
+        setChildFilteredState(node.value.children[0], true, false);
+        setChildFilteredState(node.value.children[1], false, false);
+        await flushPromises();
+      });
+
+      it('should set isFilteringEnabled to true', () => {
+        expect(wrapper.vm.isFilteringEnabled).to.be.true;
+      });
+
+      it('should only include subnodes included in the filter in filteredChildren', () => {
+        expect(wrapper.vm.filteredChildren.length).to.equal(1);
+        expect(wrapper.vm.filteredChildren[0].id).to.equal('n0n0');
+      });
+    });
+
+    describe('and the node matches the filter', () => {
+
+      beforeEach(async () => {
+        node = ref(generateNodes(['fe', ['e', 's']])[0]);
+        wrapper = createTestComponent(node, (n) => n.treeNodeSpec.expandable);
+        await flushPromises();
+      });
+
+      it('should set filterIncludesNode to true', () => {
+        expect(wrapper.vm.filterIncludesNode).to.be.true;
+      });
+    });
+
+    describe('and the node does not match the filter', () => {
+
+      beforeEach(async () => {
+        node = ref(generateNodes(['fe', ['e', 's']])[0]);
+        wrapper = createTestComponent(node, (n) => n.treeNodeSpec.selectable);
+        await flushPromises();
+      });
+
+      describe('and the node has filtered children', () => {
+
+        beforeEach(async () => {
+          setChildFilteredState(node.value.children[0], true, false);
+          await flushPromises();
+        });
+
+        it('should set filterIncludesNode to true', () => {
+          expect(wrapper.vm.filterIncludesNode).to.be.true;
+        });
+      });
+
+      describe('and the node has no filtered children', () => {
+
+        beforeEach(async () => {
+          setChildFilteredState(node.value.children[0], false, false);
+          setChildFilteredState(node.value.children[1], false, false);
+          await flushPromises();
+        });
+
+        it('should set filterIncludesNode to false', () => {
+          expect(wrapper.vm.filterIncludesNode).to.be.false;
+        });
+      });
+    });
+
+    describe('and children are loaded', () => {
+
+      describe('and the node has filtered children', () => {
+
+        beforeEach(async () => {
+          node = ref(generateNodes(['fe', ['e']])[0]);
+          wrapper = createTestComponent(node, (n) => n.treeNodeSpec.expandable);
+          setChildFilteredState(node.value.children[0], true, false);
+          await flushPromises();
+        });
+
+        it('should set mayHaveFilteredChildren to true', () => {
+          expect(wrapper.vm.mayHaveFilteredChildren).to.be.true;
+        });
+      });
+
+      describe('and the node has no filtered children', () => {
+
+        beforeEach(async () => {
+          node = ref(generateNodes(['fe', ['e']])[0]);
+          wrapper = createTestComponent(node, (n) => n.treeNodeSpec.expandable);
+          setChildFilteredState(node.value.children[0], false, false);
+          await flushPromises();
+        });
+
+        it('should set mayHaveFilteredChildren to false', () => {
+          expect(wrapper.vm.mayHaveFilteredChildren).to.be.false;
+        });
+      });
+    });
+
+    describe('and children are not loaded', () => {
+
+      beforeEach(async () => {
+        node = ref(generateNodes(['fe'])[0]);
+        node.value.treeNodeSpec.loadChildrenAsync = () => { };
+        node.value.treeNodeSpec._.state.areChildrenLoaded = false;
+        wrapper = createTestComponent(node, (n) => n.treeNodeSpec.expandable);
+        await flushPromises();
+      });
+
+      it('should set mayHaveFilteredChildren to true', () => {
+        expect(wrapper.vm.mayHaveFilteredChildren).to.be.true;
+      });
+    });
+
+    describe('and the node changes to not match the filter', () => {
+
+      beforeEach(async () => {
+        node = ref(generateNodes(['fe'])[0]);
+        wrapper = createTestComponent(node, (n) => n.treeNodeSpec.expandable);
+        await flushPromises();
+        node.value.treeNodeSpec.expandable = false;
+        await flushPromises();
+      });
+
+      it('should set the node as not matching the filter', () => {
+        expect(node.value.treeNodeSpec._.state.matchesFilter).to.be.false;
+      });
+
+      describe('and it is the focused node', () => {
+
+        it('should emit the requestFirstFocus event', () => {
+          expect(emit).toHaveBeenCalledWith(TreeEvent.RequestFirstFocus, true);
+        });
+      });
+    });
+
+    describe('and the node changes to match the filter', () => {
+
+      beforeEach(async () => {
+        node = ref(generateNodes(['f'])[0]);
+        wrapper = createTestComponent(node, (n) => n.treeNodeSpec.expandable);
+        await flushPromises();
+        node.value.treeNodeSpec.expandable = true;
+        await flushPromises();
+      });
+
+      it('should set the node as matching the filter', () => {
+        expect(node.value.treeNodeSpec._.state.matchesFilter).to.be.true;
+      });
+    });
+  });
+
+  describe('when the filterMethod is not set', () => {
+
+    beforeEach(async () => {
+      node = ref(generateNodes(['fe', ['e', 's']])[0]);
+      wrapper = createTestComponent(node, null);
+
+      // The composable only filters for the current node; in a real tree, each node would have it's own watch.
+      // Simulate the subnodes states here.
+      node.value.children[0].treeNodeSpec._.state.matchesFilter = true;
+      node.value.children[0].treeNodeSpec._.state.subnodeMatchesFilter = false;
+      node.value.children[1].treeNodeSpec._.state.matchesFilter = false;
+      node.value.children[1].treeNodeSpec._.state.subnodeMatchesFilter = false;
+
+      await flushPromises();
+    });
+
+    it('should set isFilteringEnabled to false', () => {
+      expect(wrapper.vm.isFilteringEnabled).to.be.false;
+    });
+  });
+});
\ No newline at end of file
diff --git a/src/composables/focus/focus.js b/src/composables/focus/focus.js
index d12270a2..e6f6113f 100644
--- a/src/composables/focus/focus.js
+++ b/src/composables/focus/focus.js
@@ -1,5 +1,6 @@
 import { unref } from 'vue';
 import { useExpansion } from '../expansion/expansion.js';
+import { useFilter } from '../filter/filter.js';
 
 /**
  * Composable dealing with focus handling on an arbitrary node.
@@ -9,11 +10,18 @@ export function useFocus() {
 
   const { isExpanded } = useExpansion();
 
+  const {
+    getFilteredChildren,
+    getFilteredNodes
+  } = useFilter();
+
   /**
    * Marks the given node as the focusable node in the tree
    * @param {TreeViewNode} targetNodeModel The model to mark as focusable
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    */
-  function focus(targetNodeModel) {
+  function focus(targetNodeModel, keepCurrentDomFocus = false) {
+    unref(targetNodeModel).treeNodeSpec._.keepCurrentDomFocus = keepCurrentDomFocus;
     unref(targetNodeModel).treeNodeSpec.focusable = true;
   }
 
@@ -36,26 +44,32 @@ export function useFocus() {
   /**
    * Sets the first node in the node collection as focusable.
    * @param {TreeViewNode[]} targetCollection The collection of nodes
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    */
-  function focusFirst(targetCollection) {
-    if (targetCollection.length > 0) {
-      focus(targetCollection[0]);
+  function focusFirst(targetCollection, keepCurrentDomFocus = false) {
+    const filteredCollection = getFilteredNodes(targetCollection);
+
+    if (filteredCollection.length > 0) {
+      focus(filteredCollection[0], keepCurrentDomFocus);
     }
   }
 
   /**
    * Sets the last expanded node in the given part of the hierarchy as focusable.
    * @param {TreeViewNode[]} targetCollection The collection of nodes
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    */
-  function focusLast(targetCollection) {
-    let lastModel = targetCollection[targetCollection.length - 1];
-    let lastModelChildren = lastModel[lastModel.treeNodeSpec.childrenProperty];
+  function focusLast(targetCollection, keepCurrentDomFocus = false) {
+    const filteredCollection = getFilteredNodes(targetCollection);
+
+    let lastModel = filteredCollection[filteredCollection.length - 1];
+    let lastModelChildren = getFilteredChildren(lastModel);
     while (lastModelChildren.length > 0 && isExpanded(lastModel)) {
       lastModel = lastModelChildren[lastModelChildren.length - 1];
-      lastModelChildren = lastModel[lastModel.treeNodeSpec.childrenProperty];
+      lastModelChildren = getFilteredChildren(lastModel);
     }
 
-    focus(lastModel);
+    focus(lastModel, keepCurrentDomFocus);
   }
 
   /**
@@ -65,20 +79,23 @@ export function useFocus() {
    * @param {Boolean} ignoreChild True to not consider child nodes. This would be true if a user
    * requests to focus the next node while on the last child of this node; the next sibling of
    * this node should gain focus in that case, or the parent node if there is no next sibling.
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    * @return {Boolean} true if a node was focused, false otherwise
    */
-  function focusNext(targetCollection, childNode, ignoreChild) {
+  function focusNext(targetCollection, childNode, ignoreChild, keepCurrentDomFocus = false) {
+    const filteredCollection = getFilteredNodes(targetCollection);
+
     // If the node is expanded, focus first child unless we're ignoring it (this was punted from a grandchild)
     // If the node has a next sibling, focus that
     // Otherwise, return false to let the caller know. A Node will punt to its parent if it has one.
-    let childIndex = targetCollection.indexOf(childNode);
-    let childNodeChildren = childNode[childNode.treeNodeSpec.childrenProperty];
+    let childIndex = filteredCollection.findIndex(n => n[n.treeNodeSpec.idProperty] === childNode[childNode.treeNodeSpec.idProperty]);
+    let childNodeChildren = getFilteredChildren(childNode);
 
     if (!ignoreChild && childNodeChildren.length > 0 && isExpanded(childNode)) {
-      focus(childNodeChildren[0]);
+      focus(childNodeChildren[0], keepCurrentDomFocus);
     }
-    else if (childIndex < targetCollection.length - 1) {
-      focus(targetCollection[childIndex + 1]);
+    else if (childIndex < filteredCollection.length - 1) {
+      focus(filteredCollection[childIndex + 1], keepCurrentDomFocus);
     }
     else {
       return false;
@@ -91,21 +108,25 @@ export function useFocus() {
    * Focuses the previous node in the tree
    * @param {TreeViewNode[]} targetCollection The collection of nodes
    * @param {TreeViewNode} childNode The node from which focusable should be moved
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    * @return {Boolean} true if a node was focused, false otherwise
    */
-  function focusPrevious(targetCollection, childNode) {
+  function focusPrevious(targetCollection, childNode, keepCurrentDomFocus = false) {
+    const filteredCollection = getFilteredNodes(targetCollection);
+
     // If focusing previous of the first child, defer to the caller to focus the parent.
     // If focusing previous of any other node, focus the last expanded node within the previous sibling.
-    let childIndex = targetCollection.indexOf(childNode);
+    let childIndex = filteredCollection.findIndex(n => n[n.treeNodeSpec.idProperty] === childNode[childNode.treeNodeSpec.idProperty]);
+
     if (childIndex !== 0) {
-      let lastModel = targetCollection[childIndex - 1];
-      let lastModelChildren = lastModel[lastModel.treeNodeSpec.childrenProperty];
+      let lastModel = filteredCollection[childIndex - 1];
+      let lastModelChildren = getFilteredChildren(lastModel);
       while (lastModelChildren.length > 0 && isExpanded(lastModel)) {
         lastModel = lastModelChildren[lastModelChildren.length - 1];
-        lastModelChildren = lastModel[lastModel.treeNodeSpec.childrenProperty];
+        lastModelChildren = getFilteredChildren(lastModel);
       }
 
-      focus(lastModel);
+      focus(lastModel, keepCurrentDomFocus);
       return true;
     }
 
diff --git a/src/composables/focus/treeViewNodeFocus.js b/src/composables/focus/treeViewNodeFocus.js
index 286fb101..c02976e8 100644
--- a/src/composables/focus/treeViewNodeFocus.js
+++ b/src/composables/focus/treeViewNodeFocus.js
@@ -1,5 +1,6 @@
 import { computed, unref, watch } from 'vue'
 import { useFocus } from './focus.js';
+import { useChildren } from '../children/children.js';
 import TreeEvent from '../../enums/event.js';
 
 /**
@@ -14,21 +15,30 @@ export function useTreeViewNodeFocus(nodeModel, nodeElement, emit, isMounted) {
 
   const { focus, focusFirst, focusLast, focusNext, focusPrevious, isFocused, unfocus } = useFocus();
 
-  const nodeModelChildren = computed(() => nodeModel.value[nodeModel.value.treeNodeSpec.childrenProperty]);
+  const { getChildren } = useChildren();
+
+  const nodeModelChildren = computed(() => getChildren(nodeModel));
 
   watch(() => nodeModel.value.treeNodeSpec.focusable, function (newValue) {
     if (newValue === true) {
       // If focusable is set to true and the tree is mounted in the DOM,
-      // also focus the node's element.
-      if (isMounted.value) {
+      // also focus the node's element unless explicitly told not to do so.
+      if (isMounted.value && !nodeModel.value.treeNodeSpec._.keepCurrentDomFocus) {
         nodeElement.value.focus();
       }
+
+      delete nodeModel.value.treeNodeSpec._.keepCurrentDomFocus;
+
       emit(TreeEvent.FocusableChange, nodeModel.value);
     }
   });
 
-  function focusNode() {
-    focus(nodeModel);
+  /**
+   * Marks the node as the focusable node in the tree
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
+   */
+  function focusNode(keepCurrentDomFocus = false) {
+    focus(nodeModel, keepCurrentDomFocus);
   }
 
   function unfocusNode() {
@@ -41,16 +51,18 @@ export function useTreeViewNodeFocus(nodeModel, nodeElement, emit, isMounted) {
 
   /**
    * Sets the first node in the node's children as focusable.
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    */
-  function focusFirstChild() {
-    focusFirst(nodeModelChildren.value);
+  function focusFirstChild(keepCurrentDomFocus = false) {
+    focusFirst(nodeModelChildren.value, keepCurrentDomFocus);
   }
 
   /**
    * Sets the last expanded node in this part of the hierarchy as focusable.
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    */
-  function focusLastChild() {
-    focusLast(nodeModelChildren.value);
+  function focusLastChild(keepCurrentDomFocus = false) {
+    focusLast(nodeModelChildren.value, keepCurrentDomFocus);
   }
 
   /**
@@ -59,11 +71,12 @@ export function useTreeViewNodeFocus(nodeModel, nodeElement, emit, isMounted) {
    * @param {Boolean} ignoreChild True to not consider child nodes. This would be true if a user
    * requests to focus the next node while on the last child of this node; the next sibling of
    * this node should gain focus in that case, or the parent node if there is no next sibling.
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    */
-  function focusNextNode(childNode, ignoreChild) {
+  function focusNextNode(childNode, ignoreChild, keepCurrentDomFocus = false) {
     // Call focusNext and see if it succeeds in focusing.
     // If not, punt this up to this node's parent.
-    if (!focusNext(nodeModelChildren.value, childNode, ignoreChild)) {
+    if (!focusNext(nodeModelChildren.value, childNode, ignoreChild, keepCurrentDomFocus)) {
       emit(TreeEvent.RequestNextFocus, unref(nodeModel), true);
     }
   }
@@ -71,11 +84,12 @@ export function useTreeViewNodeFocus(nodeModel, nodeElement, emit, isMounted) {
   /**
    * Focuses the previous node in the tree
    * @param {TreeViewNode} childNode The node from which focusable should be moved
+   * @param {boolean} keepCurrentDomFocus If true, does not try to focus the node's element in the DOM
    */
-  function focusPreviousNode(childNode) {
+  function focusPreviousNode(childNode, keepCurrentDomFocus = false) {
     // If focusing previous of the first child, focusPrevious returns false. Focus this node.
-    if (!focusPrevious(nodeModelChildren.value, childNode)) {
-      focusNode();
+    if (!focusPrevious(nodeModelChildren.value, childNode, keepCurrentDomFocus)) {
+      focusNode(keepCurrentDomFocus);
     }
   }
 
diff --git a/src/composables/treeViewTraversal.js b/src/composables/treeViewTraversal.js
index 6eabbb83..b667f689 100644
--- a/src/composables/treeViewTraversal.js
+++ b/src/composables/treeViewTraversal.js
@@ -1,3 +1,5 @@
+import { useFilter } from "./filter/filter.js";
+
 /**
  * Composable dealing with methods for traversing tree nodes
  * @param {Ref<TreeViewNode>} treeModel A Ref to the model from which traversals should start
@@ -5,6 +7,11 @@
  */
 export function useTreeViewTraversal(treeModel) {
 
+  const {
+    getFilteredChildren,
+    getFilteredNodes
+  } = useFilter();
+
   /**
    * Traverses the tree breadth-first and performs a callback action against each node.
    * @param {Function} nodeActionCallback The action to call against each node, taking that node as a parameter
@@ -28,23 +35,22 @@ export function useTreeViewTraversal(treeModel) {
    */
   function traverse(nodeActionCallback, depthFirst) {
 
-    if (treeModel.value.length === 0) {
+    const filteredNodes = getFilteredNodes(treeModel);
+    if (filteredNodes.length === 0) {
       return;
     }
 
-    let nodeQueue = treeModel.value.slice();
+    let nodeQueue = filteredNodes.slice();
     let continueCallbacks = true;
 
     while (nodeQueue.length > 0 && continueCallbacks !== false) {
-      let current = nodeQueue.shift();
+      const current = nodeQueue.shift();
 
       // Push children to the front (depth-first) or the back (breadth-first)
-      let childrenPropName = current.treeNodeSpec.childrenProperty;
-      if (Array.isArray(current[childrenPropName])) {
-        nodeQueue = depthFirst
-          ? current[childrenPropName].concat(nodeQueue)
-          : nodeQueue.concat(current[childrenPropName]);
-      }
+      const children = getFilteredChildren(current);
+      nodeQueue = depthFirst
+        ? children.concat(nodeQueue)
+        : nodeQueue.concat(children);
 
       // Use a return value of false to halt calling the callback on further nodes.
       continueCallbacks = nodeActionCallback(current);
diff --git a/src/stories/Examples.docs.mdx b/src/stories/Examples.docs.mdx
index a6e2a644..d4f86aef 100644
--- a/src/stories/Examples.docs.mdx
+++ b/src/stories/Examples.docs.mdx
@@ -147,4 +147,14 @@ You can drag a node that has the `draggable` property in a node's `treeNodeSpec`
 
 <Canvas>
 <Story id="examples-treeview--drag-drop" />
+</Canvas>
+
+## Filtering
+
+You can provide a method by which data should be filtered. Any node for which the method returns `true` or for which a subnode returns `true` will be included in the visual tree.
+
+<a target="_blank" href="assets_data/Filtering.js">See the Model Data</a>
+
+<Canvas>
+<Story id="examples-treeview--filtering" />
 </Canvas>
\ No newline at end of file
diff --git a/src/stories/Home.stories.mdx b/src/stories/Home.stories.mdx
index be2ea4a9..769a02a6 100644
--- a/src/stories/Home.stories.mdx
+++ b/src/stories/Home.stories.mdx
@@ -27,6 +27,7 @@ Features include:
 - Asynchronous loading of nodes
 - Follows ARIA guidelines for treeview accessibility
 - Drag and drop (single nodes, works between trees)
+- Filtering
 
 For future plans, see the project's [Issues](https://github.com/grapoza/vue-tree/issues) page.
 
@@ -134,6 +135,7 @@ To see it in action, try out the [demos](/docs/examples-treeview--basic#examples
 | modelDefaults     | Object   | An object containing defaults for all nodes that do not specify the given properties               | `{}`                              |          |
 | selectionMode     | String   | How selection should operate (see [Selection Mode](#selection-mode))                               | `null` (cannot select nodes)      |          |
 | skinClass         | String   | A class name to apply to the tree that specifies a skin to use (see [Skins](#skins))               | `"grtv-default-skin"`             |          |
+| filterMethod      | Function | A boolean function against which nodes are evaluated to see if they should be included in the tree | `null` (no filtering)             |          |
 
 ## Selection Mode
 
@@ -488,4 +490,10 @@ The tree view uses a roaming tab index to maintain focusability in the tree. A n
 
 ### More about ARIA Tree Views
 
-[WAI-ARIA Authoring Best Practices, Tree View](https://www.w3.org/TR/wai-aria-practices-1.1/#TreeView)
\ No newline at end of file
+[WAI-ARIA Authoring Best Practices, Tree View](https://www.w3.org/TR/wai-aria-practices-1.1/#TreeView)
+
+## Filtering
+
+If a `filterMethod` property is provided to the treeView then each node will get evaulated against that method, any node for which the function returns `true` or for which a subnode returns `true` will show in the tree view and get included in things like keyboard navigation or focusing. The method takes one parameter, which is the node. For example, to only show nodes with a description including "steve" you could use the method:
+
+`(node) => node.label.toLowerCase().includes('steve')`
\ No newline at end of file
diff --git a/src/stories/TreeView.stories.js b/src/stories/TreeView.stories.js
index f1d4c1ef..07fed6c7 100644
--- a/src/stories/TreeView.stories.js
+++ b/src/stories/TreeView.stories.js
@@ -36,4 +36,5 @@ export { AddRemove } from './definitions/TreeView.AddRemove';
 export { Selection } from './definitions/TreeView.Selection';
 export { Async } from './definitions/TreeView.Async';
 export { DragDrop } from './definitions/TreeView.DragDrop';
+export { Filtering } from './definitions/TreeView.Filtering';
 export { ClassCustomization, SkinCustomization } from './definitions/TreeView.Customization';
\ No newline at end of file
diff --git a/src/stories/data/filteringTreeViewData.js b/src/stories/data/filteringTreeViewData.js
new file mode 100644
index 00000000..b90cb4eb
--- /dev/null
+++ b/src/stories/data/filteringTreeViewData.js
@@ -0,0 +1,69 @@
+export default [
+  {
+    id: 'basic-node1',
+    label: 'My First Node',
+    children: [],
+  },
+  {
+    id: 'basic-node2',
+    label: 'My Second Node',
+    treeNodeSpec: {
+      title: 'My node, and its fantastic title',
+      input: {
+        type: 'checkbox',
+        name: 'checkbox1'
+      },
+      state: {
+        expanded: true,
+      }
+    },
+    children: [
+      {
+        id: 'basic-subnode1',
+        label: 'This is a subnode',
+        children: [],
+        treeNodeSpec: {
+          input: {
+            type: 'radio',
+            name: 'radio1',
+            isInitialRadioGroupValue: true
+          }
+        }
+      },
+      {
+        id: 'basic-subnode2',
+        label: 'Another Subnode',
+        children: [],
+        treeNodeSpec: {
+          input: {
+            type: 'radio',
+            name: 'radio1'
+          }
+        }
+      },
+      {
+        id: 'basic-subnode3',
+        label: 'This is a disabled, checked subnode',
+        treeNodeSpec: {
+          input: {
+            type: 'checkbox',
+            name: 'checkbox2'
+          },
+          state: {
+            input: {
+              value: true,
+              disabled: true
+            }
+          }
+        },
+        children: [
+          {
+            id: 'basic-subsubnode1',
+            label: 'An even deeper node',
+            children: []
+          }
+        ]
+      }
+    ]
+  }
+];
\ No newline at end of file
diff --git a/src/stories/definitions/TreeView.Filtering.js b/src/stories/definitions/TreeView.Filtering.js
new file mode 100644
index 00000000..e611bab9
--- /dev/null
+++ b/src/stories/definitions/TreeView.Filtering.js
@@ -0,0 +1,69 @@
+import TreeView from '../../components/TreeView.vue';
+import treeViewData from '../data/filteringTreeViewData';
+
+const Template = (args) => ({
+  components: { TreeView },
+  setup() {
+    return { args };
+  },
+  template: `<span>
+<tree-view v-bind="args" :filter-method="filterMethod" ref="treeViewRef"></tree-view>
+<section style="margin: 10px 0">
+  <input v-model="filterText" type='text' id="filter" placeholder="Filter by label text" style="margin-right: 4px" /><button @click="applyFilter">Apply Filter</button>
+</section>
+<section class="checked-nodes">
+  <button type="button" style="margin-top: 1rem" @click="refreshCheckedTvList">What's been checked (checkboxes and radiobuttons)?</button>
+  <ul id="checkedList">
+    <li v-for="checkedNode in checkedTvNodes">{{ checkedNode.id }}</li>
+  </ul>
+</section>
+</span>`,
+  data() {
+    return {
+      checkedTvNodes: [],
+      filterText: "",
+      filterMethod: null
+    }
+  },
+  methods: {
+    applyFilter() {
+      if (this.filterText === "") {
+        this.filterMethod = null;
+      }
+      else {
+        const lowercaseFilter = this.filterText.toLowerCase();
+        this.filterMethod = (n) => n.label.toLowerCase().includes(lowercaseFilter);
+      }
+    },
+    refreshCheckedTvList() {
+      this.checkedTvNodes = [...this.$refs.treeViewRef.getCheckedCheckboxes(), ...this.$refs.treeViewRef.getCheckedRadioButtons()];
+    }
+  }
+});
+
+export const Filtering = Template.bind({});
+Filtering.args = {
+  initialModel: treeViewData,
+};
+
+const docsSourceCode = `
+<template>
+  <tree-view :initial-model="tvModel"></tree-view>
+</template>
+<script setup>
+import { ref } from "vue";
+import { TreeView } from "@grapoza/vue-tree";
+import treeViewData from "../data/basicTreeViewData";
+
+const tvModel = ref(treeViewData);
+</script>`;
+
+Filtering.parameters = {
+  docs: {
+    source: {
+      code: docsSourceCode,
+      language: "html",
+      type: "auto",
+    },
+  },
+};
\ No newline at end of file
diff --git a/tests/data/node-generator.js b/tests/data/node-generator.js
index 4b95dd6b..4f83fc23 100644
--- a/tests/data/node-generator.js
+++ b/tests/data/node-generator.js
@@ -22,7 +22,7 @@ import InputType from '../../src/enums/inputType';
  * @param {Array<String|Array>} nodeSpec The node specification array.
  * @param {String} baseId The base string used in the node IDs.
  * @param {Function} addChildCallback A method that returns a Promise that resolves to the node data to add as a subnode.
- * @param {Function} loadChildrenAsync A method tha treturns a Promise that resolves to child nodes to set as the children.
+ * @param {Function} loadChildrenAsync A method that returns a Promise that resolves to child nodes to set as the children.
  * @returns {TreeViewNode[]} The requested nodes
  */
 export function generateNodes(nodeSpec, baseId = "", addChildCallback = null, loadChildrenAsync = null) {
@@ -48,7 +48,8 @@ export function generateNodes(nodeSpec, baseId = "", addChildCallback = null, lo
                 treeNodeSpec: {
                     _: {
                         state: {
-                            areChildrenLoaded: loadChildrenAsync === null
+                            areChildrenLoaded: loadChildrenAsync === null,
+                            matchesFilter: true
                         }
                     },
                     childrenProperty: 'children',