Change "grouping" to "view"

1. *Grouping* becomes *view*. Because *view* is more clear and extensible than *grouping*. It increases flexibility to extend by e.g. adding *flat* as a new view as discussed in #50, in this case "flat *view*" would make more sense than "flat *grouping*".
2. *None* becomes *tree*. Because *tree* is more descriptive than *none*.

Updates labels on top menu. As labels are updated, the file structure/names are refactored to follow the same concept. `TheScriptsList` is renamed to `TheScriptsView`. Also refactors `ViewChanger` so view types are presented in same way.

src/presentation/components/Scripts/View/ScriptsTree/ScriptNodeParser.ts

@@ -0,0 +1,90 @@
+import { ICategory, IScript } from '@/domain/ICategory';
+import { INode, NodeType } from './SelectableTree/Node/INode';
+import { ICategoryCollection } from '@/domain/ICategoryCollection';
+
+export function parseAllCategories(collection: ICategoryCollection): INode[] | undefined {
+  const nodes = new Array<INode>();
+  for (const category of collection.actions) {
+    const children = parseCategoryRecursively(category);
+    nodes.push(convertCategoryToNode(category, children));
+  }
+  return nodes;
+}
+
+export function parseSingleCategory(categoryId: number, collection: ICategoryCollection): INode[] | undefined {
+  const category = collection.findCategory(categoryId);
+  if (!category) {
+    throw new Error(`Category with id ${categoryId} does not exist`);
+  }
+  const tree = parseCategoryRecursively(category);
+  return tree;
+}
+
+export function getScriptNodeId(script: IScript): string {
+  return script.id;
+}
+export function getScriptId(nodeId: string): string {
+  return nodeId;
+}
+export function getCategoryId(nodeId: string): number {
+  return +nodeId;
+}
+
+export function getCategoryNodeId(category: ICategory): string {
+  return `${category.id}`;
+}
+
+function parseCategoryRecursively(
+  parentCategory: ICategory): INode[] {
+  if (!parentCategory) {
+    throw new Error('parentCategory is undefined');
+  }
+  let nodes = new Array<INode>();
+  nodes = addCategories(parentCategory.subCategories, nodes);
+  nodes = addScripts(parentCategory.scripts, nodes);
+  return nodes;
+}
+
+function addScripts(scripts: ReadonlyArray<IScript>, nodes: INode[]): INode[] {
+  if (!scripts || scripts.length === 0) {
+    return nodes;
+  }
+  for (const script of scripts) {
+    nodes.push(convertScriptToNode(script));
+  }
+  return nodes;
+}
+
+function addCategories(categories: ReadonlyArray<ICategory>, nodes: INode[]): INode[] {
+  if (!categories || categories.length === 0) {
+    return nodes;
+  }
+  for (const category of categories) {
+    const subCategoryNodes = parseCategoryRecursively(category);
+    nodes.push(convertCategoryToNode(category, subCategoryNodes));
+  }
+  return nodes;
+}
+
+function convertCategoryToNode(
+  category: ICategory, children: readonly INode[]): INode {
+  return {
+    id: getCategoryNodeId(category),
+    type: NodeType.Category,
+    text: category.name,
+    children,
+    documentationUrls: category.documentationUrls,
+    isReversible: children && children.every((child) => child.isReversible),
+  };
+}
+
+function convertScriptToNode(script: IScript): INode {
+  return {
+    id: getScriptNodeId(script),
+    type: NodeType.Script,
+    text: script.name,
+    children: undefined,
+    documentationUrls: script.documentationUrls,
+    isReversible: script.canRevert(),
+  };
+}