@aurigma/design-atoms-model 7.0.34 → 7.0.37

package/Product/Items/LayoutItem.js

@@ -1,27 +1,3 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -31,156 +7,123 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
 import { GroupItem } from "./GroupItem";
 import { EventObject } from "../../EventObject";
 import { EqualsOfFloatNumbers } from "../../Math";
 import { BaseTextItem } from ".";
 import { Property } from "../Decorators/Property";
 import { equals } from "../../Utils/Utils";
-var LayoutItem = /** @class */ (function (_super) {
-    __extends(LayoutItem, _super);
-    function LayoutItem(items, layoutSettings) {
-        var _this = _super.call(this, items) || this;
-        _this.type = LayoutItem.type;
-        _this._onLayoutSettingsChanged = function (propertyName) {
-            _this._propertyChanged.notify(_this, propertyName);
+export class LayoutItem extends GroupItem {
+    constructor(items, layoutSettings) {
+        super(items);
+        this.type = LayoutItem.type;
+        this._onLayoutSettingsChanged = (propertyName) => {
+            this._propertyChanged.notify(this, propertyName);
         };
-        _this.layoutSettings = layoutSettings != null ? layoutSettings : new DefaultLayoutSettings();
-        return _this;
+        this.layoutSettings = layoutSettings != null ? layoutSettings : new DefaultLayoutSettings();
     }
-    LayoutItem.prototype.getSimplifiedObject = function (omitProperties) {
-        if (omitProperties === void 0) { omitProperties = []; }
+    getSimplifiedObject(omitProperties = []) {
         var _a, _b;
-        var result = _super.prototype.getSimplifiedObject.call(this, ["layoutSettings"].concat(omitProperties));
+        const result = super.getSimplifiedObject(["layoutSettings"].concat(omitProperties));
         result["layoutSettings"] = (_a = this.layoutSettings) === null || _a === void 0 ? void 0 : _a.getSimplifiedObject();
         result["sourceRectangle"] = (_b = this.sourceRectangle) === null || _b === void 0 ? void 0 : _b.toJSON();
         return result;
-    };
-    LayoutItem.prototype._copy = function (source, destination, generateNewIds, appropriateParentContainer) {
+    }
+    _copy(source, destination, generateNewIds, appropriateParentContainer) {
         var _a;
-        _super.prototype._copy.call(this, source, destination, generateNewIds, appropriateParentContainer);
+        super._copy(source, destination, generateNewIds, appropriateParentContainer);
         if (generateNewIds) {
             this._copyItemsOrder(source, destination);
         }
         destination.layoutSettings = source.layoutSettings.clone();
         destination.sourceRectangle = (_a = source.sourceRectangle) === null || _a === void 0 ? void 0 : _a.clone();
-    };
-    LayoutItem.prototype._copyItemsOrder = function (source, destination) {
-        var sourceOrder = source.getItemsOrder();
+    }
+    _copyItemsOrder(source, destination) {
+        const sourceOrder = source.getItemsOrder();
         if (sourceOrder) {
-            var targetOrder = sourceOrder.map(function (x) {
-                var sourceItemIndex = source.items.indexOf(function (item) { return item.id == x; });
-                var targetItem = destination.items.get(sourceItemIndex);
+            const targetOrder = sourceOrder.map(x => {
+                let sourceItemIndex = source.items.indexOf(item => item.id == x);
+                let targetItem = destination.items.get(sourceItemIndex);
                 return targetItem.id;
             });
             destination.setItemsOrder(targetOrder);
         }
-    };
-    LayoutItem.prototype.clone = function (generateNewIds, appropriateParentContainer) {
-        if (generateNewIds === void 0) { generateNewIds = false; }
-        if (appropriateParentContainer === void 0) { appropriateParentContainer = false; }
-        var item = new LayoutItem();
+    }
+    clone(generateNewIds = false, appropriateParentContainer = false) {
+        const item = new LayoutItem();
         this._copy(this, item, generateNewIds, appropriateParentContainer);
         return item;
-    };
-    Object.defineProperty(LayoutItem.prototype, "layoutSettings", {
-        get: function () {
-            return this._layoutSettings;
-        },
-        set: function (value) {
-            if (value == null)
-                throw new Error("LayoutSettings can't be null");
-            if (this._layoutSettings != null)
-                this._layoutSettings.propertyChanged.remove(this._onLayoutSettingsChanged);
-            this._layoutSettings = value;
-            this._layoutSettings.propertyChanged.add(this._onLayoutSettingsChanged);
-            this._onLayoutSettingsChanged("layoutSettings");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(LayoutItem.prototype, "sourceRectangle", {
-        get: function () {
-            return this._sourceRectangle;
-        },
-        set: function (value) {
-            if (this._sourceRectangle != null && value == null)
-                throw new Error("LayoutItem.sourceRectangle can't be null");
-            if (value != null && value.equals(this._sourceRectangle))
-                return;
-            this._unsubscribeSourceRectangle();
-            this._sourceRectangle = value;
-            this._subscribeSourceRectangle();
-            this._propertyChanged.notify(this, "sourceRectangle");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    LayoutItem.prototype._subscribeSourceRectangle = function () {
+    }
+    get layoutSettings() {
+        return this._layoutSettings;
+    }
+    set layoutSettings(value) {
+        if (value == null)
+            throw new Error("LayoutSettings can't be null");
+        if (this._layoutSettings != null)
+            this._layoutSettings.propertyChanged.remove(this._onLayoutSettingsChanged);
+        this._layoutSettings = value;
+        this._layoutSettings.propertyChanged.add(this._onLayoutSettingsChanged);
+        this._onLayoutSettingsChanged("layoutSettings");
+    }
+    get sourceRectangle() {
+        return this._sourceRectangle;
+    }
+    set sourceRectangle(value) {
+        if (this._sourceRectangle != null && value == null)
+            throw new Error("LayoutItem.sourceRectangle can't be null");
+        if (value != null && value.equals(this._sourceRectangle))
+            return;
+        this._unsubscribeSourceRectangle();
+        this._sourceRectangle = value;
+        this._subscribeSourceRectangle();
+        this._propertyChanged.notify(this, "sourceRectangle");
+    }
+    _subscribeSourceRectangle() {
         if (this._sourceRectangle == null)
             return;
-    };
-    LayoutItem.prototype._unsubscribeSourceRectangle = function () {
+    }
+    _unsubscribeSourceRectangle() {
         if (this._sourceRectangle == null)
             return;
-    };
-    LayoutItem.prototype.addItems = function (items, targetIndex, orderIndex) {
-        var order = this.getItemsOrder();
+    }
+    addItems(items, targetIndex, orderIndex) {
+        let order = this.getItemsOrder();
         if (order) {
             if (!Number.isInteger(orderIndex))
                 throw new Error("orderIndex must not be null");
-            order = LayoutItem._insertToOrder(order, items.map(function (x) { return x.id; }), orderIndex);
+            order = LayoutItem._insertToOrder(order, items.map(x => x.id), orderIndex);
             this.setItemsOrder(order);
         }
-        _super.prototype.addItems.call(this, items, targetIndex);
-    };
-    LayoutItem.prototype.removeItems = function (items) {
-        var order = this.getItemsOrder();
+        super.addItems(items, targetIndex);
+    }
+    removeItems(items) {
+        let order = this.getItemsOrder();
         if (order) {
-            items.forEach(function (item) { return order = order.filter(function (id) { return id !== item.id; }); });
+            items.forEach((item) => order = order.filter((id) => id !== item.id));
             this.setItemsOrder(order);
         }
-        _super.prototype.removeItems.call(this, items);
-    };
-    LayoutItem.prototype.addItem = function (item, targetIndex, orderIndex) {
-        var order = this.getItemsOrder();
+        super.removeItems(items);
+    }
+    addItem(item, targetIndex, orderIndex) {
+        let order = this.getItemsOrder();
         if (order != null) {
             order = LayoutItem._insertToOrder(order, [item.id], orderIndex);
             this.setItemsOrder(order);
         }
-        _super.prototype.addItem.call(this, item, targetIndex);
-    };
-    LayoutItem._insertToOrder = function (order, newItems, index) {
-        var part1 = order.slice(0, index);
-        var part2 = order.slice(index);
+        super.addItem(item, targetIndex);
+    }
+    static _insertToOrder(order, newItems, index) {
+        let part1 = order.slice(0, index);
+        let part2 = order.slice(index);
         order = part1.concat(newItems, part2);
         return order;
-    };
-    LayoutItem.prototype.setItemsOrder = function (ids) {
+    }
+    setItemsOrder(ids) {
         this.tags[LayoutItem._layoutItemsOrderTagKey] = ids;
-    };
-    LayoutItem.prototype.getItemsOrder = function () {
-        var value = this.tags[LayoutItem._layoutItemsOrderTagKey];
+    }
+    getItemsOrder() {
+        const value = this.tags[LayoutItem._layoutItemsOrderTagKey];
         if (value == null) {
             return null;
         }
@@ -188,31 +131,31 @@ var LayoutItem = /** @class */ (function (_super) {
             return null;
         }
         return value;
-    };
-    LayoutItem.prototype.getSortedItems = function () {
-        var order = this.getItemsOrder();
+    }
+    getSortedItems() {
+        const order = this.getItemsOrder();
         var nestedItems = this.items.toArray();
         if (order != null && nestedItems != null)
-            return order.map(function (id) { return nestedItems.find(function (i) { return i.id === id; }); });
+            return order.map(id => nestedItems.find(i => i.id === id));
         return null;
-    };
-    LayoutItem.prototype.getItemOrderIndex = function (item) {
+    }
+    getItemOrderIndex(item) {
         if (this.items.indexOf(item) < 0)
             return -1;
-        var order = this.getItemsOrder();
+        let order = this.getItemsOrder();
         return order === null || order === void 0 ? void 0 : order.indexOf(item.id);
-    };
-    LayoutItem.generateAutoLayoutSettings = function (rectangles, alignItems, orientation, margin, justifyContent) {
-        var autoLayoutSettings = new AutoLayoutSettings();
-        var leftBounds = rectangles.map(function (rectangle) { return rectangle.left; });
-        var rightBounds = rectangles.map(function (rectangle) { return rectangle.right; });
-        var topBounds = rectangles.map(function (rectangle) { return rectangle.top; });
-        var bottomBounds = rectangles.map(function (rectangle) { return rectangle.bottom; });
-        var centersX = rectangles.map(function (rectangle) { return rectangle.center.x; });
-        var centersY = rectangles.map(function (rectangle) { return rectangle.center.y; });
+    }
+    static generateAutoLayoutSettings(rectangles, alignItems, orientation, margin, justifyContent) {
+        const autoLayoutSettings = new AutoLayoutSettings();
+        const leftBounds = rectangles.map(rectangle => rectangle.left);
+        const rightBounds = rectangles.map(rectangle => rectangle.right);
+        const topBounds = rectangles.map(rectangle => rectangle.top);
+        const bottomBounds = rectangles.map(rectangle => rectangle.bottom);
+        const centersX = rectangles.map(rectangle => rectangle.center.x);
+        const centersY = rectangles.map(rectangle => rectangle.center.y);
         if (orientation == null) {
-            var horizontalDelta = Math.max.apply(Math, __spread(centersX)) - Math.min.apply(Math, __spread(centersX));
-            var verticalDelta = Math.max.apply(Math, __spread(centersY)) - Math.min.apply(Math, __spread(centersY));
+            const horizontalDelta = Math.max(...centersX) - Math.min(...centersX);
+            const verticalDelta = Math.max(...centersY) - Math.min(...centersY);
             orientation = horizontalDelta > verticalDelta
                 ? AutoLayoutOrientation.horizontal
                 : AutoLayoutOrientation.vertical;
@@ -221,21 +164,21 @@ var LayoutItem = /** @class */ (function (_super) {
         if (alignItems == null)
             switch (autoLayoutSettings.orientation) {
                 case AutoLayoutOrientation.horizontal:
-                    if (EqualsOfFloatNumbers(Math.max.apply(Math, __spread(topBounds)), Math.min.apply(Math, __spread(topBounds)), 5))
+                    if (EqualsOfFloatNumbers(Math.max(...topBounds), Math.min(...topBounds), 5))
                         alignItems = AutoLayoutAlignItems.start;
-                    else if (EqualsOfFloatNumbers(Math.max.apply(Math, __spread(centersY)), Math.min.apply(Math, __spread(centersY)), 5))
+                    else if (EqualsOfFloatNumbers(Math.max(...centersY), Math.min(...centersY), 5))
                         alignItems = AutoLayoutAlignItems.center;
-                    else if (EqualsOfFloatNumbers(Math.max.apply(Math, __spread(bottomBounds)), Math.min.apply(Math, __spread(bottomBounds)), 5))
+                    else if (EqualsOfFloatNumbers(Math.max(...bottomBounds), Math.min(...bottomBounds), 5))
                         alignItems = AutoLayoutAlignItems.end;
                     else
                         alignItems = AutoLayoutAlignItems.none;
                     break;
                 case AutoLayoutOrientation.vertical:
-                    if (EqualsOfFloatNumbers(Math.max.apply(Math, __spread(leftBounds)), Math.min.apply(Math, __spread(leftBounds)), 5))
+                    if (EqualsOfFloatNumbers(Math.max(...leftBounds), Math.min(...leftBounds), 5))
                         alignItems = AutoLayoutAlignItems.start;
-                    else if (EqualsOfFloatNumbers(Math.max.apply(Math, __spread(centersX)), Math.min.apply(Math, __spread(centersX)), 5))
+                    else if (EqualsOfFloatNumbers(Math.max(...centersX), Math.min(...centersX), 5))
                         alignItems = AutoLayoutAlignItems.center;
-                    else if (EqualsOfFloatNumbers(Math.max.apply(Math, __spread(rightBounds)), Math.min.apply(Math, __spread(rightBounds)), 5))
+                    else if (EqualsOfFloatNumbers(Math.max(...rightBounds), Math.min(...rightBounds), 5))
                         alignItems = AutoLayoutAlignItems.end;
                     else
                         alignItems = AutoLayoutAlignItems.none;
@@ -244,46 +187,44 @@ var LayoutItem = /** @class */ (function (_super) {
                     break;
             }
         autoLayoutSettings.alignItems = alignItems;
-        var sortedRectangles = autoLayoutSettings.orientation === AutoLayoutOrientation.horizontal
-            ? rectangles.sort(function (a, b) { return a.left - b.left; })
-            : rectangles.sort(function (a, b) { return a.top - b.top; });
-        var margins = [];
-        for (var i = 1; i < sortedRectangles.length; i++) {
-            var previousRectangle = sortedRectangles[i - 1];
-            var rectangle = sortedRectangles[i];
+        const sortedRectangles = autoLayoutSettings.orientation === AutoLayoutOrientation.horizontal
+            ? rectangles.sort((a, b) => a.left - b.left)
+            : rectangles.sort((a, b) => a.top - b.top);
+        const margins = [];
+        for (let i = 1; i < sortedRectangles.length; i++) {
+            const previousRectangle = sortedRectangles[i - 1];
+            const rectangle = sortedRectangles[i];
             margins.push(autoLayoutSettings.orientation === AutoLayoutOrientation.horizontal
                 ? rectangle.left - previousRectangle.right
                 : rectangle.top - previousRectangle.bottom);
         }
         if (margin == null)
             margin = margins.length > 0
-                ? Math.max(0, Math.min.apply(Math, __spread(margins.map(Math.round))))
+                ? Math.max(0, Math.min(...margins.map(Math.round)))
                 : 0;
         autoLayoutSettings.margin = margin;
         if (justifyContent == null)
-            justifyContent = EqualsOfFloatNumbers(Math.max.apply(Math, __spread(margins)), Math.min.apply(Math, __spread(margins)), 2)
+            justifyContent = EqualsOfFloatNumbers(Math.max(...margins), Math.min(...margins), 2)
                 ? AutoLayoutJustifyContent.stretch
                 : AutoLayoutJustifyContent.spaceBetween;
         autoLayoutSettings.justifyContent = justifyContent;
         return autoLayoutSettings;
-    };
-    LayoutItem.prototype.isChildVisible = function (item) {
+    }
+    isChildVisible(item) {
         if (item instanceof BaseTextItem) {
             return !item.isEmpty();
         }
         return true;
-    };
-    LayoutItem.prototype.equals = function (other) {
-        var superEq = _super.prototype.equals.call(this, other);
-        var sourceRectangleEq = equals(this.sourceRectangle, other.sourceRectangle);
-        var layoutSettingsEq = equals(this.layoutSettings, other.layoutSettings);
+    }
+    equals(other) {
+        const superEq = super.equals(other);
+        const sourceRectangleEq = equals(this.sourceRectangle, other.sourceRectangle);
+        const layoutSettingsEq = equals(this.layoutSettings, other.layoutSettings);
         return superEq && sourceRectangleEq && layoutSettingsEq;
-    };
-    LayoutItem._layoutItemsOrderTagKey = "$layoutItemsOrder";
-    LayoutItem.type = "LayoutItem";
-    return LayoutItem;
-}(GroupItem));
-export { LayoutItem };
+    }
+}
+LayoutItem._layoutItemsOrderTagKey = "$layoutItemsOrder";
+LayoutItem.type = "LayoutItem";
 ;
 export var LayoutType;
 (function (LayoutType) {
@@ -314,125 +255,101 @@ export var AutoLayoutAnchorPoint;
     AutoLayoutAnchorPoint[AutoLayoutAnchorPoint["center"] = 1] = "center";
     AutoLayoutAnchorPoint[AutoLayoutAnchorPoint["end"] = 2] = "end";
 })(AutoLayoutAnchorPoint || (AutoLayoutAnchorPoint = {}));
-var DefaultLayoutSettings = /** @class */ (function () {
-    function DefaultLayoutSettings() {
+export class DefaultLayoutSettings {
+    constructor() {
         this.type = DefaultLayoutSettings.type;
         this.propertyChanged = new EventObject();
     }
-    DefaultLayoutSettings.prototype.clone = function () {
+    clone() {
         return new DefaultLayoutSettings();
-    };
-    DefaultLayoutSettings.prototype.getSimplifiedObject = function () {
-        var result = {};
+    }
+    getSimplifiedObject() {
+        const result = {};
         result["type"] = DefaultLayoutSettings.type;
         return result;
-    };
-    DefaultLayoutSettings.prototype.equals = function (other) {
-        var typeEq = equals(this.type, other.type);
+    }
+    equals(other) {
+        const typeEq = equals(this.type, other.type);
         return typeEq;
-    };
-    DefaultLayoutSettings.type = "DefaultLayoutSettings";
-    return DefaultLayoutSettings;
-}());
-export { DefaultLayoutSettings };
-var AutoLayoutSettings = /** @class */ (function (_super) {
-    __extends(AutoLayoutSettings, _super);
-    function AutoLayoutSettings() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.type = AutoLayoutSettings.type;
-        _this._margin = 0;
-        _this._orientation = AutoLayoutOrientation.vertical;
-        _this._alignItems = AutoLayoutAlignItems.none;
-        _this._anchorPoint = AutoLayoutAnchorPoint.start;
-        _this._justifyContent = AutoLayoutJustifyContent.stretch;
-        return _this;
-    }
-    Object.defineProperty(AutoLayoutSettings.prototype, "margin", {
-        get: function () {
-            return this._margin;
-        },
-        set: function (value) {
-            if (value == null)
-                throw new Error("Margin can't be null");
-            if (value === this.margin)
-                return;
-            this._margin = value;
-            this.propertyChanged.notify("margin");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(AutoLayoutSettings.prototype, "orientation", {
-        get: function () {
-            return this._orientation;
-        },
-        set: function (value) {
-            if (value == null)
-                throw Error("Orientation can't be null");
-            if (value === this.orientation)
-                return;
-            this._orientation = value;
-            this.propertyChanged.notify("orientation");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(AutoLayoutSettings.prototype, "alignItems", {
-        get: function () {
-            return this._alignItems;
-        },
-        set: function (value) {
-            if (value == null)
-                throw new Error("alignItems can't be null");
-            if (value === this.alignItems)
-                return;
-            this._alignItems = value;
-            this.propertyChanged.notify("alignItems");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(AutoLayoutSettings.prototype, "justifyContent", {
-        get: function () {
-            return this._justifyContent;
-        },
-        set: function (value) {
-            if (value == null)
-                throw new Error("JustifyContent can't be null");
-            if (value === this.justifyContent)
-                return;
-            this._justifyContent = value;
-            this.propertyChanged.notify("justifyContent");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(AutoLayoutSettings.prototype, "anchorPoint", {
-        get: function () {
-            return this._anchorPoint;
-        },
-        set: function (value) {
-            if (value == null)
-                throw new Error("anchorPoint can't be null");
-            if (value === this._anchorPoint)
-                return;
-            this._anchorPoint = value;
-            this.propertyChanged.notify("anchorPoint");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    AutoLayoutSettings.prototype.clone = function () {
-        var clone = new AutoLayoutSettings();
+    }
+}
+DefaultLayoutSettings.type = "DefaultLayoutSettings";
+export class AutoLayoutSettings extends DefaultLayoutSettings {
+    constructor() {
+        super(...arguments);
+        this.type = AutoLayoutSettings.type;
+        this._margin = 0;
+        this._orientation = AutoLayoutOrientation.vertical;
+        this._alignItems = AutoLayoutAlignItems.none;
+        this._anchorPoint = AutoLayoutAnchorPoint.start;
+        this._justifyContent = AutoLayoutJustifyContent.stretch;
+    }
+    get margin() {
+        return this._margin;
+    }
+    set margin(value) {
+        if (value == null)
+            throw new Error("Margin can't be null");
+        if (value === this.margin)
+            return;
+        this._margin = value;
+        this.propertyChanged.notify("margin");
+    }
+    get orientation() {
+        return this._orientation;
+    }
+    set orientation(value) {
+        if (value == null)
+            throw Error("Orientation can't be null");
+        if (value === this.orientation)
+            return;
+        this._orientation = value;
+        this.propertyChanged.notify("orientation");
+    }
+    get alignItems() {
+        return this._alignItems;
+    }
+    set alignItems(value) {
+        if (value == null)
+            throw new Error("alignItems can't be null");
+        if (value === this.alignItems)
+            return;
+        this._alignItems = value;
+        this.propertyChanged.notify("alignItems");
+    }
+    get justifyContent() {
+        return this._justifyContent;
+    }
+    set justifyContent(value) {
+        if (value == null)
+            throw new Error("JustifyContent can't be null");
+        if (value === this.justifyContent)
+            return;
+        this._justifyContent = value;
+        this.propertyChanged.notify("justifyContent");
+    }
+    get anchorPoint() {
+        return this._anchorPoint;
+    }
+    set anchorPoint(value) {
+        if (value == null)
+            throw new Error("anchorPoint can't be null");
+        if (value === this._anchorPoint)
+            return;
+        this._anchorPoint = value;
+        this.propertyChanged.notify("anchorPoint");
+    }
+    clone() {
+        const clone = new AutoLayoutSettings();
         clone.orientation = this.orientation;
         clone.alignItems = this.alignItems;
         clone.justifyContent = this.justifyContent;
         clone.margin = this.margin;
         clone.anchorPoint = this.anchorPoint;
         return clone;
-    };
-    AutoLayoutSettings.prototype.getSimplifiedObject = function () {
-        var result = _super.prototype.getSimplifiedObject.call(this);
+    }
+    getSimplifiedObject() {
+        const result = super.getSimplifiedObject();
         result["type"] = AutoLayoutSettings.type;
         result["orientation"] = this.orientation;
         result["alignItems"] = this.alignItems;
@@ -440,49 +357,47 @@ var AutoLayoutSettings = /** @class */ (function (_super) {
         result["margin"] = this.margin;
         result["anchorPoint"] = this.anchorPoint;
         return result;
-    };
-    AutoLayoutSettings.prototype.equals = function (other) {
-        var superEq = _super.prototype.equals.call(this, other);
-        var orientationEq = equals(this.orientation, other.orientation);
-        var alignItemsEq = equals(this.alignItems, other.alignItems);
-        var marginEq = equals(this.margin, other.margin);
-        var anchorPointEq = equals(this.anchorPoint, other.anchorPoint);
+    }
+    equals(other) {
+        const superEq = super.equals(other);
+        const orientationEq = equals(this.orientation, other.orientation);
+        const alignItemsEq = equals(this.alignItems, other.alignItems);
+        const marginEq = equals(this.margin, other.margin);
+        const anchorPointEq = equals(this.anchorPoint, other.anchorPoint);
         return superEq && orientationEq && alignItemsEq && marginEq && anchorPointEq;
-    };
-    AutoLayoutSettings.type = "AutoLayoutSettings";
-    __decorate([
-        Property({ ignore: true }),
-        __metadata("design:type", Object)
-    ], AutoLayoutSettings.prototype, "type", void 0);
-    __decorate([
-        Property({
-            enumObject: __assign({}, AutoLayoutOrientation)
-        }),
-        __metadata("design:type", Object),
-        __metadata("design:paramtypes", [Object])
-    ], AutoLayoutSettings.prototype, "orientation", null);
-    __decorate([
-        Property({
-            enumObject: AutoLayoutAlignItems
-        }),
-        __metadata("design:type", Object),
-        __metadata("design:paramtypes", [Object])
-    ], AutoLayoutSettings.prototype, "alignItems", null);
-    __decorate([
-        Property({
-            enumObject: AutoLayoutJustifyContent
-        }),
-        __metadata("design:type", Object),
-        __metadata("design:paramtypes", [Object])
-    ], AutoLayoutSettings.prototype, "justifyContent", null);
-    __decorate([
-        Property({
-            enumObject: AutoLayoutAnchorPoint
-        }),
-        __metadata("design:type", Number),
-        __metadata("design:paramtypes", [Number])
-    ], AutoLayoutSettings.prototype, "anchorPoint", null);
-    return AutoLayoutSettings;
-}(DefaultLayoutSettings));
-export { AutoLayoutSettings };
+    }
+}
+AutoLayoutSettings.type = "AutoLayoutSettings";
+__decorate([
+    Property({ ignore: true }),
+    __metadata("design:type", Object)
+], AutoLayoutSettings.prototype, "type", void 0);
+__decorate([
+    Property({
+        enumObject: Object.assign({}, AutoLayoutOrientation)
+    }),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], AutoLayoutSettings.prototype, "orientation", null);
+__decorate([
+    Property({
+        enumObject: AutoLayoutAlignItems
+    }),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], AutoLayoutSettings.prototype, "alignItems", null);
+__decorate([
+    Property({
+        enumObject: AutoLayoutJustifyContent
+    }),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], AutoLayoutSettings.prototype, "justifyContent", null);
+__decorate([
+    Property({
+        enumObject: AutoLayoutAnchorPoint
+    }),
+    __metadata("design:type", Number),
+    __metadata("design:paramtypes", [Number])
+], AutoLayoutSettings.prototype, "anchorPoint", null);
 //# sourceMappingURL=LayoutItem.js.map