MapComplete/Models/ThemeConfig/Conversion/PrepareLayer.ts

import {
    Concat,
    Conversion,
    DesugaringContext,
    DesugaringStep,
    Each,
    FirstOf,
    Fuse,
    On,
    SetDefault,
} from "./Conversion"
import { LayerConfigJson } from "../Json/LayerConfigJson"
import { TagRenderingConfigJson } from "../Json/TagRenderingConfigJson"
import { Utils } from "../../../Utils"
import RewritableConfigJson from "../Json/RewritableConfigJson"
import SpecialVisualizations from "../../../UI/SpecialVisualizations"
import Translations from "../../../UI/i18n/Translations"
import { Translation } from "../../../UI/i18n/Translation"
import * as tagrenderingconfigmeta from "../../../assets/tagrenderingconfigmeta.json"
import { AddContextToTranslations } from "./AddContextToTranslations"
import FilterConfigJson from "../Json/FilterConfigJson"
import * as predifined_filters from "../../../assets/layers/filters/filters.json"

class ExpandFilter extends DesugaringStep<LayerConfigJson> {
    private static load_filters(): Map<string, FilterConfigJson> {
        let filters = new Map<string, FilterConfigJson>()
        for (const filter of <FilterConfigJson[]>predifined_filters.filter) {
            filters.set(filter.id, filter)
        }
        return filters
    }

    private static readonly predefinedFilters = ExpandFilter.load_filters()

    constructor() {
        super(
            "Expands filters: replaces a shorthand by the value found in 'filters.json'",
            ["filter"],
            "ExpandFilter"
        )
    }

    convert(
        json: LayerConfigJson,
        context: string
    ): { result: LayerConfigJson; errors?: string[]; warnings?: string[]; information?: string[] } {
        if (json.filter === undefined || json.filter === null) {
            return { result: json } // Nothing to change here
        }

        if (json.filter["sameAs"] !== undefined) {
            return { result: json } // Nothing to change here
        }

        const newFilters: FilterConfigJson[] = []
        const errors: string[] = []
        for (const filter of <(FilterConfigJson | string)[]>json.filter) {
            if (typeof filter !== "string") {
                newFilters.push(filter)
                continue
            }
            // Search for the filter:
            const found = ExpandFilter.predefinedFilters.get(filter)
            if (found === undefined) {
                const suggestions = Utils.sortedByLevenshteinDistance(
                    filter,
                    Array.from(ExpandFilter.predefinedFilters.keys()),
                    (t) => t
                )
                const err =
                    context +
                    ".filter: while searching for predifined filter " +
                    filter +
                    ": this filter is not found. Perhaps you meant one of: " +
                    suggestions
                errors.push(err)
            }
            newFilters.push(found)
        }
        return {
            result: {
                ...json,
                filter: newFilters,
            },
            errors,
        }
    }
}

class ExpandTagRendering extends Conversion<
    string | TagRenderingConfigJson | { builtin: string | string[]; override: any },
    TagRenderingConfigJson[]
