Finish importer, add applicable import layers to every theme by default

Models/ThemeConfig/Conversion/Conversion.ts

@@ -0,0 +1,171 @@
+import {TagRenderingConfigJson} from "../Json/TagRenderingConfigJson";
+import {LayerConfigJson} from "../Json/LayerConfigJson";
+import {Utils} from "../../../Utils";
+
+export interface DesugaringContext {
+    tagRenderings: Map<string, TagRenderingConfigJson>
+    sharedLayers: Map<string, LayerConfigJson>
+}
+
+export abstract class Conversion<TIn, TOut> {
+    public readonly modifiedAttributes: string[];
+    protected readonly doc: string;
+
+    constructor(doc: string, modifiedAttributes: string[] = []) {
+        this.modifiedAttributes = modifiedAttributes;
+        this.doc = doc + "\n\nModified attributes are\n" + modifiedAttributes.join(", ");
+    }
+
+    public static strict<T>(fixed: { errors: string[], warnings: string[], result?: T }): T {
+        if (fixed?.errors?.length > 0) {
+            throw fixed.errors.join("\n");
+        }
+        fixed.warnings?.forEach(w => console.warn(w))
+        return fixed.result;
+    }
+
+    public convertStrict(state: DesugaringContext, json: TIn, context: string): TOut {
+        const fixed = this.convert(state, json, context)
+        return DesugaringStep.strict(fixed)
+    }
+
+    abstract convert(state: DesugaringContext, json: TIn, context: string): { result: TOut, errors: string[], warnings: string[] }
+
+    public convertAll(state: DesugaringContext, jsons: TIn[], context: string): { result: TOut[], errors: string[], warnings: string[] } {
+        const result = []
+        const errors = []
+        const warnings = []
+        for (let i = 0; i < jsons.length; i++) {
+            const json = jsons[i];
+            const r = this.convert(state, json, context + "[" + i + "]")
+            result.push(r.result)
+            errors.push(...r.errors)
+            warnings.push(...r.warnings)
+        }
+        return {
+            result,
+            errors,
+            warnings
+        }
+    }
+
+}
+
+export abstract class DesugaringStep<T> extends Conversion<T, T> {
+}
+
+export class OnEvery<X, T> extends DesugaringStep<T> {
+    private readonly key: string;
+    private readonly step: DesugaringStep<X>;
+
+    constructor(key: string, step: DesugaringStep<X>) {
+        super("Applies " + step.constructor.name + " onto every object of the list `key`", [key]);
+        this.step = step;
+        this.key = key;
+    }
+
+    convert(state: DesugaringContext, json: T, context: string): { result: T; errors: string[]; warnings: string[] } {
+        json = {...json}
+        const step = this.step
+        const key = this.key;
+        const r = step.convertAll(state, (<X[]>json[key]), context + "." + key)
+        json[key] = r.result
+        return {
+            result: json,
+            errors: r.errors,
+            warnings: r.warnings
+        };
+    }
+}
+
+export class OnEveryConcat<X, T> extends DesugaringStep<T> {
+    private readonly key: string;
+    private readonly step: Conversion<X, X[]>;
+
+    constructor(key: string, step: Conversion<X, X[]>) {
+        super(`Applies ${step.constructor.name} onto every object of the list \`${key}\`. The results are concatenated and used as new list`, [key]);
+        this.step = step;
+        this.key = key;
+    }
+
+    convert(state: DesugaringContext, json: T, context: string): { result: T; errors: string[]; warnings: string[] } {
+        json = {...json}
+        const step = this.step
+        const key = this.key;
+        const values = json[key]
+        if (values === undefined) {
+            // Move on - nothing to see here!
+            return {
+                result: json,
+                errors: [],
+                warnings: []
+            }
+        }
+        const r = step.convertAll(state, (<X[]>values), context + "." + key)
+        const vals: X[][] = r.result
+        json[key] = [].concat(...vals)
+        return {
+            result: json,
+            errors: r.errors,
+            warnings: r.warnings
+        };
+
+    }
+}
+
+export class Fuse<T> extends DesugaringStep<T> {
+    private readonly steps: DesugaringStep<T>[];
+
+    constructor(doc: string, ...steps: DesugaringStep<T>[]) {
+        super((doc ?? "") + "This fused pipeline of the following steps: " + steps.map(s => s.constructor.name).join(", "),
+            Utils.Dedup([].concat(...steps.map(step => step.modifiedAttributes)))
+        );
+        this.steps = steps;
+    }
+
+    convert(state: DesugaringContext, json: T, context: string): { result: T; errors: string[]; warnings: string[] } {
+        const errors = []
+        const warnings = []
+        for (let i = 0; i < this.steps.length; i++) {
+            const step = this.steps[i];
+            let r = step.convert(state, json, context + "(fusion " + this.constructor.name + "." + i + ")")
+            errors.push(...r.errors)
+            warnings.push(...r.warnings)
+            json = r.result
+            if (errors.length > 0) {
+                break;
+            }
+        }
+        return {
+            result: json,
+            errors,
+            warnings
+        };
+    }
+
+}
+
+export class SetDefault<T> extends DesugaringStep<T> {
+    private readonly value: any;
+    private readonly key: string;
+    private readonly _overrideEmptyString: boolean;
+
+    constructor(key: string, value: any, overrideEmptyString = false) {
+        super("Sets " + key + " to a default value if undefined");
+        this.key = key;
+        this.value = value;
+        this._overrideEmptyString = overrideEmptyString;
+    }
+
+    convert(state: DesugaringContext, json: T, context: string): { result: T; errors: string[]; warnings: string[] } {
+        if (json[this.key] === undefined || (json[this.key] === "" && this._overrideEmptyString)) {
+            json = {...json}
+            json[this.key] = this.value
+        }
+
+        return {
+            errors: [], warnings: [],
+            result: json
+        };
+    }
+}