Refactor to unify scripts/categories as Executable

This commit consolidates scripts and categories under a unified
'Executable' concept. This simplifies the architecture and improves code
readability.

- Introduce subfolders within `src/domain` to segregate domain elements.
- Update class and interface names by removing the 'I' prefix in
  alignment with new coding standards.
- Replace 'Node' with 'Executable' to clarify usage; reserve 'Node'
  exclusively for the UI's tree component.

src/application/Parser/CategoryCollectionParser.ts

@@ -4,20 +4,21 @@ import type { ICategoryCollection } from '@/domain/ICategoryCollection';
 import { CategoryCollection } from '@/domain/CategoryCollection';
 import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
 import { createEnumParser } from '../Common/Enum';
-import { parseCategory } from './CategoryParser';
-import { CategoryCollectionParseContext } from './Script/CategoryCollectionParseContext';
+import { parseCategory } from './Executable/CategoryParser';
 import { ScriptingDefinitionParser } from './ScriptingDefinition/ScriptingDefinitionParser';
+import { createCollectionUtilities, type CategoryCollectionSpecificUtilitiesFactory } from './Executable/CategoryCollectionSpecificUtilities';
 
 export function parseCategoryCollection(
   content: CollectionData,
   projectDetails: ProjectDetails,
   osParser = createEnumParser(OperatingSystem),
+  createUtilities: CategoryCollectionSpecificUtilitiesFactory = createCollectionUtilities,
 ): ICategoryCollection {
   validate(content);
   const scripting = new ScriptingDefinitionParser()
     .parse(content.scripting, projectDetails);
-  const context = new CategoryCollectionParseContext(content.functions, scripting);
-  const categories = content.actions.map((action) => parseCategory(action, context));
+  const utilities = createUtilities(content.functions, scripting);
+  const categories = content.actions.map((action) => parseCategory(action, utilities));
   const os = osParser.parseEnum(content.os, 'os');
   const collection = new CategoryCollection(
     os,

src/application/Parser/Executable/CategoryCollectionSpecificUtilities.ts

@@ -0,0 +1,32 @@
+import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+import type { FunctionData } from '@/application/collections/';
+import { ScriptCompiler } from './Script/Compiler/ScriptCompiler';
+import { SyntaxFactory } from './Script/Validation/Syntax/SyntaxFactory';
+import type { IScriptCompiler } from './Script/Compiler/IScriptCompiler';
+import type { ILanguageSyntax } from './Script/Validation/Syntax/ILanguageSyntax';
+import type { ISyntaxFactory } from './Script/Validation/Syntax/ISyntaxFactory';
+
+export interface CategoryCollectionSpecificUtilities {
+  readonly compiler: IScriptCompiler;
+  readonly syntax: ILanguageSyntax;
+}
+
+export const createCollectionUtilities: CategoryCollectionSpecificUtilitiesFactory = (
+  functionsData: ReadonlyArray<FunctionData> | undefined,
+  scripting: IScriptingDefinition,
+  syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
+) => {
+  const syntax = syntaxFactory.create(scripting.language);
+  return {
+    compiler: new ScriptCompiler(functionsData ?? [], syntax),
+    syntax,
+  };
+};
+
+export interface CategoryCollectionSpecificUtilitiesFactory {
+  (
+    functionsData: ReadonlyArray<FunctionData> | undefined,
+    scripting: IScriptingDefinition,
+    syntaxFactory?: ISyntaxFactory,
+  ): CategoryCollectionSpecificUtilities;
+}

src/application/Parser/Executable/CategoryParser.ts

@@ -1,35 +1,35 @@
 import type {
-  CategoryData, ScriptData, CategoryOrScriptData,
+  CategoryData, ScriptData, ExecutableData,
 } from '@/application/collections/';
-import { Script } from '@/domain/Script';
-import { Category } from '@/domain/Category';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import type { ICategory } from '@/domain/ICategory';
+import type { Category } from '@/domain/Executables/Category/Category';
+import { CollectionCategory } from '@/domain/Executables/Category/CollectionCategory';
+import type { Script } from '@/domain/Executables/Script/Script';
 import { parseDocs, type DocsParser } from './DocumentationParser';
 import { parseScript, type ScriptParser } from './Script/ScriptParser';
-import { createNodeDataValidator, type NodeDataValidator, type NodeDataValidatorFactory } from './NodeValidation/NodeDataValidator';
-import { NodeDataType } from './NodeValidation/NodeDataType';
-import type { ICategoryCollectionParseContext } from './Script/ICategoryCollectionParseContext';
+import { createExecutableDataValidator, type ExecutableValidator, type ExecutableValidatorFactory } from './Validation/ExecutableValidator';
+import { ExecutableType } from './Validation/ExecutableType';
+import type { CategoryCollectionSpecificUtilities } from './CategoryCollectionSpecificUtilities';
 
 let categoryIdCounter = 0;
 
 export function parseCategory(
   category: CategoryData,
-  context: ICategoryCollectionParseContext,
-  utilities: CategoryParserUtilities = DefaultCategoryParserUtilities,
+  collectionUtilities: CategoryCollectionSpecificUtilities,
+  categoryUtilities: CategoryParserUtilities = DefaultCategoryParserUtilities,
 ): Category {
   return parseCategoryRecursively({
     categoryData: category,
-    context,
-    utilities,
+    collectionUtilities,
+    categoryUtilities,
   });
 }
 
 interface CategoryParseContext {
   readonly categoryData: CategoryData;
-  readonly context: ICategoryCollectionParseContext;
+  readonly collectionUtilities: CategoryCollectionSpecificUtilities;
   readonly parentCategory?: CategoryData;
-  readonly utilities: CategoryParserUtilities;
+  readonly categoryUtilities: CategoryParserUtilities;
 }
 
 function parseCategoryRecursively(
@@ -41,24 +41,24 @@ function parseCategoryRecursively(
     subscripts: new Array<Script>(),
   };
   for (const data of context.categoryData.children) {
-    parseNode({
-      nodeData: data,
+    parseExecutable({
+      data,
       children,
       parent: context.categoryData,
-      utilities: context.utilities,
-      context: context.context,
+      categoryUtilities: context.categoryUtilities,
+      collectionUtilities: context.collectionUtilities,
     });
   }
   try {
-    return context.utilities.createCategory({
+    return context.categoryUtilities.createCategory({
       id: categoryIdCounter++,
       name: context.categoryData.category,
-      docs: context.utilities.parseDocs(context.categoryData),
+      docs: context.categoryUtilities.parseDocs(context.categoryData),
       subcategories: children.subcategories,
       scripts: children.subscripts,
     });
   } catch (error) {
-    throw context.utilities.wrapError(
+    throw context.categoryUtilities.wrapError(
       error,
       validator.createContextualErrorMessage('Failed to parse category.'),
     );
@@ -67,12 +67,12 @@ function parseCategoryRecursively(
 
 function ensureValidCategory(
   context: CategoryParseContext,
-): NodeDataValidator {
+): ExecutableValidator {
   const category = context.categoryData;
-  const validator: NodeDataValidator = context.utilities.createValidator({
-    type: NodeDataType.Category,
-    selfNode: context.categoryData,
-    parentNode: context.parentCategory,
+  const validator: ExecutableValidator = context.categoryUtilities.createValidator({
+    type: ExecutableType.Category,
+    self: context.categoryData,
+    parentCategory: context.parentCategory,
   });
   validator.assertDefined(category);
   validator.assertValidName(category.category);
@@ -88,44 +88,43 @@ interface CategoryChildren {
   readonly subscripts: Script[];
 }
 
-interface NodeParseContext {
-  readonly nodeData: CategoryOrScriptData;
+interface ExecutableParseContext {
+  readonly data: ExecutableData;
   readonly children: CategoryChildren;
   readonly parent: CategoryData;
-  readonly context: ICategoryCollectionParseContext;
-
-  readonly utilities: CategoryParserUtilities;
+  readonly collectionUtilities: CategoryCollectionSpecificUtilities;
+  readonly categoryUtilities: CategoryParserUtilities;
 }
 
-function parseNode(context: NodeParseContext) {
-  const validator: NodeDataValidator = context.utilities.createValidator({
-    selfNode: context.nodeData,
-    parentNode: context.parent,
+function parseExecutable(context: ExecutableParseContext) {
+  const validator: ExecutableValidator = context.categoryUtilities.createValidator({
+    self: context.data,
+    parentCategory: context.parent,
   });
-  validator.assertDefined(context.nodeData);
+  validator.assertDefined(context.data);
   validator.assert(
-    () => isCategory(context.nodeData) || isScript(context.nodeData),
-    'Node is neither a category or a script.',
+    () => isCategory(context.data) || isScript(context.data),
+    'Executable is neither a category or a script.',
   );
-  if (isCategory(context.nodeData)) {
+  if (isCategory(context.data)) {
     const subCategory = parseCategoryRecursively({
-      categoryData: context.nodeData,
-      context: context.context,
+      categoryData: context.data,
+      collectionUtilities: context.collectionUtilities,
       parentCategory: context.parent,
-      utilities: context.utilities,
+      categoryUtilities: context.categoryUtilities,
     });
     context.children.subcategories.push(subCategory);
   } else { // A script
-    const script = context.utilities.parseScript(context.nodeData, context.context);
+    const script = context.categoryUtilities.parseScript(context.data, context.collectionUtilities);
     context.children.subscripts.push(script);
   }
 }
 
-function isScript(data: CategoryOrScriptData): data is ScriptData {
+function isScript(data: ExecutableData): data is ScriptData {
   return hasCode(data) || hasCall(data);
 }
 
-function isCategory(data: CategoryOrScriptData): data is CategoryData {
+function isCategory(data: ExecutableData): data is CategoryData {
   return hasProperty(data, 'category');
 }
 
@@ -151,21 +150,21 @@ function hasProperty(
 }
 
 export type CategoryFactory = (
-  ...parameters: ConstructorParameters<typeof Category>
-) => ICategory;
+  ...parameters: ConstructorParameters<typeof CollectionCategory>
+) => Category;
 
 interface CategoryParserUtilities {
   readonly createCategory: CategoryFactory;
   readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: NodeDataValidatorFactory;
+  readonly createValidator: ExecutableValidatorFactory;
   readonly parseScript: ScriptParser;
   readonly parseDocs: DocsParser;
 }
 
 const DefaultCategoryParserUtilities: CategoryParserUtilities = {
-  createCategory: (...parameters) => new Category(...parameters),
+  createCategory: (...parameters) => new CollectionCategory(...parameters),
   wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createNodeDataValidator,
+  createValidator: createExecutableDataValidator,
   parseScript,
   parseDocs,
 };

src/application/Parser/Executable/Script/Compiler/Expressions/Expression/Expression.ts

@@ -1,4 +1,4 @@
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
 import { FunctionCallArgumentCollection } from '../../Function/Call/Argument/FunctionCallArgumentCollection';
 import { ExpressionEvaluationContext, type IExpressionEvaluationContext } from './ExpressionEvaluationContext';
 import { ExpressionPosition } from './ExpressionPosition';

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

@@ -1,4 +1,4 @@
-import { type IExpressionEvaluationContext, ExpressionEvaluationContext } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
+import { type IExpressionEvaluationContext, ExpressionEvaluationContext } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext';
 import { CompositeExpressionParser } from './Parser/CompositeExpressionParser';
 import type { IReadOnlyFunctionCallArgumentCollection } from '../Function/Call/Argument/IFunctionCallArgumentCollection';
 import type { IExpressionsCompiler } from './IExpressionsCompiler';

src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts

@@ -1,4 +1,4 @@
-import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import { FunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter';
 import { RegexParser, type PrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 

src/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts

@@ -1,7 +1,7 @@
 // eslint-disable-next-line max-classes-per-file
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
-import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { FunctionParameterCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameter } from '@/application/Parser/Executable/Script/Compiler/Function/Parameter/FunctionParameter';
 import { ExpressionPosition } from '../Expression/ExpressionPosition';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 import { createPositionFromRegexFullMatch } from '../Expression/ExpressionPositionFactory';

src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext.ts

@@ -1,4 +1,4 @@
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
 import type { FunctionCall } from '../FunctionCall';
 import type { SingleCallCompiler } from './SingleCall/SingleCallCompiler';
 

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

@@ -1,4 +1,4 @@
-import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
+import type { ISharedFunctionCollection } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionCollection';
 import type { CompiledCode } from './CompiledCode';
 import type { FunctionCall } from '../FunctionCall';
 

src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.ts

@@ -1,4 +1,4 @@
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import { NewlineCodeSegmentMerger } from './CodeSegmentJoin/NewlineCodeSegmentMerger';
 import { AdaptiveFunctionCallCompiler } from './SingleCall/AdaptiveFunctionCallCompiler';
 import type { ISharedFunctionCollection } from '../../ISharedFunctionCollection';

src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompilerStrategy.ts

@@ -1,5 +1,5 @@
-import type { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
+import type { ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
 import type { CompiledCode } from '../CompiledCode';
 import type { FunctionCallCompilationContext } from '../FunctionCallCompilationContext';
 

src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/ArgumentCompiler.ts

@@ -1,5 +1,5 @@
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
 
 export interface ArgumentCompiler {
   createCompiledNestedCall(

src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts

@@ -1,11 +1,11 @@
-import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
-import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
-import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
-import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import { ParsedFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall';
+import type { IReadOnlyFunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/IFunctionCallArgumentCollection';
+import { FunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import { FunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
+import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import { ParsedFunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/ParsedFunctionCall';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import type { ArgumentCompiler } from './ArgumentCompiler';
 

src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts

@@ -1,8 +1,8 @@
-import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
+import { FunctionBodyType, type ISharedFunction } from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import type { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';
 
 export class InlineFunctionCallCompiler implements SingleCallCompilerStrategy {

src/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts

@@ -1,10 +1,10 @@
 import {
   type CallFunctionBody, FunctionBodyType,
   type ISharedFunction,
-} from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
-import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+} from '@/application/Parser/Executable/Script/Compiler/Function/ISharedFunction';
+import type { FunctionCall } from '@/application/Parser/Executable/Script/Compiler/Function/Call/FunctionCall';
+import type { FunctionCallCompilationContext } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
+import type { CompiledCode } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { NestedFunctionArgumentCompiler } from './Argument/NestedFunctionArgumentCompiler';
 import type { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';

src/application/Parser/Executable/Script/Compiler/Function/ISharedFunctionsParser.ts

@@ -1,5 +1,5 @@
 import type { FunctionData } from '@/application/collections/';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import type { ISharedFunctionCollection } from './ISharedFunctionCollection';
 
 export interface ISharedFunctionsParser {

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

@@ -2,11 +2,11 @@ import type {
   FunctionData, CodeInstruction, CodeFunctionData, CallFunctionData,
   CallInstruction, ParameterDefinitionData,
 } from '@/application/collections/';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import { CodeValidator } from '@/application/Parser/Executable/Script/Validation/CodeValidator';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import { NoDuplicatedLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import { isArray, isNullOrUndefined, isPlainObject } from '@/TypeHelpers';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { createFunctionWithInlineCode, createCallerFunction } from './SharedFunction';

src/application/Parser/Executable/Script/Compiler/IScriptCompiler.ts

@@ -1,7 +1,7 @@
 import type { ScriptData } from '@/application/collections/';
-import type { IScriptCode } from '@/domain/IScriptCode';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
 
 export interface IScriptCompiler {
   canCompile(script: ScriptData): boolean;
-  compile(script: ScriptData): IScriptCode;
+  compile(script: ScriptData): ScriptCode;
 }

src/application/Parser/Executable/Script/Compiler/ScriptCompiler.ts

@@ -1,11 +1,11 @@
 import type { FunctionData, ScriptData, CallInstruction } from '@/application/collections/';
-import type { IScriptCode } from '@/domain/IScriptCode';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import { CodeValidator } from '@/application/Parser/Executable/Script/Validation/CodeValidator';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { createScriptCode, type ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
+import { createScriptCode, type ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
 import { SharedFunctionsParser } from './Function/SharedFunctionsParser';
 import { FunctionCallSequenceCompiler } from './Function/Call/Compiler/FunctionCallSequenceCompiler';
 import { parseFunctionCalls } from './Function/Call/FunctionCallParser';
@@ -34,7 +34,7 @@ export class ScriptCompiler implements IScriptCompiler {
     return hasCall(script);
   }
 
-  public compile(script: ScriptData): IScriptCode {
+  public compile(script: ScriptData): ScriptCode {
     try {
       if (!hasCall(script)) {
         throw new Error('Script does include any calls.');

src/application/Parser/Executable/Script/ScriptParser.ts

@@ -1,44 +1,44 @@
 import type { ScriptData, CodeScriptData, CallScriptData } from '@/application/collections/';
-import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
-import { Script } from '@/domain/Script';
-import { RecommendationLevel } from '@/domain/RecommendationLevel';
-import type { IScriptCode } from '@/domain/IScriptCode';
-import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
+import { NoEmptyLines } from '@/application/Parser/Executable/Script/Validation/Rules/NoEmptyLines';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
+import { CollectionScript } from '@/domain/Executables/Script/CollectionScript';
+import { RecommendationLevel } from '@/domain/Executables/Script/RecommendationLevel';
+import type { ScriptCode } from '@/domain/Executables/Script/Code/ScriptCode';
+import type { ICodeValidator } from '@/application/Parser/Executable/Script/Validation/ICodeValidator';
 import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
-import { createScriptCode } from '@/domain/ScriptCodeFactory';
-import type { IScript } from '@/domain/IScript';
+import type { ScriptCodeFactory } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
+import { createScriptCode } from '@/domain/Executables/Script/Code/ScriptCodeFactory';
+import type { Script } from '@/domain/Executables/Script/Script';
+import { createEnumParser, type IEnumParser } from '@/application/Common/Enum';
 import { parseDocs, type DocsParser } from '../DocumentationParser';
-import { createEnumParser, type IEnumParser } from '../../Common/Enum';
-import { NodeDataType } from '../NodeValidation/NodeDataType';
-import { createNodeDataValidator, type NodeDataValidator, type NodeDataValidatorFactory } from '../NodeValidation/NodeDataValidator';
+import { ExecutableType } from '../Validation/ExecutableType';
+import { createExecutableDataValidator, type ExecutableValidator, type ExecutableValidatorFactory } from '../Validation/ExecutableValidator';
 import { CodeValidator } from './Validation/CodeValidator';
 import { NoDuplicatedLines } from './Validation/Rules/NoDuplicatedLines';
-import type { ICategoryCollectionParseContext } from './ICategoryCollectionParseContext';
+import type { CategoryCollectionSpecificUtilities } from '../CategoryCollectionSpecificUtilities';
 
 export interface ScriptParser {
   (
     data: ScriptData,
-    context: ICategoryCollectionParseContext,
-    utilities?: ScriptParserUtilities,
-  ): IScript;
+    collectionUtilities: CategoryCollectionSpecificUtilities,
+    scriptUtilities?: ScriptParserUtilities,
+  ): Script;
 }
 
 export const parseScript: ScriptParser = (
   data,
-  context,
+  collectionUtilities,
   utilities = DefaultScriptParserUtilities,
 ) => {
   const validator = utilities.createValidator({
-    type: NodeDataType.Script,
-    selfNode: data,
+    type: ExecutableType.Script,
+    self: data,
   });
   validateScript(data, validator);
   try {
     const script = utilities.createScript({
       name: data.name,
-      code: parseCode(data, context, utilities.codeValidator, utilities.createCode),
+      code: parseCode(data, collectionUtilities, utilities.codeValidator, utilities.createCode),
       docs: utilities.parseDocs(data),
       level: parseLevel(data.recommend, utilities.levelParser),
     });
@@ -63,21 +63,21 @@ function parseLevel(
 
 function parseCode(
   script: ScriptData,
-  context: ICategoryCollectionParseContext,
+  collectionUtilities: CategoryCollectionSpecificUtilities,
   codeValidator: ICodeValidator,
   createCode: ScriptCodeFactory,
-): IScriptCode {
-  if (context.compiler.canCompile(script)) {
-    return context.compiler.compile(script);
+): ScriptCode {
+  if (collectionUtilities.compiler.canCompile(script)) {
+    return collectionUtilities.compiler.compile(script);
   }
   const codeScript = script as CodeScriptData; // Must be inline code if it cannot be compiled
   const code = createCode(codeScript.code, codeScript.revertCode);
-  validateHardcodedCodeWithoutCalls(code, codeValidator, context.syntax);
+  validateHardcodedCodeWithoutCalls(code, codeValidator, collectionUtilities.syntax);
   return code;
 }
 
 function validateHardcodedCodeWithoutCalls(
-  scriptCode: IScriptCode,
+  scriptCode: ScriptCode,
   validator: ICodeValidator,
   syntax: ILanguageSyntax,
 ) {
@@ -93,7 +93,7 @@ function validateHardcodedCodeWithoutCalls(
 
 function validateScript(
   script: ScriptData,
-  validator: NodeDataValidator,
+  validator: ExecutableValidator,
 ): asserts script is NonNullable<ScriptData> {
   validator.assertDefined(script);
   validator.assertValidName(script.name);
@@ -116,17 +116,17 @@ interface ScriptParserUtilities {
   readonly createScript: ScriptFactory;
   readonly codeValidator: ICodeValidator;
   readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: NodeDataValidatorFactory;
+  readonly createValidator: ExecutableValidatorFactory;
   readonly createCode: ScriptCodeFactory;
   readonly parseDocs: DocsParser;
 }
 
 export type ScriptFactory = (
-  ...parameters: ConstructorParameters<typeof Script>
-) => IScript;
+  ...parameters: ConstructorParameters<typeof CollectionScript>
+) => Script;
 
 const createScript: ScriptFactory = (...parameters) => {
-  return new Script(...parameters);
+  return new CollectionScript(...parameters);
 };
 
 const DefaultScriptParserUtilities: ScriptParserUtilities = {
@@ -134,7 +134,7 @@ const DefaultScriptParserUtilities: ScriptParserUtilities = {
   createScript,
   codeValidator: CodeValidator.instance,
   wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createNodeDataValidator,
+  createValidator: createExecutableDataValidator,
   createCode: createScriptCode,
   parseDocs,
 };

src/application/Parser/Executable/Script/Validation/Rules/NoDuplicatedLines.ts

@@ -1,4 +1,4 @@
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import type { ICodeLine } from '../ICodeLine';
 import type { ICodeValidationRule, IInvalidCodeLine } from '../ICodeValidationRule';
 

src/application/Parser/Executable/Script/Validation/Syntax/BatchFileSyntax.ts

@@ -1,4 +1,4 @@
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 
 const BatchFileCommonCodeParts = ['(', ')', 'else', '||'];
 const PowerShellCommonCodeParts = ['{', '}'];

src/application/Parser/Executable/Script/Validation/Syntax/ShellScriptSyntax.ts

@@ -1,4 +1,4 @@
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 
 export class ShellScriptSyntax implements ILanguageSyntax {
   public readonly commentDelimiters = ['#'];

src/application/Parser/Executable/Script/Validation/Syntax/SyntaxFactory.ts

@@ -1,6 +1,6 @@
 import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
 import { ScriptingLanguageFactory } from '@/application/Common/ScriptingLanguage/ScriptingLanguageFactory';
-import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
+import type { ILanguageSyntax } from '@/application/Parser/Executable/Script/Validation/Syntax/ILanguageSyntax';
 import { BatchFileSyntax } from './BatchFileSyntax';
 import { ShellScriptSyntax } from './ShellScriptSyntax';
 import type { ISyntaxFactory } from './ISyntaxFactory';

src/application/Parser/Executable/Validation/ExecutableErrorContext.ts

@@ -0,0 +1,24 @@
+import type { CategoryData, ScriptData, ExecutableData } from '@/application/collections/';
+import { ExecutableType } from './ExecutableType';
+
+export type ExecutableErrorContext = {
+  readonly parentCategory?: CategoryData;
+} & (CategoryErrorContext | ScriptErrorContext | UnknownExecutableErrorContext);
+
+export type CategoryErrorContext = {
+  readonly type: ExecutableType.Category;
+  readonly self: CategoryData;
+  readonly parentCategory?: CategoryData;
+};
+
+export type ScriptErrorContext = {
+  readonly type: ExecutableType.Script;
+  readonly self: ScriptData;
+  readonly parentCategory?: CategoryData;
+};
+
+export type UnknownExecutableErrorContext = {
+  readonly type?: undefined;
+  readonly self: ExecutableData;
+  readonly parentCategory?: CategoryData;
+};

src/application/Parser/Executable/Validation/ExecutableErrorContextMessage.ts

@@ -0,0 +1,35 @@
+import type { ExecutableData } from '@/application/collections/';
+import { ExecutableType } from './ExecutableType';
+import type { ExecutableErrorContext } from './ExecutableErrorContext';
+
+export interface ExecutableContextErrorMessageCreator {
+  (
+    errorMessage: string,
+    context: ExecutableErrorContext,
+  ): string;
+}
+
+export const createExecutableContextErrorMessage: ExecutableContextErrorMessageCreator = (
+  errorMessage,
+  context,
+) => {
+  let message = '';
+  if (context.type !== undefined) {
+    message += `${ExecutableType[context.type]}: `;
+  }
+  message += errorMessage;
+  message += `\n${getErrorContextDetails(context)}`;
+  return message;
+};
+
+function getErrorContextDetails(context: ExecutableErrorContext): string {
+  let output = `Self: ${printExecutable(context.self)}`;
+  if (context.parentCategory) {
+    output += `\nParent: ${printExecutable(context.parentCategory)}`;
+  }
+  return output;
+}
+
+function printExecutable(executable: ExecutableData): string {
+  return JSON.stringify(executable, undefined, 2);
+}

src/application/Parser/Executable/Validation/ExecutableType.ts

@@ -0,0 +1,4 @@
+export enum ExecutableType {
+  Script,
+  Category,
+}

src/application/Parser/Executable/Validation/ExecutableValidator.ts

@@ -1,17 +1,17 @@
 import { isString } from '@/TypeHelpers';
-import { type NodeDataErrorContext } from './NodeDataErrorContext';
-import { createNodeContextErrorMessage, type NodeContextErrorMessageCreator } from './NodeDataErrorContextMessage';
-import type { NodeData } from './NodeData';
+import type { ExecutableData } from '@/application/collections/';
+import { type ExecutableErrorContext } from './ExecutableErrorContext';
+import { createExecutableContextErrorMessage, type ExecutableContextErrorMessageCreator } from './ExecutableErrorContextMessage';
 
-export interface NodeDataValidatorFactory {
-  (context: NodeDataErrorContext): NodeDataValidator;
+export interface ExecutableValidatorFactory {
+  (context: ExecutableErrorContext): ExecutableValidator;
 }
 
-export interface NodeDataValidator {
+export interface ExecutableValidator {
   assertValidName(nameValue: string): void;
   assertDefined(
-    node: NodeData | undefined,
-  ): asserts node is NonNullable<NodeData> & void;
+    data: ExecutableData | undefined,
+  ): asserts data is NonNullable<ExecutableData> & void;
   assert(
     validationPredicate: () => boolean,
     errorMessage: string,
@@ -19,14 +19,14 @@ export interface NodeDataValidator {
   createContextualErrorMessage(errorMessage: string): string;
 }
 
-export const createNodeDataValidator
-: NodeDataValidatorFactory = (context) => new ContextualNodeDataValidator(context);
+export const createExecutableDataValidator
+: ExecutableValidatorFactory = (context) => new ContextualExecutableValidator(context);
 
-export class ContextualNodeDataValidator implements NodeDataValidator {
+export class ContextualExecutableValidator implements ExecutableValidator {
   constructor(
-    private readonly context: NodeDataErrorContext,
+    private readonly context: ExecutableErrorContext,
     private readonly createErrorMessage
-    : NodeContextErrorMessageCreator = createNodeContextErrorMessage,
+    : ExecutableContextErrorMessageCreator = createExecutableContextErrorMessage,
   ) {
 
   }
@@ -40,11 +40,11 @@ export class ContextualNodeDataValidator implements NodeDataValidator {
   }
 
   public assertDefined(
-    node: NodeData,
-  ): asserts node is NonNullable<NodeData> {
+    data: ExecutableData,
+  ): asserts data is NonNullable<ExecutableData> {
     this.assert(
-      () => node !== undefined && node !== null && Object.keys(node).length > 0,
-      'missing node data',
+      () => data !== undefined && data !== null && Object.keys(data).length > 0,
+      'missing executable data',
     );
   }
 

src/application/Parser/NodeValidation/NodeData.ts

@@ -1,3 +0,0 @@
-import type { ScriptData, CategoryData } from '@/application/collections/';
-
-export type NodeData = CategoryData | ScriptData;

src/application/Parser/NodeValidation/NodeDataErrorContext.ts

@@ -1,25 +0,0 @@
-import type { CategoryData, ScriptData } from '@/application/collections/';
-import { NodeDataType } from './NodeDataType';
-import type { NodeData } from './NodeData';
-
-export type NodeDataErrorContext = {
-  readonly parentNode?: CategoryData;
-} & (CategoryNodeErrorContext | ScriptNodeErrorContext | UnknownNodeErrorContext);
-
-export type CategoryNodeErrorContext = {
-  readonly type: NodeDataType.Category;
-  readonly selfNode: CategoryData;
-  readonly parentNode?: CategoryData;
-};
-
-export type ScriptNodeErrorContext = {
-  readonly type: NodeDataType.Script;
-  readonly selfNode: ScriptData;
-  readonly parentNode?: CategoryData;
-};
-
-export type UnknownNodeErrorContext = {
-  readonly type?: undefined;
-  readonly selfNode: NodeData;
-  readonly parentNode?: CategoryData;
-};

src/application/Parser/NodeValidation/NodeDataErrorContextMessage.ts

@@ -1,35 +0,0 @@
-import { NodeDataType } from './NodeDataType';
-import type { NodeDataErrorContext } from './NodeDataErrorContext';
-import type { NodeData } from './NodeData';
-
-export interface NodeContextErrorMessageCreator {
-  (
-    errorMessage: string,
-    context: NodeDataErrorContext,
-  ): string;
-}
-
-export const createNodeContextErrorMessage: NodeContextErrorMessageCreator = (
-  errorMessage,
-  context,
-) => {
-  let message = '';
-  if (context.type !== undefined) {
-    message += `${NodeDataType[context.type]}: `;
-  }
-  message += errorMessage;
-  message += `\n${getErrorContextDetails(context)}`;
-  return message;
-};
-
-function getErrorContextDetails(context: NodeDataErrorContext): string {
-  let output = `Self: ${printNodeDataAsJson(context.selfNode)}`;
-  if (context.parentNode) {
-    output += `\nParent: ${printNodeDataAsJson(context.parentNode)}`;
-  }
-  return output;
-}
-
-function printNodeDataAsJson(node: NodeData): string {
-  return JSON.stringify(node, undefined, 2);
-}

src/application/Parser/NodeValidation/NodeDataType.ts

@@ -1,4 +0,0 @@
-export enum NodeDataType {
-  Script,
-  Category,
-}

src/application/Parser/Script/CategoryCollectionParseContext.ts

@@ -1,23 +0,0 @@
-import type { FunctionData } from '@/application/collections/';
-import type { IScriptingDefinition } from '@/domain/IScriptingDefinition';
-import { ScriptCompiler } from './Compiler/ScriptCompiler';
-import { SyntaxFactory } from './Validation/Syntax/SyntaxFactory';
-import type { ILanguageSyntax } from './Validation/Syntax/ILanguageSyntax';
-import type { IScriptCompiler } from './Compiler/IScriptCompiler';
-import type { ICategoryCollectionParseContext } from './ICategoryCollectionParseContext';
-import type { ISyntaxFactory } from './Validation/Syntax/ISyntaxFactory';
-
-export class CategoryCollectionParseContext implements ICategoryCollectionParseContext {
-  public readonly compiler: IScriptCompiler;
-
-  public readonly syntax: ILanguageSyntax;
-
-  constructor(
-    functionsData: ReadonlyArray<FunctionData> | undefined,
-    scripting: IScriptingDefinition,
-    syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
-  ) {
-    this.syntax = syntaxFactory.create(scripting.language);
-    this.compiler = new ScriptCompiler(functionsData ?? [], this.syntax);
-  }
-}

src/application/Parser/Script/ICategoryCollectionParseContext.ts

@@ -1,7 +0,0 @@
-import type { IScriptCompiler } from './Compiler/IScriptCompiler';
-import type { ILanguageSyntax } from './Validation/Syntax/ILanguageSyntax';
-
-export interface ICategoryCollectionParseContext {
-  readonly compiler: IScriptCompiler;
-  readonly syntax: ILanguageSyntax;
-}

src/application/Parser/ScriptingDefinition/CodeSubstituter.ts

@@ -1,11 +1,11 @@
-import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import { ParameterSubstitutionParser } from '@/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser';
-import { CompositeExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser';
-import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
+import type { IExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/IExpressionsCompiler';
+import { ParameterSubstitutionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser';
+import { CompositeExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/CompositeExpressionParser';
+import { ExpressionsCompiler } from '@/application/Parser/Executable/Script/Compiler/Expressions/ExpressionsCompiler';
 import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
-import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
-import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { FunctionCallArgumentCollection } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
+import { FunctionCallArgument } from '@/application/Parser/Executable/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import type { IExpressionParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/Parser/IExpressionParser';
 import type { ICodeSubstituter } from './ICodeSubstituter';
 
 export class CodeSubstituter implements ICodeSubstituter {