> {
    private readonly _state: DesugaringContext
    private readonly _self: LayerConfigJson
    private readonly _options: {
        /* If true, will copy the 'osmSource'-tags into the condition */
        applyCondition?: true | boolean
    }

    constructor(
        state: DesugaringContext,
        self: LayerConfigJson,
        options?: { applyCondition?: true | boolean }
    ) {
        super(
            "Converts a tagRenderingSpec into the full tagRendering, e.g. by substituting the tagRendering by the shared-question",
            [],
            "ExpandTagRendering"
        )
        this._state = state
        this._self = self
        this._options = options
    }

    convert(
        json: string | TagRenderingConfigJson | { builtin: string | string[]; override: any },
        context: string
    ): { result: TagRenderingConfigJson[]; errors: string[]; warnings: string[] } {
        const errors = []
        const warnings = []

        return {
            result: this.convertUntilStable(json, warnings, errors, context),
            errors,
            warnings,
        }
    }

    private lookup(name: string): TagRenderingConfigJson[] {
        const state = this._state
        if (state.tagRenderings.has(name)) {
            return [state.tagRenderings.get(name)]
        }
        if (name.indexOf(".") < 0) {
            return undefined
        }

        const spl = name.split(".")
        let layer = state.sharedLayers.get(spl[0])
        if (spl[0] === this._self.id) {
            layer = this._self
        }

        if (spl.length !== 2 || layer === undefined) {
            return undefined
        }

        const id = spl[1]

        const layerTrs = <TagRenderingConfigJson[]>(
            layer.tagRenderings.filter((tr) => tr["id"] !== undefined)
        )
        let matchingTrs: TagRenderingConfigJson[]
        if (id === "*") {
            matchingTrs = layerTrs
        } else if (id.startsWith("*")) {
            const id_ = id.substring(1)
            matchingTrs = layerTrs.filter((tr) => tr.group === id_ || tr.labels?.indexOf(id_) >= 0)
        } else {
            matchingTrs = layerTrs.filter((tr) => tr.id === id)
        }

        const contextWriter = new AddContextToTranslations<TagRenderingConfigJson>("layers:")
        for (let i = 0; i < matchingTrs.length; i++) {
            let found: TagRenderingConfigJson = Utils.Clone(matchingTrs[i])
            if (this._options?.applyCondition) {
                // The matched tagRenderings are 'stolen' from another layer. This means that they must match the layer condition before being shown
                if (found.condition === undefined) {
                    found.condition = layer.source.osmTags
                } else {
                    found.condition = { and: [found.condition, layer.source.osmTags] }
                }
            }

            found = contextWriter.convertStrict(found, layer.id + ".tagRenderings." + found["id"])
            matchingTrs[i] = found
        }

        if (matchingTrs.length !== 0) {
            return matchingTrs
        }
        return undefined
    }

    private convertOnce(
        tr: string | any,
        warnings: string[],
        errors: string[],
        ctx: string
    ): TagRenderingConfigJson[] {
        const state = this._state
        if (tr === "questions") {
            return [
                {
                    id: "questions",
                },
            ]
        }

        if (typeof tr === "string") {
            const lookup = this.lookup(tr)
            if (lookup === undefined) {
                const isTagRendering = ctx.indexOf("On(mapRendering") < 0
                if (isTagRendering) {
                    warnings.push(ctx + "A literal rendering was detected: " + tr)
                }
                return [
                    {
                        render: tr,
                        id: tr.replace(/[^a-zA-Z0-9]/g, ""),
                    },
                ]
            }
            return lookup
        }

        if (tr["builtin"] !== undefined) {
            let names: string | string[] = tr["builtin"]
            if (typeof names === "string") {
                names = [names]
            }

            for (const key of Object.keys(tr)) {
                if (
                    key === "builtin" ||
                    key === "override" ||
                    key === "id" ||
                    key.startsWith("#")
                ) {
                    continue
                }
                errors.push(
                    "At " +
                        ctx +
                        ": an object calling a builtin can only have keys `builtin` or `override`, but a key with name `" +
                        key +
                        "` was found. This won't be picked up! The full object is: " +
                        JSON.stringify(tr)
                )
            }

            const trs: TagRenderingConfigJson[] = []
            for (const name of names) {
                const lookup = this.lookup(name)
                if (lookup === undefined) {
                    let candidates = Array.from(state.tagRenderings.keys())
                    if (name.indexOf(".") > 0) {
                        const [layerName] = name.split(".")
                        let layer = state.sharedLayers.get(layerName)
                        if (layerName === this._self.id) {
                            layer = this._self
                        }
                        if (layer === undefined) {
                            const candidates = Utils.sortedByLevenshteinDistance(
                                layerName,
                                Array.from(state.sharedLayers.keys()),
                                (s) => s
                            )
                            if (state.sharedLayers.size === 0) {
                                warnings.push(
                                    ctx +
                                        ": BOOTSTRAPPING. Rerun generate layeroverview. While reusing tagrendering: " +
                                        name +
                                        ": layer " +
                                        layerName +
                                        " not found. Maybe you meant on of " +
                                        candidates.slice(0, 3).join(", ")
                                )
                            } else {
                                errors.push(
                                    ctx +
                                        ": While reusing tagrendering: " +
                                        name +
                                        ": layer " +
                                        layerName +
                                        " not found. Maybe you meant on of " +
                                        candidates.slice(0, 3).join(", ")
                                )
                            }
                            continue
                        }
                        candidates = Utils.NoNull(layer.tagRenderings.map((tr) => tr["id"])).map(
                            (id) => layerName + "." + id
                        )
                    }
                    candidates = Utils.sortedByLevenshteinDistance(name, candidates, (i) => i)
                    errors.push(
                        ctx +
                            ": The tagRendering with identifier " +
                            name +
                            " was not found.\n\tDid you mean one of " +
                            candidates.join(", ") +
                            "?\n(Hint: did you add a new label and are you trying to use this label at the same time? Run 'reset:layeroverview' first"
                    )
                    continue
                }
                for (let foundTr of lookup) {
                    foundTr = Utils.Clone<any>(foundTr)
                    Utils.Merge(tr["override"] ?? {}, foundTr)
                    trs.push(foundTr)
                }
            }
            return trs
        }

        return [tr]
    }

    private convertUntilStable(
        spec: string | any,
        warnings: string[],
        errors: string[],
        ctx: string
    ): TagRenderingConfigJson[] {
        const trs = this.convertOnce(spec, warnings, errors, ctx)

        const result = []
        for (const tr of trs) {
            if (typeof tr === "string" || tr["builtin"] !== undefined) {
                const stable = this.convertUntilStable(
                    tr,
                    warnings,
                    errors,
                    ctx + "(RECURSIVE RESOLVE)"
                )
                result.push(...stable)
            } else {
                result.push(tr)
            }
        }

        return result
    }
}

