@colijnit/corecomponents_v12 12.2.17 → 12.2.19

package/projects/corecomponents/src/lib/core/abstract/collection-based-component.ts

@@ -0,0 +1,488 @@
+import { ChangeDetectorRef, EventEmitter, Input, OnDestroy, Output, Directive } from "@angular/core";
+
+import {isNill} from "../function/is-nill.function";
+import {ParameterValueConversionUtils} from "../utils/parameter-value-conversion-utils";
+import {ObjectUtils} from "../utils/object-utils";
+import {ArrayUtils} from "../utils/array-utils";
+import {CollectionBasedComponentInputDriverProp} from "../enum/collection-based-component-input-driver-prop.enum";
+
+/**
+ * A base class that offers a common interface and implementations for components that deal with a COLLECTION as their primary input,
+ * and want to offer a wide array of possibilities for two-way binding. Many of which are fit to bind directly to objects that are sent
+ * to the middle-tier as, e.g., search string parameter values.
+ *
+ * The in-outs you get (on top of BaseFormInputComponent):
+ * [(collection)]
+ * [(singleSelect)] // 'radio button mode'
+ *
+ * [(selectedModel)]
+ * [(selectedModels)]
+ * [(selectedModelId)]
+ * [(selectedModelIds)]
+ * [(selectionString)]
+ *
+ * this.selectedModels is always used, because that contains the most amount of data. Other outputs are optionally calculated according to driver mode.
+ */
+@Directive()
+export abstract class CollectionBasedInputComponent implements OnDestroy {
+    @Input()
+    public set collection(collection: any[]) {
+        // when using the ASYNC pipe, e.g. [collection]="companies | async", then this setter is fired very early with a null value..
+        if (collection === null || collection === this._collection || this.isDestroyed) {
+            return;
+        }
+
+        this._collection = collection;
+
+        // it's normal to receive [] collections for consumers of our class that initialize it by someColl = [];. We do not want to do processing then.
+        this.handleNewCollection();
+        this.changeDetector.detectChanges();
+    }
+
+    public get collection(): any[] {
+        return this._collection;
+    }
+
+    @Input()
+    public set selectedModel(selectedModel: any) {
+        this._drivenBy = CollectionBasedComponentInputDriverProp.SelectedModel;
+        if (selectedModel === this._selectedModel || this.isDestroyed) {
+            return;
+        }
+        this._selectedModel = selectedModel;
+        this.handleNewSelectedModel();
+    }
+
+    public get selectedModel(): any {
+        return this._selectedModel;
+    }
+
+    @Input()
+    public set selectedModels(selectedModels: any[]) {
+        this._drivenBy = CollectionBasedComponentInputDriverProp.SelectedModels;
+        if (selectedModels === this._selectedModels) {
+            return;
+        }
+        if (!this.collection || this.collection.length === 0) {
+            // collection isnt loaded yet, park the values
+            this._selectedModels = selectedModels;
+        } else {
+            this.selectModels(selectedModels);
+        }
+    }
+
+    public get selectedModels(): any[] {
+        if (!this._selectedModels) {
+            this._selectedModels = [];
+        }
+        return this._selectedModels;
+    }
+
+    @Input()
+    public set selectedModelId(selectedModelId: any) {
+        this._drivenBy = CollectionBasedComponentInputDriverProp.SelectedModelId;
+        if (selectedModelId === this._selectedModelId) {
+            return;
+        }
+        this._selectedModelId = selectedModelId;
+        this.handleNewSelectedModelId();
+    }
+
+    public get selectedModelId(): any {
+        return this._selectedModelId;
+    }
+
+    @Input()
+    public set selectedModelIds(selectedModelIds: any[]) {
+        this._drivenBy = CollectionBasedComponentInputDriverProp.SelectedModelIds;
+        if (selectedModelIds === this._selectedModelIds) {
+            return;
+        }
+        this._selectedModelIds = selectedModelIds;
+        this.handleNewSelectedModelIds();
+    }
+
+    public get selectedModelIds(): any[] {
+        return this._selectedModelIds;
+    }
+
+    @Input()
+    public set selectionString(selectionString: string) {
+        this._drivenBy = CollectionBasedComponentInputDriverProp.SelectionString;
+        if (selectionString === this._selectionString) {
+            return;
+        }
+        this._selectionString = selectionString;
+        this.handleNewSelectionString();
+    }
+
+    public get selectionString(): string {
+        return this._selectionString;
+    }
+
+    @Input()
+    public set singleSelect(singleSelect: boolean) {
+        this._singleSelect = singleSelect;
+        this.handleSingleSelectChange();
+    }
+
+    public get singleSelect(): boolean {
+        return this._singleSelect;
+    }
+
+    @Input()
+    public set customInput(value: string) {
+        if (value === this._customInput) {
+            return;
+        }
+        this._customInput = value;
+    }
+
+    public get customInput(): string {
+        return this._customInput;
+    }
+
+    @Input()
+    public idProperty: string = "id";
+
+    @Output()
+    public readonly selectedModelChange: EventEmitter<any> = new EventEmitter<any>();
+
+    // The main source change emitter; this is always up-to-date with the actual selected models.
+    @Output()
+    public readonly selectedModelsChange: EventEmitter<any[]> = new EventEmitter<any[]>();
+
+    @Output()
+    public readonly selectedModelsCleared: EventEmitter<any> = new EventEmitter();
+
+    @Output()
+    public readonly selectionStringChange: EventEmitter<any> = new EventEmitter<any>();
+
+    @Output()
+    public readonly selectedModelIdsChange: EventEmitter<any[]> = new EventEmitter<any[]>();
+
+    @Output()
+    public readonly selectedModelIdChange: EventEmitter<any> = new EventEmitter<any>();
+
+    @Output()
+    public readonly customInputChange: EventEmitter<string> = new EventEmitter<string>();
+
+    public get isDestroyed(): boolean {
+        return this._destroyed;
+    }
+
+    public get firstSelectedModel(): any {
+        return this._selectedModels ? this._selectedModels[0] : undefined;
+    }
+
+    public selectedModelsString: string;
+
+    private _collection: any[] = [];
+
+    private _singleSelect: boolean;
+    private _drivenBy: CollectionBasedComponentInputDriverProp = CollectionBasedComponentInputDriverProp.SelectedModels;
+    private _selectedModel: any;
+    // This selectedModels is the main source property, to which the other 'selectedBlaBla' are synced optionally, depending on the input prop driver.
+    private _selectedModels: any[] = [];
+    private _selectedModelId: any;
+    private _selectedModelIds: any[] = [];
+    private _selectionString: string;
+    private _customInput: string;
+
+    private _destroyed: boolean;
+
+    constructor(protected changeDetector: ChangeDetectorRef) {
+    }
+
+    ngOnDestroy(): void {
+        this._destroyed = true;
+    }
+
+    public updateCustomInput(input: string): void {
+        if (this._customInput !== input) {
+            this._customInput = input;
+            this.customInputChange.emit(this._customInput);
+        }
+    }
+
+    // Returns whether selected models actually changed.
+    public selectModel(modelToSelect: any, sync: boolean = true): boolean {
+        if (!modelToSelect || this.isSelectedModel(modelToSelect) || !this._collection) {
+            return false;
+        }
+
+        for (let i: number = 0, len: number = this._collection.length; i < len; i++) {
+            const item: any = this._collection[i];
+            if (item && this.getModelId(item) === this.getModelId(modelToSelect)) {
+                // don't select more than one when in radio button mode
+                if (this._singleSelect && this.hasSelectedModels()) {
+                    this.clearSelectedModels();
+                    this._selectedModels = [];
+                }
+                this._selectedModels.push(item);
+                this.selectedModelsChange.emit(this.selectedModels);
+                this.updateSelectedModelsString();
+                if (sync) {
+                    this.syncCalculatedDriveModel();
+                }
+                this.changeDetector.detectChanges();
+                return true;
+            }
+        }
+    }
+
+    private getModelId(model: any): any {
+        return model ? model[this.idProperty] : "";
+    }
+
+    // Returns whether selected models actually changed.
+    public selectModelById(modelId: any): boolean {
+        let modelToSelect: any;
+        if (this._collection) {
+            modelToSelect = this._collection.find(item => this.getModelId(item) === modelId);
+        }
+        if (modelToSelect) {
+            return this.selectModel(modelToSelect);
+        } else {
+            return false;
+        }
+    }
+
+    public deselectModel(modelToDeselect: any): void {
+        if (!modelToDeselect) {
+            return;
+        }
+
+        const len: number = this._selectedModels.length;
+        for (let i: number = len - 1; i >= 0; i--) {
+            let selectedItem: any = this._selectedModels[i];
+            if (this.getModelId(selectedItem) === this.getModelId(modelToDeselect)) {
+                ArrayUtils.RemoveElementAtIndex(i, this._selectedModels);
+                this.selectedModelsChange.emit(this._selectedModels);
+                this.updateSelectedModelsString();
+                this.syncCalculatedDriveModel();
+                break;
+            }
+        }
+    }
+
+    public selectModels(modelsToSelect: any[], sync: boolean = true): void {
+        if (!modelsToSelect || modelsToSelect.length === 0) {
+            return;
+        }
+
+        for (let i: number = 0, len: number = modelsToSelect.length; i < len; i++) {
+            this.selectModel(modelsToSelect[i], false);
+        }
+
+        if (sync) {
+            this.syncCalculatedDriveModel();
+        }
+        this.selectedModelsChange.emit(this._selectedModels);
+        this.updateSelectedModelsString();
+    }
+
+    public selectAll(): void {
+        this.clearSelectedModels();
+        for (let i: number = 0, len: number = this.collection.length; i < len; i++) {
+            this.selectModel(this.collection[i], false);
+        }
+        this.syncCalculatedDriveModel();
+    }
+
+    public deselectAll(): void {
+        this.clearSelectedModels();
+        this.selectedModelsChange.emit(this._selectedModels);
+        this.updateSelectedModelsString();
+        this.syncCalculatedDriveModel();
+    }
+
+    public isSelectedModel(modelToCheckIfIsSelected: any): boolean {
+        if (!modelToCheckIfIsSelected) {
+            return false;
+        } else {
+            return ArrayUtils.ContainsAnElementFoundBy(this._selectedModels, (selectedModel) => {
+                return this.getModelId(selectedModel) === this.getModelId(modelToCheckIfIsSelected);
+            });
+        }
+    }
+
+    // Checked by array lengths.
+    public allCollectionItemsAreSelected(): boolean {
+        if (this._selectedModels && this._collection) {
+            return this._collection.length === this._selectedModels.length;
+        } else if (!this._collection) {
+            return true;
+        }
+        return false;
+    }
+
+    public update(): void {
+        this.changeDetector.detectChanges();
+    }
+
+    private clearSelectedModels(): void {
+        if (this._selectedModels) {
+            this._selectedModels.length = 0;
+        } else {
+            this._selectedModels = [];
+        }
+        this.selectedModelsCleared.emit();
+    }
+
+    private handleNewCollection(): void {
+        switch (this._drivenBy) {
+            case (CollectionBasedComponentInputDriverProp.SelectedModelIds):
+                this.handleNewSelectedModelIds();
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectionString):
+                this.handleNewSelectionString();
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectedModelId):
+                this.handleNewSelectedModelId();
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectedModel):
+                this.handleNewSelectedModel();
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectedModels):
+            default:
+                this.handleNewSelectedModels();
+                break;
+        }
+    }
+
+    // @param models IN-OUT
+    private removeItemsThatDontExistInCollection(models: any[]): void {
+        ArrayUtils.RemoveElementsByFilter(models, (m: any) => {
+            for (let i: number = 0, len: number = this._collection.length; i < len; i++) {
+                let item: any = this._collection[i];
+                if (ObjectUtils.DeepEquals(m, item)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+
+    private handleSingleSelectChange(): void {
+        if (this._singleSelect === true && this.hasSelectedModels()) {
+            let firstModel: any = this.selectedModels[0];
+            this.clearSelectedModels();
+            this.selectModel(firstModel);
+        }
+    }
+
+    private handleNewSelectionString(): void {
+        if (isNill(this.selectionString)) {
+            this.deselectAll();
+        } else {
+            if (this.hasCollectionItems()) {
+                this.clearSelectedModels();
+                // the data values in selection string ought to be business object ID's; extract them and use them to select the specified models
+                let selectionIds: string[] = ParameterValueConversionUtils.ExtractDataValuesFromSearchString(this.selectionString);
+                let modelsToSelect: any[] = [];
+                for (let i: number = 0, len: number = this._collection.length; i < len; i++) {
+                    const item: any = this._collection[i];
+                    const itemId: any = this.getModelId(item);
+                    const itemIdAsString: string = itemId ? itemId.toString() : "";
+                    if (selectionIds.indexOf(itemIdAsString) !== -1) {
+                        modelsToSelect.push(item);
+                    }
+                }
+                this.selectModels(modelsToSelect);
+            }
+        }
+    }
+
+    private handleNewSelectedModelIds(): void {
+        this.clearSelectedModels();
+        if (Array.isArray(this._selectedModelIds) && this.hasCollectionItems()) {
+            this.selectModels(this.collection.filter(item => this._selectedModelIds.indexOf(this.getModelId(item)) !== -1));
+        }
+    }
+
+    private handleNewSelectedModelId(): void {
+        if (isNill(this._selectedModelId)) {
+            this.deselectAll();
+        } else if (this.hasCollectionItems()) {
+            this.clearSelectedModels();
+            this.selectModels(this._collection.filter(item => this.getModelId(item) == this._selectedModelId)); // DONT CHANGE TO '===', this is '==' because it has to evaluate '1' equal to 1 (CoDomainValue gimmick)
+        }
+    }
+
+    private handleNewSelectedModel(): void {
+        this.clearSelectedModels();
+        if (this.selectedModelExistsInCollection()) {
+            this.selectModel(this._selectedModel);
+        }
+    }
+
+    private handleNewSelectedModels(): void {
+        //this._clearSelectedModels();
+        this.removeItemsThatDontExistInCollection(this._selectedModels);
+        this.selectModels(this._selectedModels);
+    }
+
+    // PRE: this._selectedModels (the source) contains the true current selected models. POST: the synced input driver will be calculated
+    // and its change outputted.
+    private syncCalculatedDriveModel(): void {
+        // plz keep the order like this (most common cases on top)
+        switch (this._drivenBy) {
+            case (CollectionBasedComponentInputDriverProp.SelectedModelId):
+                this._selectedModelId = (this._selectedModels && this._selectedModels[0]) ? this.getModelId(this._selectedModels[0]) : undefined;
+                this.selectedModelIdChange.emit(this._selectedModelId);
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectedModelIds):
+                this._selectedModelIds = this.getSelectedModelIdsSorted();
+                this.selectedModelIdsChange.emit(this._selectedModelIds);
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectionString):
+                this._selectionString = ParameterValueConversionUtils.ArrayValuesToOrList(this.getSelectedModelIdsSorted(), "");
+                this.selectionStringChange.emit(this._selectionString);
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectedModel):
+                this._selectedModel = (this._selectedModels) ? this._selectedModels[0] : undefined;
+                this.selectedModelChange.emit(this._selectedModel);
+                break;
+            case (CollectionBasedComponentInputDriverProp.SelectedModels):
+            default:
+                // here, we dont have to sync anything else since selectedModels this is the core thing that (possibly) drives the other, calculated in/outs
+                break;
+        }
+    }
+
+    private getSelectedModelIdsSorted(): any[] {
+        let ids: any[] = [];
+        for (let i: number = 0, len: number = this._selectedModels.length; i < len; i++) {
+            ids.push(this.getModelId(this._selectedModels[i]));
+        }
+        ArrayUtils.SortAlphabetically(ids);
+        return ids;
+    }
+
+    private selectedModelExistsInCollection(): boolean {
+        if (this._selectedModel) {
+            const selectedModelId: any = this.getModelId(this._selectedModel);
+            return ArrayUtils.ContainsAnElementFoundBy(this._collection, (item: any) => {
+                return this.getModelId(item) === selectedModelId;
+            });
+        }
+    }
+
+    private hasSelectedModels(): boolean {
+        return ArrayUtils.IsArrayWithElements(this._selectedModels);
+    }
+
+    private hasCollectionItems(): boolean {
+        return ArrayUtils.IsArrayWithElements(this._collection);
+    }
+
+    private updateSelectedModelsString(): void {
+        const selectedModelIds: any[] = this.selectedModels.map(item => this.getModelId(item));
+        let idsString: string;
+        selectedModelIds.forEach(modelId => {
+            idsString += modelId.toString();
+        });
+        this.selectedModelsString = idsString;
+    }
+}

package/projects/corecomponents/src/lib/core/config/device-environment.ts

@@ -0,0 +1,26 @@
+// Static function holder able to provide information about the device that currently runs the application.
+import { isNill } from '../function/is-nill.function';
+
+// @dynamic
+export class DeviceEnvironment {
+    private static _IsTouchDevice: boolean = null;
+
+    // Returns whether the app is running on a touch-enabled device.
+    public static get IsTouchDevice(): boolean {
+        // test and set IsTouchDevice only once
+        if (isNill(DeviceEnvironment._IsTouchDevice)) {
+            DeviceEnvironment._IsTouchDevice = DeviceEnvironment._TestTouchSupport();
+        }
+        return DeviceEnvironment._IsTouchDevice;
+    }
+
+    private static _TestTouchSupport(): boolean {
+        try {
+            // this throws an error if there's no touch support
+            document.createEvent("TouchEvent");
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+}

package/projects/corecomponents/src/lib/core/constant/default-upper-bound-for-range-components.ts

@@ -0,0 +1,4 @@
+import {JAVA_MAX_INT} from "./java-max-int";
+
+export const DEFAULT_LOWER_BOUND_FOR_RANGE_COMPONENTS: number = -JAVA_MAX_INT;
+export const DEFAULT_UPPER_BOUND_FOR_RANGE_COMPONENTS: number = JAVA_MAX_INT;

package/projects/corecomponents/src/lib/core/constant/java-max-int.ts

@@ -0,0 +1 @@
+export const JAVA_MAX_INT: number = 2147483647;

package/projects/corecomponents/src/lib/core/constant/number-inputs-key-down-white-list.ts

@@ -0,0 +1,46 @@
+import {KeyboardCode} from "../enum/keyboard-code.enum";
+
+export const NUMBER_INPUTS_KEY_DOWN_WHITE_LIST: KeyboardCode[] = [
+    /* navigation and functional utility buttons */
+    KeyboardCode.Left,
+    KeyboardCode.Up,
+    KeyboardCode.Right,
+    KeyboardCode.Down,
+    KeyboardCode.Up,
+    KeyboardCode.Tab,
+    KeyboardCode.Enter,
+    KeyboardCode.Home,
+    KeyboardCode.End,
+    KeyboardCode.Delete,
+    KeyboardCode.Insert,
+    KeyboardCode.Shift,
+    KeyboardCode.Backspace,
+
+    /* actual number input part */
+    KeyboardCode.Comma,
+    KeyboardCode.Period,
+    KeyboardCode.DecimalPoint,
+    KeyboardCode.Zero,
+    KeyboardCode.One,
+    KeyboardCode.Two,
+    KeyboardCode.Three,
+    KeyboardCode.Four,
+    KeyboardCode.Five,
+    KeyboardCode.Six,
+    KeyboardCode.Seven,
+    KeyboardCode.Eight,
+    KeyboardCode.Nine,
+    KeyboardCode.Minus,
+    KeyboardCode.MinusFireFox,
+    KeyboardCode.Substract,
+    KeyboardCode.NumpadZero,
+    KeyboardCode.NumpadOne,
+    KeyboardCode.NumpadTwo,
+    KeyboardCode.NumpadThree,
+    KeyboardCode.NumpadFour,
+    KeyboardCode.NumpadFive,
+    KeyboardCode.NumpadSix,
+    KeyboardCode.NumpadSeven,
+    KeyboardCode.NumpadEight,
+    KeyboardCode.NumpadNine
+];

package/projects/corecomponents/src/lib/core/decorator/input-boolean.decorator.ts

@@ -0,0 +1,35 @@
+import { Input } from '@angular/core';
+import { StringUtils } from '../utils/string-utils';
+
+/**
+ * Property decorator which enables template syntax like "someBoolInput" instead of "[someBoolInput]='true'". Makes use of the fact that
+ * Angular assigns an empty string to the input property in the naked "someBoolInput" template case.
+ */
+export function InputBoolean(bindingPropertyName?: string): PropertyDecorator {
+    const inputDecorator: PropertyDecorator = Input(bindingPropertyName);
+    return (target: Object, key: string) => {
+        inputDecorator(target, key);
+        const descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(target, key) || {};
+        Object.defineProperty(target, key, {
+            get: descriptor.get || function (): boolean {
+                return this["__" + key];
+            },
+            set: function(newValue: any): void {
+                const val: boolean = InputBooleanDecorator.InputValueToBoolean(newValue);
+                descriptor.set ? descriptor.set(val) : this["__" + key] = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+    };
+}
+
+// Utility function holder of the InputBooleanDecorator decorator.
+export class InputBooleanDecorator {
+    public static InputValueToBoolean(value: any): boolean {
+        if (StringUtils.IsString(value) && !StringUtils.IsStringWithLength(value)) {
+            return true;
+        }
+        return !!value;
+    }
+}

package/projects/corecomponents/src/lib/core/enum/co-direction.ts

@@ -0,0 +1,7 @@
+// Direction type for regular straight directions.
+export enum CoDirection {
+    Right = "right",
+    Left = "left",
+    Up = "top",
+    Down = "bottom",
+}

package/projects/corecomponents/src/lib/core/enum/co-document-image-display-kind.enum.ts

@@ -0,0 +1,5 @@
+export enum CoDocumentImageDisplayKind {
+    NormalImage = "N",
+    LayeredImage = "L",
+    Avatar = "A"
+}

package/projects/corecomponents/src/lib/core/enum/co-document-type.enum.ts

@@ -0,0 +1,9 @@
+// for refcode CV_DOCUMENTATIE.DOC_TYPE
+export enum CoDocumentType {
+    // BN: Document opslaan als bestand, locatie niet van toepassing
+    SaveAsDocument = "BN",
+    // LS: Document opslaan als link op willekeurige locatie
+    SaveAsLinkOnRandomLocation = "LS",
+    // LW: Document opslaan als link op standaardloactie
+    SaveAsLinkOnDefaultLocation = "LW",
+}

package/projects/corecomponents/src/lib/core/enum/co-orientation.ts

@@ -0,0 +1,18 @@
+import {CoDirection} from "./co-direction";
+
+// Represents a bi-directional orientation.
+export enum CoOrientation {
+    Horizontal = "horizontal",
+    Vertical = "vertical",
+}
+
+const _orientationsOfDirections: Map<CoDirection, CoOrientation> = new Map<CoDirection, CoOrientation>([
+    [CoDirection.Right, CoOrientation.Vertical],
+    [CoDirection.Left, CoOrientation.Vertical],
+    [CoDirection.Up, CoOrientation.Horizontal],
+    [CoDirection.Down, CoOrientation.Horizontal]
+]);
+
+export function OrientationOfDirection(direction: CoDirection): CoOrientation {
+    return _orientationsOfDirections.get(direction);
+}

package/projects/corecomponents/src/lib/core/enum/collection-based-component-input-driver-prop.enum.ts

@@ -0,0 +1,10 @@
+// Collection based components can operate with [(selectionString)] or [(selectedModelIds)] or [(selectedModelId)] two-way binding.
+// To prevent multiple @Input()'s being in conflict (and to prevent needless calculation), the component always has only ONE
+// 'driver property' and doesn't sync the others.
+export enum CollectionBasedComponentInputDriverProp {
+    SelectedModel = "SelectedModel",
+    SelectedModels = "SelectedModels",
+    SelectedModelId = "SelectedModelId",
+    SelectedModelIds = "SelectedModelIds",
+    SelectionString = "SelectionString"
+}

package/projects/corecomponents/src/lib/core/enum/color-sequence-name.enum.ts

@@ -0,0 +1,5 @@
+// Represents the enumeration of color sequence names; the different color sequences stored in db.
+export enum ColorSequenceName {
+    Regular = "REGULAR",
+    Variant = "VARIANT",
+}