Introduce new TreeView UI component

Key highlights:

- Written from scratch to cater specifically to privacy.sexy's
  needs and requirements.
- The visual look mimics the previous component with minimal changes,
  but its internal code is completely rewritten.
- Lays groundwork for future functionalities like the "expand all"
  button a flat view mode as discussed in #158.
- Facilitates the transition to Vue 3 by omitting the Vue 2.0 dependent
  `liquour-tree` as part of #230.

Improvements and features:

- Caching for quicker node queries.
- Gradual rendering of nodes that introduces a noticable boost in
  performance, particularly during search/filtering.
  - `TreeView` solely governs the check states of branch nodes.

Changes:

- Keyboard interactions now alter the background color to highlight the
  focused item. Previously, it was changing the color of the text.
- Better state management with clear separation of concerns:
  - `TreeView` exclusively manages indeterminate states.
  - `TreeView` solely governs the check states of branch nodes.
  - Introduce transaction pattern to update state in batches to minimize
    amount of events handled.
- Improve keyboard focus, style background instead of foreground. Use
  hover/touch color on keyboard focus.
- `SelectableTree` has been removed. Instead, `TreeView` is now directly
  integrated with `ScriptsTree`.
- `ScriptsTree` has been refactored to incorporate hooks for clearer
  code and separation of duties.
- Adopt Vue-idiomatic bindings instead of keeping a reference of the
  tree component.
- Simplify and change filter event management.
- Abandon global styles in favor of class-scoped styles.
- Use global mixins with descriptive names to clarify indended
  functionality.

src/presentation/components/Scripts/View/Tree/TreeView/Rendering/NodeRenderingStrategy.ts

@@ -0,0 +1,5 @@
+import { TreeNode } from '../Node/TreeNode';
+
+export interface NodeRenderingStrategy {
+  shouldRender(node: TreeNode): boolean;
+}

src/presentation/components/Scripts/View/Tree/TreeView/Rendering/UseGradualNodeRendering.ts

@@ -0,0 +1,117 @@
+import {
+  WatchSource, computed, shallowRef, triggerRef, watch,
+} from 'vue';
+import { ReadOnlyTreeNode } from '../Node/TreeNode';
+import { useNodeStateChangeAggregator } from '../UseNodeStateChangeAggregator';
+import { TreeRoot } from '../TreeRoot/TreeRoot';
+import { useCurrentTreeNodes } from '../UseCurrentTreeNodes';
+import { NodeRenderingStrategy } from './NodeRenderingStrategy';
+
+/**
+ * Renders tree nodes gradually to prevent UI freeze when loading large amounts of nodes.
+ */
+export function useGradualNodeRendering(
+  treeWatcher: WatchSource<TreeRoot>,
+): NodeRenderingStrategy {
+  const nodesToRender = new Set<ReadOnlyTreeNode>();
+  const nodesBeingRendered = shallowRef(new Set<ReadOnlyTreeNode>());
+  let isFirstRender = true;
+  let isRenderingInProgress = false;
+  const renderingDelayInMs = 50;
+  const initialBatchSize = 30;
+  const subsequentBatchSize = 5;
+
+  const { onNodeStateChange } = useNodeStateChangeAggregator(treeWatcher);
+  const { nodes } = useCurrentTreeNodes(treeWatcher);
+
+  const orderedNodes = computed<readonly ReadOnlyTreeNode[]>(() => nodes.value.flattenedNodes);
+
+  watch(() => orderedNodes.value, (newNodes) => {
+    newNodes.forEach((node) => updateNodeRenderQueue(node));
+  }, { immediate: true });
+
+  function updateNodeRenderQueue(node: ReadOnlyTreeNode) {
+    if (node.state.current.isVisible
+        && !nodesToRender.has(node)
+        && !nodesBeingRendered.value.has(node)) {
+      nodesToRender.add(node);
+      if (!isRenderingInProgress) {
+        scheduleRendering();
+      }
+    } else if (!node.state.current.isVisible) {
+      if (nodesToRender.has(node)) {
+        nodesToRender.delete(node);
+      }
+      if (nodesBeingRendered.value.has(node)) {
+        nodesBeingRendered.value.delete(node);
+        triggerRef(nodesBeingRendered);
+      }
+    }
+  }
+
+  onNodeStateChange((node, change) => {
+    if (change.newState.isVisible === change.oldState.isVisible) {
+      return;
+    }
+    updateNodeRenderQueue(node);
+  });
+
+  scheduleRendering();
+
+  function scheduleRendering() {
+    if (isFirstRender) {
+      renderNodeBatch();
+      isFirstRender = false;
+    } else {
+      const delayScheduler = new DelayScheduler(renderingDelayInMs);
+      delayScheduler.schedule(renderNodeBatch);
+    }
+  }
+
+  function renderNodeBatch() {
+    if (nodesToRender.size === 0) {
+      isRenderingInProgress = false;
+      return;
+    }
+    isRenderingInProgress = true;
+    const batchSize = isFirstRender ? initialBatchSize : subsequentBatchSize;
+    const sortedNodes = Array.from(nodesToRender).sort(
+      (a, b) => orderedNodes.value.indexOf(a) - orderedNodes.value.indexOf(b),
+    );
+    const currentBatch = sortedNodes.slice(0, batchSize);
+    currentBatch.forEach((node) => {
+      nodesToRender.delete(node);
+      nodesBeingRendered.value.add(node);
+    });
+    triggerRef(nodesBeingRendered);
+    if (nodesToRender.size > 0) {
+      scheduleRendering();
+    }
+  }
+
+  function shouldNodeBeRendered(node: ReadOnlyTreeNode) {
+    return nodesBeingRendered.value.has(node);
+  }
+
+  return {
+    shouldRender: shouldNodeBeRendered,
+  };
+}
+
+class DelayScheduler {
+  private timeoutId: ReturnType<typeof setTimeout> = null;
+
+  constructor(private delay: number) {}
+
+  schedule(callback: () => void) {
+    this.clear();
+    this.timeoutId = setTimeout(callback, this.delay);
+  }
+
+  clear() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+}