export class ExpandRewrite<T> extends Conversion<T | RewritableConfigJson<T>, T[]> {
    constructor() {
        super("Applies a rewrite", [], "ExpandRewrite")
    }

    /**
     * Used for left|right group creation and replacement.
     * Every 'keyToRewrite' will be replaced with 'target' recursively. This substitution will happen in place in the object 'tr'
     *
     * // should substitute strings
     * const spec = {
     *   "someKey": "somevalue {xyz}"
     * }
     * ExpandRewrite.RewriteParts("{xyz}", "rewritten", spec) // => {"someKey": "somevalue rewritten"}
     *
     * // should substitute all occurances in strings
     * const spec = {
     *   "someKey": "The left|right side has {key:left|right}"
     * }
     * ExpandRewrite.RewriteParts("left|right", "left", spec) // => {"someKey": "The left side has {key:left}"}
     *
     */
    public static RewriteParts<T>(keyToRewrite: string, target: string | any, tr: T): T {
        const targetIsTranslation = Translations.isProbablyATranslation(target)

        function replaceRecursive(obj: string | any, target) {
            if (obj === keyToRewrite) {
                return target
            }

            if (typeof obj === "string") {
                // This is a simple string - we do a simple replace
                while (obj.indexOf(keyToRewrite) >= 0) {
                    obj = obj.replace(keyToRewrite, target)
                }
                return obj
            }
            if (Array.isArray(obj)) {
                // This is a list of items
                return obj.map((o) => replaceRecursive(o, target))
            }

            if (typeof obj === "object") {
                obj = { ...obj }

                const isTr = targetIsTranslation && Translations.isProbablyATranslation(obj)

                for (const key in obj) {
                    let subtarget = target
                    if (isTr && target[key] !== undefined) {
                        // The target is a translation AND the current object is a translation
                        // This means we should recursively replace with the translated value
                        subtarget = target[key]
                    }

                    obj[key] = replaceRecursive(obj[key], subtarget)
                }
                return obj
            }
            return obj
        }

        return replaceRecursive(tr, target)
    }

