refactor extra code, duplicates, complexity

- refactor array equality check and add tests
- remove OperatingSystem.Unknown causing extra logic, return undefined instead
- refactor enum validation to share same logic
- refactor scripting language factories to share same logic
- refactor too many args in runCodeAsync
- refactor ScriptCode constructor to reduce complexity
- fix writing useless write to member object since another property write always override it

src/application/Common/Array.ts

@@ -0,0 +1,21 @@
+// Compares to Array<T> objects for equality, ignoring order
+export function scrambledEqual<T>(array1: readonly T[], array2: readonly T[]) {
+    if (!array1) { throw new Error('undefined first array'); }
+    if (!array2) { throw new Error('undefined second array'); }
+    const sortedArray1 = sort(array1);
+    const sortedArray2 = sort(array2);
+    return sequenceEqual(sortedArray1, sortedArray2);
+    function sort(array: readonly T[]) {
+        return array.slice().sort();
+    }
+}
+
+// Compares to Array<T> objects for equality in same order
+export function sequenceEqual<T>(array1: readonly T[], array2: readonly T[]) {
+    if (!array1) { throw new Error('undefined first array'); }
+    if (!array2) { throw new Error('undefined second array'); }
+    if (array1.length !== array2.length) {
+        return false;
+    }
+    return array1.every((val, index) => val === array2[index]);
+}

src/application/Common/Enum.ts

@@ -1,6 +1,6 @@
 // Because we cannot do "T extends enum" 😞 https://github.com/microsoft/TypeScript/issues/30611
-type EnumType = number | string;
-type EnumVariable<T extends EnumType, TEnumValue extends EnumType> = { [key in T]: TEnumValue };
+export type EnumType = number | string;
+export type EnumVariable<T extends EnumType, TEnumValue extends EnumType> = { [key in T]: TEnumValue };
 
 export interface IEnumParser<TEnum> {
     parseEnum(value: string, propertyName: string): TEnum;
@@ -41,3 +41,14 @@ export function getEnumValues<T extends EnumType, TEnumValue extends EnumType>(
     return getEnumNames(enumVariable)
         .map((level) => enumVariable[level]) as TEnumValue[];
 }
+
+export function assertInRange<T extends EnumType, TEnumValue extends EnumType>(
+    value: TEnumValue,
+    enumVariable: EnumVariable<T, TEnumValue>) {
+    if (value === undefined) {
+        throw new Error('undefined enum value');
+    }
+    if (!(value in enumVariable)) {
+        throw new RangeError(`enum value "${value}" is out of range`);
+    }
+}

src/application/Common/ScriptingLanguage/IScriptingLanguageFactory.ts

@@ -0,0 +1,5 @@
+import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+
+export interface IScriptingLanguageFactory<T> {
+    create(language: ScriptingLanguage): T;
+}

src/application/Common/ScriptingLanguage/ScriptingLanguageFactory.ts

@@ -0,0 +1,31 @@
+import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+import { IScriptingLanguageFactory } from './IScriptingLanguageFactory';
+import { assertInRange } from '@/application/Common/Enum';
+
+type Getter<T> = () => T;
+
+export abstract class ScriptingLanguageFactory<T> implements IScriptingLanguageFactory<T> {
+    private readonly getters = new Map<ScriptingLanguage, Getter<T>>();
+
+    public create(language: ScriptingLanguage): T {
+        assertInRange(language, ScriptingLanguage);
+        if (!this.getters.has(language)) {
+            throw new RangeError(`unknown language: "${ScriptingLanguage[language]}"`);
+        }
+        const getter = this.getters.get(language);
+        const instance = getter();
+        return instance;
+    }
+
+    protected registerGetter(language: ScriptingLanguage, getter: Getter<T>) {
+        assertInRange(language, ScriptingLanguage);
+        if (!getter)  {
+            throw new Error('undefined getter');
+        }
+        if (this.getters.has(language)) {
+            throw new Error(`${ScriptingLanguage[language]} is already registered`);
+        }
+        this.getters.set(language, getter);
+    }
+
+}