@manuth/woltlab-compiler/lib/Compilation/Options/OptionFileCompiler.js

A compiler for generating WoltLab-Package `.tar` Archives and other WoltLab-Package Components

import { XML } from "../../Serialization/XML.js";
import { XMLEditor } from "../../Serialization/XMLEditor.js";
import { ImportFileCompiler } from "../ImportFileCompiler.js";
/**
 * Provides the functionality to compile option-files.
 *
 * @template TInstruction
 * The type of the instruction which can be compiled by this compiler.
 *
 * @template TCategory
 * The type of the option-categories.
 *
 * @template TOption
 * The type of the options.
 */
export class OptionFileCompiler extends ImportFileCompiler {
    /**
     * Initializes a new instance of the {@link OptionFileCompiler `OptionFileCompiler<TInstruction, TCategory, TOption>`} class.
     *
     * @param instruction
     * The instruction to compile.
     */
    constructor(instruction) {
        super(instruction);
        this.LanguageCategory = `${instruction.RootCategory}${instruction.OptionCategory ? `.${instruction.OptionCategory}` : ""}`;
    }
    /**
     * Gets or sets the language-category which contains translations for options.
     */
    get LanguageCategory() {
        return this.languageCategory;
    }
    /**
     * @inheritdoc
     */
    set LanguageCategory(value) {
        this.languageCategory = value;
    }
    /**
     * @inheritdoc
     *
     * @returns
     * The serialized import.
     */
    CreateImport() {
        let editor = new XMLEditor(super.CreateImport());
        let categoriesElement = editor.CreateElement("categories");
        let optionsElement = editor.CreateElement("options");
        editor.Add(categoriesElement);
        editor.Add(optionsElement);
        for (let rootCategory of this.Item.Nodes) {
            for (let category of rootCategory.GetAllNodes()) {
                categoriesElement.Add(this.CreateCategory(category));
            }
        }
        for (let rootCategory of this.Item.Nodes) {
            for (let category of rootCategory.GetAllNodes()) {
                if (category.Item) {
                    for (let option of category.Item.Options) {
                        optionsElement.Add(this.CreateOption(option));
                    }
                }
            }
        }
        return editor.Element;
    }
    /**
     * @inheritdoc
     *
     * @returns
     * The serialized deletion.
     */
    CreateDelete() {
        let editor = new XMLEditor(super.CreateDelete());
        for (let categoryToDelete of this.Item.CategoriesToDelete) {
            let categoryElement = editor.CreateElement("category");
            editor.Add(categoryElement);
            categoryElement.SetAttribute("name", categoryToDelete.Name);
        }
        for (let optionToDelete of this.Item.OptionsToDelete) {
            let optionElement = editor.CreateElement("option");
            editor.Add(optionElement);
            optionElement.SetAttribute("name", optionToDelete.Name);
        }
        return editor.Element;
    }
    /**
     * Serializes a category to xml.
     *
     * @param category
     * The category to serialize.
     *
     * @returns
     * The serialized category.
     */
    CreateCategory(category) {
        var _a, _b;
        let document = XML.CreateDocument("category");
        let editor = new XMLEditor(document.documentElement);
        editor.SetAttribute("name", category.FullName);
        if (category.Parent) {
            editor.Add(editor.CreateTextElement("parent", category.Parent.FullName));
        }
        if ((_a = category.Item) === null || _a === void 0 ? void 0 : _a.ShowOrder) {
            editor.Add(editor.CreateTextElement("showorder", category.Item.ShowOrder.toString()));
        }
        if (((_b = category.Item) === null || _b === void 0 ? void 0 : _b.EnableOptions.length) > 0) {
            editor.Add(editor.CreateTextElement("options", category.Item.EnableOptions.join(",")));
        }
        return editor.Element;
    }
    /**
     * Serializes an option to xml.
     *
     * @param option
     * The option to serialize.
     *
     * @returns
     * The serialized option.
     */
    CreateOption(option) {
        let document = XML.CreateDocument("option");
        let editor = new XMLEditor(document.documentElement);
        editor.SetAttribute("name", option.Name);
        editor.Add(editor.CreateTextElement("categoryname", option.Category.Node.FullName));
        editor.Add(editor.CreateTextElement("optiontype", option.Type));
        if (option.DefaultValue) {
            editor.Add(editor.CreateTextElement("defaultvalue", `${option.DefaultValue}`));
        }
        if (option.ShowOrder) {
            editor.Add(editor.CreateTextElement("showorder", option.ShowOrder.toString()));
        }
        if (option.ValidationPattern) {
            editor.Add(editor.CreateTextElement("validationpattern", option.ValidationPattern.source));
        }
        if (option.Items.length > 0) {
            editor.Add(editor.CreateTextElement("selectoptions", option.Items.map((optionItem) => {
                return `${optionItem.Value}:${this.LanguageCategory}.${option.Name}.${optionItem.Name}`;
            }).join("\n")));
        }
        if (option.Options.length > 0) {
            editor.Add(editor.CreateTextElement("options", option.Options.join(",")));
        }
        if (option.EnableOptions.length > 0) {
            editor.Add(editor.CreateTextElement("enableoptions", option.EnableOptions.join(",")));
        }
        for (let additionalProperty in option.AdditionalProperties) {
            editor.Add(editor.CreateTextElement(additionalProperty, `${option.AdditionalProperties[additionalProperty]}`));
        }
        return editor.Element;
    }
}
//# sourceMappingURL=OptionFileCompiler.js.map