    /**
     * // should convert simple strings
     * const spec = <RewritableConfigJson<string>>{
     *     rewrite: {
     *         sourceString: ["xyz","abc"],
     *         into: [
     *             ["X", "A"],
     *             ["Y", "B"],
     *             ["Z", "C"]],
     *     },
     *     renderings: "The value of xyz is abc"
     * }
     * new ExpandRewrite().convertStrict(spec, "test") // => ["The value of X is A", "The value of Y is B", "The value of Z is C"]
     *
     * // should rewrite with translations
     * const spec = <RewritableConfigJson<any>>{
     *     rewrite: {
     *         sourceString: ["xyz","abc"],
     *         into: [
     *             ["X", {en: "value", nl: "waarde"}],
     *             ["Y", {en: "some other value", nl: "een andere waarde"}],
     *     },
     *     renderings: {en: "The value of xyz is abc", nl: "De waarde van xyz is abc"}
     * }
     * const expected = [
     *  {
     *      en: "The value of X is value",
     *      nl: "De waarde van X is waarde"
     *  },
     *  {
     *      en: "The value of Y is some other value",
     *      nl: "De waarde van Y is een andere waarde"
     *  }
     * ]
     * new ExpandRewrite().convertStrict(spec, "test") // => expected
     */
    convert(
        json: T | RewritableConfigJson<T>,
        context: string
    ): { result: T[]; errors?: string[]; warnings?: string[]; information?: string[] } {
        if (json === null || json === undefined) {
            return { result: [] }
        }

        if (json["rewrite"] === undefined) {
            // not a rewrite
            return { result: [<T>json] }
        }

        const rewrite = <RewritableConfigJson<T>>json
        const keysToRewrite = rewrite.rewrite
        const ts: T[] = []

        {
            // sanity check: rewrite: ["xyz", "longer_xyz"] is not allowed as "longer_xyz" will never be triggered
            for (let i = 0; i < keysToRewrite.sourceString.length; i++) {
                const guard = keysToRewrite.sourceString[i]
                for (let j = i + 1; j < keysToRewrite.sourceString.length; j++) {
                    const toRewrite = keysToRewrite.sourceString[j]
                    if (toRewrite.indexOf(guard) >= 0) {
                        throw `${context} Error in rewrite: sourcestring[${i}] is a substring of sourcestring[${j}]: ${guard} will be substituted away before ${toRewrite} is reached.`
                    }
                }
            }
        }

        {
            // sanity check: {rewrite: ["a", "b"] should have the right amount of 'intos' in every case
            for (let i = 0; i < rewrite.rewrite.into.length; i++) {
                const into = keysToRewrite.into[i]
                if (into.length !== rewrite.rewrite.sourceString.length) {
                    throw `${context}.into.${i} Error in rewrite: there are ${rewrite.rewrite.sourceString.length} keys to rewrite, but entry ${i} has only ${into.length} values`
                }
            }
        }

        for (let i = 0; i < keysToRewrite.into.length; i++) {
            let t = Utils.Clone(rewrite.renderings)
            for (let j = 0; j < keysToRewrite.sourceString.length; j++) {
                const key = keysToRewrite.sourceString[j]
                const target = keysToRewrite.into[i][j]
                t = ExpandRewrite.RewriteParts(key, target, t)
            }
            ts.push(t)
        }

        return { result: ts }
    }
}

/**
 * Converts a 'special' translation into a regular translation which uses parameters
 */
export class RewriteSpecial extends DesugaringStep<TagRenderingConfigJson> {
    constructor() {
        super(
            "Converts a 'special' translation into a regular translation which uses parameters",
            ["special"],
            "RewriteSpecial"
        )
    }

