Refactor to improve iterations

- Use function abstractions (such as map, reduce, filter etc.) over
  for-of loops to gain benefits of having less side effects and easier
  readability.
- Enable `downLevelIterations` for writing modern code with lazy evaluation.
- Refactor for of loops to named abstractions to clearly express their
  intentions without needing to analyse the loop itself.
- Add missing cases for changes that had no tests.

src/application/Context/State/Code/Event/CodeChangedEvent.ts

@@ -42,13 +42,12 @@ export class CodeChangedEvent implements ICodeChangedEvent {
 
 function ensureAllPositionsExist(script: string, positions: ReadonlyArray<ICodePosition>) {
   const totalLines = script.split(/\r\n|\r|\n/).length;
-  for (const position of positions) {
-    if (position.endLine > totalLines) {
-      throw new Error(
-        `script end line (${position.endLine}) is out of range.`
-          + `(total code lines: ${totalLines}`,
-      );
-    }
+  const missingPositions = positions.filter((position) => position.endLine > totalLines);
+  if (missingPositions.length > 0) {
+    throw new Error(
+      `Out of range script end line: "${missingPositions.map((pos) => pos.endLine).join('", "')}"`
+        + `(total code lines: ${totalLines}).`,
+    );
   }
 }
 

src/application/Context/State/Code/Generation/CodeBuilder.ts

@@ -17,9 +17,7 @@ export abstract class CodeBuilder implements ICodeBuilder {
       return this;
     }
     const lines = code.match(/[^\r\n]+/g);
-    for (const line of lines) {
-      this.lines.push(line);
-    }
+    this.lines.push(...lines);
     return this;
   }
 

src/application/Context/State/Code/Generation/UserScriptGenerator.ts

@@ -19,15 +19,14 @@ export class UserScriptGenerator implements IUserScriptGenerator {
   ): IUserScript {
     if (!selectedScripts) { throw new Error('undefined scripts'); }
     if (!scriptingDefinition) { throw new Error('undefined definition'); }
-    let scriptPositions = new Map<SelectedScript, ICodePosition>();
     if (!selectedScripts.length) {
-      return { code: '', scriptPositions };
+      return { code: '', scriptPositions: new Map<SelectedScript, ICodePosition>() };
     }
     let builder = this.codeBuilderFactory.create(scriptingDefinition.language);
     builder = initializeCode(scriptingDefinition.startCode, builder);
-    for (const selection of selectedScripts) {
-      scriptPositions = appendSelection(selection, scriptPositions, builder);
-    }
+    const scriptPositions = selectedScripts.reduce((result, selection) => {
+      return appendSelection(selection, result, builder);
+    }, new Map<SelectedScript, ICodePosition>());
     const code = finalizeCode(builder, scriptingDefinition.endCode);
     return { code, scriptPositions };
   }

src/application/Context/State/Selection/UserSelection.ts

@@ -17,10 +17,8 @@ export class UserSelection implements IUserSelection {
     selectedScripts: ReadonlyArray<SelectedScript>,
   ) {
     this.scripts = new InMemoryRepository<string, SelectedScript>();
-    if (selectedScripts && selectedScripts.length > 0) {
-      for (const script of selectedScripts) {
-        this.scripts.addItem(script);
-      }
+    for (const script of selectedScripts) {
+      this.scripts.addItem(script);
     }
   }
 
@@ -58,18 +56,19 @@ export class UserSelection implements IUserSelection {
   }
 
   public addOrUpdateAllInCategory(categoryId: number, revert = false): void {
-    const category = this.collection.findCategory(categoryId);
-    const scriptsToAddOrUpdate = category.getAllScriptsRecursively()
+    const scriptsToAddOrUpdate = this.collection
+      .findCategory(categoryId)
+      .getAllScriptsRecursively()
       .filter(
         (script) => !this.scripts.exists(script.id)
           || this.scripts.getById(script.id).revert !== revert,
-      );
+      )
+      .map((script) => new SelectedScript(script, revert));
     if (!scriptsToAddOrUpdate.length) {
       return;
     }
     for (const script of scriptsToAddOrUpdate) {
-      const selectedScript = new SelectedScript(script, revert);
-      this.scripts.addOrUpdateItem(selectedScript);
+      this.scripts.addOrUpdateItem(script);
     }
     this.changed.notify(this.scripts.getItems());
   }
@@ -106,11 +105,12 @@ export class UserSelection implements IUserSelection {
   }
 
   public selectAll(): void {
-    for (const script of this.collection.getAllScripts()) {
-      if (!this.scripts.exists(script.id)) {
-        const selection = new SelectedScript(script, false);
-        this.scripts.addItem(selection);
-      }
+    const scriptsToSelect = this.collection
+      .getAllScripts()
+      .filter((script) => !this.scripts.exists(script.id))
+      .map((script) => new SelectedScript(script, false));
+    for (const script of scriptsToSelect) {
+      this.scripts.addItem(script);
     }
     this.changed.notify(this.scripts.getItems());
   }
@@ -135,10 +135,11 @@ export class UserSelection implements IUserSelection {
         .forEach((scriptId) => this.scripts.removeItem(scriptId));
     }
     // Select from unselected scripts
-    const unselectedScripts = scripts.filter((script) => !this.scripts.exists(script.id));
+    const unselectedScripts = scripts
+      .filter((script) => !this.scripts.exists(script.id))
+      .map((script) => new SelectedScript(script, false));
     for (const toSelect of unselectedScripts) {
-      const selection = new SelectedScript(toSelect, false);
-      this.scripts.addItem(selection);
+      this.scripts.addItem(toSelect);
     }
     this.changed.notify(this.scripts.getItems());
   }

src/application/Parser/CategoryCollectionParser.ts

@@ -1,5 +1,4 @@
 import { CollectionData } from 'js-yaml-loader!@/*';
-import { Category } from '@/domain/Category';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { CategoryCollection } from '@/domain/CategoryCollection';
@@ -18,11 +17,7 @@ export function parseCategoryCollection(
   const scripting = new ScriptingDefinitionParser()
     .parse(content.scripting, info);
   const context = new CategoryCollectionParseContext(content.functions, scripting);
-  const categories = new Array<Category>();
-  for (const action of content.actions) {
-    const category = parseCategory(action, context);
-    categories.push(category);
-  }
+  const categories = content.actions.map((action) => parseCategory(action, context));
   const os = osParser.parseEnum(content.os, 'os');
   const collection = new CategoryCollection(
     os,

src/application/Parser/CategoryParser.ts

@@ -9,11 +9,6 @@ import { parseScript } from './Script/ScriptParser';
 
 let categoryIdCounter = 0;
 
-interface ICategoryChildren {
-  subCategories: Category[];
-  subScripts: Script[];
-}
-
 export function parseCategory(
   category: CategoryData,
   context: ICategoryCollectionParseContext,
@@ -48,6 +43,11 @@ function ensureValid(category: CategoryData) {
   }
 }
 
+interface ICategoryChildren {
+  subCategories: Category[];
+  subScripts: Script[];
+}
+
 function parseCategoryChild(
   data: CategoryOrScriptData,
   children: ICategoryChildren,

src/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.ts

@@ -56,14 +56,13 @@ function compileExpressions(
 function extractRequiredParameterNames(
   expressions: readonly IExpression[],
 ): string[] {
-  const usedParameterNames = expressions
+  return expressions
     .map((e) => e.parameters.all
       .filter((p) => !p.isOptional)
       .map((p) => p.name))
-    .filter((p) => p)
-    .flat();
-  const uniqueParameterNames = Array.from(new Set(usedParameterNames));
-  return uniqueParameterNames;
+    .filter(Boolean) // Remove empty or undefined
+    .flat()
+    .filter((name, index, array) => array.indexOf(name) === index); // Remove duplicates
 }
 
 function ensureParamsUsedInCodeHasArgsProvided(

src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts

@@ -16,13 +16,8 @@ export class CompositeExpressionParser implements IExpressionParser {
   }
 
   public findExpressions(code: string): IExpression[] {
-    const expressions = new Array<IExpression>();
-    for (const parser of this.leafs) {
-      const newExpressions = parser.findExpressions(code);
-      if (newExpressions && newExpressions.length) {
-        expressions.push(...newExpressions);
-      }
-    }
-    return expressions;
+    return this.leafs.flatMap(
+      (parser) => parser.findExpressions(code) || [],
+    );
   }
 }

src/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts

@@ -18,35 +18,42 @@ export abstract class RegexParser implements IExpressionParser {
     if (!code) {
       throw new Error('undefined code');
     }
-    const matches = Array.from(code.matchAll(this.regex));
+    const matches = code.matchAll(this.regex);
     for (const match of matches) {
-      const startPos = match.index;
-      const endPos = startPos + match[0].length;
-      let position: ExpressionPosition;
-      try {
-        position = new ExpressionPosition(startPos, endPos);
-      } catch (error) {
-        throw new Error(`[${this.constructor.name}] invalid script position: ${error.message}\nRegex ${this.regex}\nCode: ${code}`);
-      }
       const primitiveExpression = this.buildExpression(match);
-      const parameters = getParameters(primitiveExpression);
+      const position = this.doOrRethrow(() => createPosition(match), 'invalid script position', code);
+      const parameters = createParameters(primitiveExpression);
       const expression = new Expression(position, primitiveExpression.evaluator, parameters);
       yield expression;
     }
   }
+
+  private doOrRethrow<T>(action: () => T, errorText: string, code: string): T {
+    try {
+      return action();
+    } catch (error) {
+      throw new Error(`[${this.constructor.name}] ${errorText}: ${error.message}\nRegex: ${this.regex}\nCode: ${code}`);
+    }
+  }
+}
+
+function createPosition(match: RegExpMatchArray): ExpressionPosition {
+  const startPos = match.index;
+  const endPos = startPos + match[0].length;
+  return new ExpressionPosition(startPos, endPos);
+}
+
+function createParameters(
+  expression: IPrimitiveExpression,
+): FunctionParameterCollection {
+  return (expression.parameters || [])
+    .reduce((parameters, parameter) => {
+      parameters.addParameter(parameter);
+      return parameters;
+    }, new FunctionParameterCollection());
 }
 
 export interface IPrimitiveExpression {
   evaluator: ExpressionEvaluator;
   parameters?: readonly IFunctionParameter[];
 }
-
-function getParameters(
-  expression: IPrimitiveExpression,
-): FunctionParameterCollection {
-  const parameters = new FunctionParameterCollection();
-  for (const parameter of expression.parameters || []) {
-    parameters.addParameter(parameter);
-  }
-  return parameters;
-}

src/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.ts

@@ -8,11 +8,9 @@ export class PipelineCompiler implements IPipelineCompiler {
     ensureValidArguments(value, pipeline);
     const pipeNames = extractPipeNames(pipeline);
     const pipes = pipeNames.map((pipeName) => this.factory.get(pipeName));
-    let valueInCompilation = value;
-    for (const pipe of pipes) {
-      valueInCompilation = pipe.apply(valueInCompilation);
-    }
-    return valueInCompilation;
+    return pipes.reduce((previousValue, pipe) => {
+      return pipe.apply(previousValue);
+    }, value);
   }
 }
 

src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts

@@ -47,11 +47,8 @@ interface ICompiledFunctionCall {
 }
 
 function compileCallSequence(context: ICompilationContext): ICompiledFunctionCall {
-  const compiledFunctions = new Array<ICompiledFunctionCall>();
-  for (const call of context.callSequence) {
-    const compiledCode = compileSingleCall(call, context);
-    compiledFunctions.push(...compiledCode);
-  }
+  const compiledFunctions = context.callSequence
+    .flatMap((call) => compileSingleCall(call, context));
   return {
     code: merge(compiledFunctions.map((f) => f.code)),
     revertCode: merge(compiledFunctions.map((f) => f.revertCode)),
@@ -94,14 +91,17 @@ function compileArgs(
   args: IReadOnlyFunctionCallArgumentCollection,
   compiler: IExpressionsCompiler,
 ): IReadOnlyFunctionCallArgumentCollection {
-  const compiledArgs = new FunctionCallArgumentCollection();
-  for (const parameterName of argsToCompile.getAllParameterNames()) {
-    const { argumentValue } = argsToCompile.getArgument(parameterName);
-    const compiledValue = compiler.compileExpressions(argumentValue, args);
-    const newArgument = new FunctionCallArgument(parameterName, compiledValue);
-    compiledArgs.addArgument(newArgument);
-  }
-  return compiledArgs;
+  return argsToCompile
+    .getAllParameterNames()
+    .map((parameterName) => {
+      const { argumentValue } = argsToCompile.getArgument(parameterName);
+      const compiledValue = compiler.compileExpressions(argumentValue, args);
+      return new FunctionCallArgument(parameterName, compiledValue);
+    })
+    .reduce((compiledArgs, arg) => {
+      compiledArgs.addArgument(arg);
+      return compiledArgs;
+    }, new FunctionCallArgumentCollection());
 }
 
 function merge(codeParts: readonly string[]): string {

src/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.ts

@@ -1,4 +1,4 @@
-import { FunctionCallData, FunctionCallsData } from 'js-yaml-loader!@/*';
+import { FunctionCallData, FunctionCallsData, FunctionCallParametersData } from 'js-yaml-loader!@/*';
 import { IFunctionCall } from './IFunctionCall';
 import { FunctionCallArgumentCollection } from './Argument/FunctionCallArgumentCollection';
 import { FunctionCallArgument } from './Argument/FunctionCallArgument';
@@ -26,10 +26,17 @@ function parseFunctionCall(call: FunctionCallData): IFunctionCall {
   if (!call) {
     throw new Error('undefined function call');
   }
-  const args = new FunctionCallArgumentCollection();
-  for (const parameterName of Object.keys(call.parameters || {})) {
-    const arg = new FunctionCallArgument(parameterName, call.parameters[parameterName]);
-    args.addArgument(arg);
-  }
-  return new FunctionCall(call.function, args);
+  const callArgs = parseArgs(call.parameters);
+  return new FunctionCall(call.function, callArgs);
+}
+
+function parseArgs(
+  parameters: FunctionCallParametersData,
+): FunctionCallArgumentCollection {
+  return Object.keys(parameters || {})
+    .map((parameterName) => new FunctionCallArgument(parameterName, parameters[parameterName]))
+    .reduce((args, arg) => {
+      args.addArgument(arg);
+      return args;
+    }, new FunctionCallArgumentCollection());
 }

src/application/Parser/Script/Compiler/Function/SharedFunctionsParser.ts

@@ -20,11 +20,12 @@ export class SharedFunctionsParser implements ISharedFunctionsParser {
       return collection;
     }
     ensureValidFunctions(functions);
-    for (const func of functions) {
-      const sharedFunction = parseFunction(func);
-      collection.addFunction(sharedFunction);
-    }
-    return collection;
+    return functions
+      .map((func) => parseFunction(func))
+      .reduce((acc, func) => {
+        acc.addFunction(func);
+        return acc;
+      }, collection);
   }
 }
 
@@ -40,20 +41,21 @@ function parseFunction(data: FunctionData): ISharedFunction {
 }
 
 function parseParameters(data: FunctionData): IReadOnlyFunctionParameterCollection {
-  const parameters = new FunctionParameterCollection();
-  if (!data.parameters) {
-    return parameters;
-  }
-  for (const parameterData of data.parameters) {
-    const isOptional = parameterData.optional || false;
-    try {
-      const parameter = new FunctionParameter(parameterData.name, isOptional);
+  return (data.parameters || [])
+    .map((parameter) => {
+      try {
+        return new FunctionParameter(
+          parameter.name,
+          parameter.optional || false,
+        );
+      } catch (err) {
+        throw new Error(`"${data.name}": ${err.message}`);
+      }
+    })
+    .reduce((parameters, parameter) => {
       parameters.addParameter(parameter);
-    } catch (err) {
-      throw new Error(`"${data.name}": ${err.message}`);
-    }
-  }
-  return parameters;
+      return parameters;
+    }, new FunctionParameterCollection());
 }
 
 function hasCode(data: FunctionData): boolean {

src/domain/CategoryCollection.ts

@@ -1,4 +1,4 @@
-import { getEnumNames, getEnumValues, assertInRange } from '@/application/Common/Enum';
+import { getEnumValues, assertInRange } from '@/application/Common/Enum';
 import { IEntity } from '../infrastructure/Entity/IEntity';
 import { ICategory } from './ICategory';
 import { IScript } from './IScript';
@@ -57,16 +57,12 @@ export class CategoryCollection implements ICategoryCollection {
 }
 
 function ensureNoDuplicates<TKey>(entities: ReadonlyArray<IEntity<TKey>>) {
-  const totalOccurrencesById = new Map<TKey, number>();
-  for (const entity of entities) {
-    totalOccurrencesById.set(entity.id, (totalOccurrencesById.get(entity.id) || 0) + 1);
-  }
-  const duplicatedIds = new Array<TKey>();
-  totalOccurrencesById.forEach((index, id) => {
-    if (index > 1) {
-      duplicatedIds.push(id);
-    }
-  });
+  const isUniqueInArray = (id: TKey, index: number, array: readonly TKey[]) => array
+    .findIndex((otherId) => otherId === id) !== index;
+  const duplicatedIds = entities
+    .map((entity) => entity.id)
+    .filter((id, index, array) => !isUniqueInArray(id, index, array))
+    .filter(isUniqueInArray);
   if (duplicatedIds.length > 0) {
     const duplicatedIdsText = duplicatedIds.map((id) => `"${id}"`).join(',');
     throw new Error(
@@ -96,48 +92,37 @@ function ensureValidScripts(allScripts: readonly IScript[]) {
   if (!allScripts || allScripts.length === 0) {
     throw new Error('must consist of at least one script');
   }
-  for (const level of getEnumValues(RecommendationLevel)) {
-    if (allScripts.every((script) => script.level !== level)) {
-      throw new Error(`none of the scripts are recommended as ${RecommendationLevel[level]}`);
-    }
+  const missingRecommendationLevels = getEnumValues(RecommendationLevel)
+    .filter((level) => allScripts.every((script) => script.level !== level));
+  if (missingRecommendationLevels.length > 0) {
+    throw new Error('none of the scripts are recommended as'
+      + ` "${missingRecommendationLevels.map((level) => RecommendationLevel[level]).join(', "')}".`);
   }
 }
 
-function flattenApplication(categories: ReadonlyArray<ICategory>): [ICategory[], IScript[]] {
-  const allCategories = new Array<ICategory>();
-  const allScripts = new Array<IScript>();
-  flattenCategories(categories, allCategories, allScripts);
-  return [
-    allCategories,
-    allScripts,
-  ];
-}
-
-function flattenCategories(
+function flattenApplication(
   categories: ReadonlyArray<ICategory>,
-  allCategories: ICategory[],
-  allScripts: IScript[],
-): IQueryableCollection {
-  if (!categories || categories.length === 0) {
-    return;
-  }
-  for (const category of categories) {
-    allCategories.push(category);
-    flattenScripts(category.scripts, allScripts);
-    flattenCategories(category.subCategories, allCategories, allScripts);
-  }
-}
-
-function flattenScripts(
-  scripts: ReadonlyArray<IScript>,
-  allScripts: IScript[],
-): IScript[] {
-  if (!scripts) {
-    return;
-  }
-  for (const script of scripts) {
-    allScripts.push(script);
-  }
+): [ICategory[], IScript[]] {
+  const [subCategories, subScripts] = (categories || [])
+    // Parse children
+    .map((category) => flattenApplication(category.subCategories))
+    // Flatten results
+    .reduce(([previousCategories, previousScripts], [currentCategories, currentScripts]) => {
+      return [
+        [...previousCategories, ...currentCategories],
+        [...previousScripts, ...currentScripts],
+      ];
+    }, [new Array<ICategory>(), new Array<IScript>()]);
+  return [
+    [
+      ...(categories || []),
+      ...subCategories,
+    ],
+    [
+      ...(categories || []).flatMap((category) => category.scripts || []),
+      ...subScripts,
+    ],
+  ];
 }
 
 function makeQueryable(
@@ -154,13 +139,15 @@ function makeQueryable(
 function groupByLevel(
   allScripts: readonly IScript[],
 ): Map<RecommendationLevel, readonly IScript[]> {
-  const map = new Map<RecommendationLevel, readonly IScript[]>();
-  for (const levelName of getEnumNames(RecommendationLevel)) {
-    const level = RecommendationLevel[levelName];
-    const scripts = allScripts.filter(
-      (script) => script.level !== undefined && script.level <= level,
-    );
-    map.set(level, scripts);
-  }
-  return map;
+  return getEnumValues(RecommendationLevel)
+    .map((level) => ({
+      level,
+      scripts: allScripts.filter(
+        (script) => script.level !== undefined && script.level <= level,
+      ),
+    }))
+    .reduce((map, group) => {
+      map.set(group.level, group.scripts);
+      return map;
+    }, new Map<RecommendationLevel, readonly IScript[]>());
 }

src/infrastructure/Events/EventSource.ts

@@ -12,7 +12,7 @@ export class EventSource<T> implements IEventSource<T> {
   }
 
   public notify(data: T) {
-    for (const handler of Array.from(this.handlers.values())) {
+    for (const handler of this.handlers.values()) {
       handler(data);
     }
   }

src/presentation/components/Scripts/Menu/Selector/SelectionTypeHandler.ts

@@ -26,7 +26,7 @@ export class SelectionTypeHandler {
   }
 
   public getCurrentSelectionType(): SelectionType {
-    for (const [type, selector] of Array.from(selectors.entries())) {
+    for (const [type, selector] of selectors.entries()) {
       if (selector.isSelected(this.state)) {
         return type;
       }

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

@@ -3,12 +3,7 @@ import { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { INode, NodeType } from './SelectableTree/Node/INode';
 
 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;
+  return createCategoryNodes(collection.actions);
 }
 
 export function parseSingleCategory(
@@ -43,31 +38,21 @@ function parseCategoryRecursively(
   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;
+  return [
+    ...createCategoryNodes(parentCategory.subCategories),
+    ...createScriptNodes(parentCategory.scripts),
+  ];
 }
 
-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 createScriptNodes(scripts: ReadonlyArray<IScript>): INode[] {
+  return (scripts || [])
+    .map((script) => convertScriptToNode(script));
 }
 
-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 createCategoryNodes(categories: ReadonlyArray<ICategory>): INode[] {
+  return (categories || [])
+    .map((category) => ({ category, children: parseCategoryRecursively(category) }))
+    .map((data) => convertCategoryToNode(data.category, data.children));
 }
 
 function convertCategoryToNode(