    /**
     * Does the heavy lifting and conversion
     *
     * // should not do anything if no 'special'-key is present
     * RewriteSpecial.convertIfNeeded({"en": "xyz", "nl": "abc"}, [], "test") // => {"en": "xyz", "nl": "abc"}
     *
     * // should handle a simple special case
     * RewriteSpecial.convertIfNeeded({"special": {"type":"image_carousel"}}, [], "test") // => {'*': "{image_carousel()}"}
     *
     * // should handle special case with a parameter
     * RewriteSpecial.convertIfNeeded({"special": {"type":"image_carousel", "image_key": "some_image_key"}}, [], "test") // =>  {'*': "{image_carousel(some_image_key)}"}
     *
     * // should handle special case with a translated parameter
     * const spec = {"special": {"type":"image_upload", "label": {"en": "Add a picture to this object", "nl": "Voeg een afbeelding toe"}}}
     * const r = RewriteSpecial.convertIfNeeded(spec, [], "test")
     * r // => {"en": "{image_upload(,Add a picture to this object)}", "nl": "{image_upload(,Voeg een afbeelding toe)}" }
     *
     * // should handle special case with a prefix and postfix
     * const spec = {"special": {"type":"image_upload" }, before: {"en": "PREFIX "}, after: {"en": " POSTFIX", nl: " Achtervoegsel"} }
     * const r = RewriteSpecial.convertIfNeeded(spec, [], "test")
     * r // => {"en": "PREFIX {image_upload(,)} POSTFIX", "nl": "PREFIX {image_upload(,)} Achtervoegsel" }
     *
     * // should warn for unexpected keys
     * const errors = []
     * RewriteSpecial.convertIfNeeded({"special": {type: "image_carousel"}, "en": "xyz"}, errors, "test") // =>  {'*': "{image_carousel()}"}
     * errors // => ["At test: The only keys allowed next to a 'special'-block are 'before' and 'after'. Perhaps you meant to put 'en' into the special block?"]
     *
     * // should give an error on unknown visualisations
     * const errors = []
     * RewriteSpecial.convertIfNeeded({"special": {type: "qsdf"}}, errors, "test") // => undefined
     * errors.length // => 1
     * errors[0].indexOf("Special visualisation 'qsdf' not found") >= 0 // => true
     *
     * // should give an error is 'type' is missing
     * const errors = []
     * RewriteSpecial.convertIfNeeded({"special": {}}, errors, "test") // => undefined
     * errors // => ["A 'special'-block should define 'type' to indicate which visualisation should be used"]
     *
     *
     * // an actual test
     * const special = {
     *     "before": {
     *             "en": "<h3>Entrances</h3>This building has {_entrances_count} entrances:"
     *           },
     *     "after": {
     *             "en": "{_entrances_count_without_width_count} entrances don't have width information yet"
     *           },
     *     "special": {
     *           "type": "multi",
     *           "key": "_entrance_properties_with_width",
     *           "tagrendering": {
     *             "en": "An <a href='#{id}'>entrance</a> of {canonical(width)}"
     *           }
     *         }}
     * const errors = []
     * RewriteSpecial.convertIfNeeded(special, errors, "test") // => {"en": "<h3>Entrances</h3>This building has {_entrances_count} entrances:{multi(_entrance_properties_with_width,An <a href='#&LBRACEid&RBRACE'>entrance</a> of &LBRACEcanonical&LPARENSwidth&RPARENS&RBRACE)}{_entrances_count_without_width_count} entrances don't have width information yet"}
     * errors // => []
     */
    private static convertIfNeeded(
        input: (object & { special: { type: string } }) | any,
        errors: string[],
        context: string
    ): any {
        const special = input["special"]
        if (special === undefined) {
            return input
        }

        const type = special["type"]
        if (type === undefined) {
            errors.push(
                "A 'special'-block should define 'type' to indicate which visualisation should be used"
            )
            return undefined
        }

        const vis = SpecialVisualizations.specialVisualizations.find((sp) => sp.funcName === type)
        if (vis === undefined) {
            const options = Utils.sortedByLevenshteinDistance(
                type,
                SpecialVisualizations.specialVisualizations,
                (sp) => sp.funcName
            )
            errors.push(
                `Special visualisation '${type}' not found. Did you perhaps mean ${options[0].funcName}, ${options[1].funcName} or ${options[2].funcName}?\n\tFor all known special visualisations, please see https://github.com/pietervdvn/MapComplete/blob/develop/Docs/SpecialRenderings.md`
            )
            return undefined
        }
        errors.push(
            ...Array.from(Object.keys(input))
                .filter((k) => k !== "special" && k !== "before" && k !== "after")
                .map((k) => {
                    return `At ${context}: The only keys allowed next to a 'special'-block are 'before' and 'after'. Perhaps you meant to put '${k}' into the special block?`
                })
        )

        const argNamesList = vis.args.map((a) => a.name)
        const argNames = new Set<string>(argNamesList)
        // Check for obsolete and misspelled arguments
        errors.push(
            ...Object.keys(special)
                .filter((k) => !argNames.has(k))
                .filter((k) => k !== "type" && k !== "before" && k !== "after")
                .map((wrongArg) => {
                    const byDistance = Utils.sortedByLevenshteinDistance(
                        wrongArg,
                        argNamesList,
                        (x) => x
                    )
                    return `At ${context}: Unexpected argument in special block at ${context} with name '${wrongArg}'. Did you mean ${
                        byDistance[0]
                    }?\n\tAll known arguments are ${argNamesList.join(", ")}`
                })
        )

        // Check that all obligated arguments are present. They are obligated if they don't have a preset value
        for (const arg of vis.args) {
            if (arg.required !== true) {
                continue
            }
            const param = special[arg.name]
            if (param === undefined) {
                errors.push(
                    `At ${context}: Obligated parameter '${arg.name}' in special rendering of type ${vis.funcName} not found.\n${arg.doc}`
                )
            }
        }

        const foundLanguages = new Set<string>()
        const translatedArgs = argNamesList
            .map((nm) => special[nm])
            .filter((v) => v !== undefined)
            .filter((v) => Translations.isProbablyATranslation(v))
        for (const translatedArg of translatedArgs) {
            for (const ln of Object.keys(translatedArg)) {
                foundLanguages.add(ln)
            }
        }

        const before = Translations.T(input.before)
        const after = Translations.T(input.after)

        for (const ln of Object.keys(before?.translations ?? {})) {
            foundLanguages.add(ln)
        }
        for (const ln of Object.keys(after?.translations ?? {})) {
            foundLanguages.add(ln)
        }

        if (foundLanguages.size === 0) {
            const args = argNamesList.map((nm) => special[nm] ?? "").join(",")
            return {
                "*": `{${type}(${args})}`,
            }
        }

        const result = {}
        const languages = Array.from(foundLanguages)
        languages.sort()
        for (const ln of languages) {
            const args = []
            for (const argName of argNamesList) {
                let v = special[argName] ?? ""
                if (Translations.isProbablyATranslation(v)) {
                    v = new Translation(v).textFor(ln)
                }

                if (typeof v === "string") {
                    const txt = v
                        .replace(/,/g, "&COMMA")
                        .replace(/\{/g, "&LBRACE")
                        .replace(/}/g, "&RBRACE")
                        .replace(/\(/g, "&LPARENS")
                        .replace(/\)/g, "&RPARENS")
                    args.push(txt)
                } else if (typeof v === "object") {
                    args.push(JSON.stringify(v))
                } else {
                    args.push(v)
                }
            }
            const beforeText = before?.textFor(ln) ?? ""
            const afterText = after?.textFor(ln) ?? ""
            result[ln] = `${beforeText}{${type}(${args.map((a) => a).join(",")})}${afterText}`
        }
        return result
    }

    /**
     * const tr = {
     *     render: {special: {type: "image_carousel", image_key: "image" }},
     *     mappings: [
     *         {
     *             if: "other_image_key",
     *             then: {special: {type: "image_carousel", image_key: "other_image_key"}}
     *         }
     *     ]
     * }
     * const result = new RewriteSpecial().convert(tr,"test").result
     * const expected = {render:  {'*': "{image_carousel(image)}"}, mappings: [{if: "other_image_key", then:  {'*': "{image_carousel(other_image_key)}"}} ]}
     * result // => expected
     *
     * // Should put text before if specified
     * const tr = {
     *     render: {special: {type: "image_carousel", image_key: "image"}, before: {en: "Some introduction"} },
     * }
     * const result = new RewriteSpecial().convert(tr,"test").result
     * const expected = {render:  {'en': "Some introduction{image_carousel(image)}"}}
     * result // => expected
     *
     * // Should put text after if specified
     * const tr = {
     *     render: {special: {type: "image_carousel", image_key: "image"}, after: {en: "Some footer"} },
     * }
     * const result = new RewriteSpecial().convert(tr,"test").result
     * const expected = {render:  {'en': "{image_carousel(image)}Some footer"}}
     * result // => expected
     */
    convert(
        json: TagRenderingConfigJson,
        context: string
    ): {
        result: TagRenderingConfigJson
        errors?: string[]
        warnings?: string[]
        information?: string[]
    } {
        const errors = []
        json = Utils.Clone(json)
        const paths: { path: string[]; type?: any; typeHint?: string }[] =
            tagrenderingconfigmeta["default"] ?? tagrenderingconfigmeta
        for (const path of paths) {
            if (path.typeHint !== "rendered") {
                continue
            }
            Utils.WalkPath(path.path, json, (leaf, travelled) =>
                RewriteSpecial.convertIfNeeded(leaf, errors, context + ":" + travelled.join("."))
            )
        }

        return {
            result: json,
            errors,
        }
    }
}

export class PrepareLayer extends Fuse<LayerConfigJson> {
    constructor(state: DesugaringContext) {
        super(
            "Fully prepares and expands a layer for the LayerConfig.",
            new On("tagRenderings", new Each(new RewriteSpecial())),
            new On("tagRenderings", new Concat(new ExpandRewrite()).andThenF(Utils.Flatten)),
            new On("tagRenderings", (layer) => new Concat(new ExpandTagRendering(state, layer))),
            new On("mapRendering", new Concat(new ExpandRewrite()).andThenF(Utils.Flatten)),
            new On(
                "mapRendering",
                (layer) =>
                    new Each(
                        new On(
                            "icon",
                            new FirstOf(
                                new ExpandTagRendering(state, layer, { applyCondition: false })
                            )
                        )
                    )
            ),
            new SetDefault("titleIcons", ["defaults"]),
            new On("titleIcons", (layer) => new Concat(new ExpandTagRendering(state, layer))),
            new ExpandFilter()
        )
    }
}