@aurigma/design-atoms-model/Product/Items/GroupItem.js

Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.

import { Item } from "./Item";
import { Collection } from "../../Collection";
import { GroupItemPermissions } from "./GroupItemPermissions";
import { ArgumentException } from "../../Exception";
import { equals } from "../../Utils/Utils";
import { arraysIsEqual } from "@aurigma/utils-js/algorithms/array";
export class GroupItem extends Item {
    constructor(items) {
        super();
        this.items = new Collection();
        this.type = GroupItem.type;
        this.groupItemPermissions = new GroupItemPermissions();
        this._ignorePermissionsChange = true;
        this._groupItemPermissions.allowReplaceContent = false;
        this._ignorePermissionsChange = false;
        this.items.add_itemAdded(collectionItem => {
            collectionItem.item.parentGroupItem = this;
            this._propertyChanged.notify(this, "items");
        });
        this.items.add_itemRemoved(collectionItem => {
            collectionItem.item.parentGroupItem = null;
            this._propertyChanged.notify(this, "items");
        });
        if (items != null)
            this.items.addRange(items);
    }
    get groupItemPermissions() {
        return this._groupItemPermissions;
    }
    set groupItemPermissions(value) {
        if (value == null)
            throw new ArgumentException("groupItemPermissions cannot be null");
        if (equals(this._groupItemPermissions, value))
            return;
        if (this._groupItemPermissions != null)
            this._groupItemPermissions.propertyChanged.remove(this._onPermissionsChanged);
        this._groupItemPermissions = value;
        this._groupItemPermissions.propertyChanged.add(this._onPermissionsChanged);
        this._onPermissionsChanged();
    }
    addItems(items, targetIndex) {
        if (targetIndex != null)
            items = items.reverse();
        if (items == null || items.length === 0)
            return;
        if (targetIndex != null && targetIndex > -1)
            this.items.insertAt(targetIndex, items);
        else
            this.items.add(...items);
    }
    _onContainerChanged() {
        this.applyToItems((item) => {
            item.parentContainer = this.parentContainer;
        });
    }
    addItem(item, targetIndex) {
        if (targetIndex != null && targetIndex > -1)
            this.items.insertAt(targetIndex, item);
        else
            this.items.add(item);
    }
    removeItems(items) {
        if (items != null && items.length > 0)
            for (let item of items)
                this.items.remove(item);
    }
    getNestedItems(excludeGroupItems = false) {
        const allNestedItems = [];
        const items = [...this.items];
        while (items.length > 0) {
            const item = items.shift();
            if (item instanceof GroupItem) {
                items.splice(items.indexOf(item), 0, ...item.items);
                if (excludeGroupItems)
                    continue;
            }
            allNestedItems.push(item);
        }
        return allNestedItems;
    }
    getSimplifiedObject(omitProperties = []) {
        const simplified = super.getSimplifiedObject([
            "groupManipulationPermissions",
            "itemRemovedEvent",
            "groupItemPermissions",
            "items"
        ].concat(omitProperties));
        simplified["items"] = this.items.toArray().map(item => item.getSimplifiedObject());
        simplified["groupItemPermissions"] = this.groupItemPermissions.getSimplifiedObject();
        return simplified;
    }
    _copy(source, destination, generateNewIds, appropriateParentContainer) {
        super._copy(source, destination, generateNewIds, appropriateParentContainer);
        if (source.items.length <= 0)
            return;
        const items = source.items.toArray().map(item => item.clone(generateNewIds, appropriateParentContainer));
        destination.items.clear();
        destination.items.addRange(items);
        destination.groupItemPermissions = source.groupItemPermissions.clone();
    }
    clone(generateNewIds = false, appropriateParentContainer = false) {
        const item = new GroupItem();
        this._copy(this, item, generateNewIds, appropriateParentContainer);
        return item;
    }
    applyPermissionsConstrain() {
        super.applyPermissionsConstrain();
        this.itemPermissions.itemToolbarPermissions.showEditButton = false;
        this.itemPermissions.itemToolbarPermissions.showSelectButton = false;
    }
    applyToItems(func) {
        this.items.forEach(func);
    }
    get manipulationPermissions() {
        if (this.items.length === 0)
            return this.groupManipulationPermissions;
        const manipulationPermissions = this.groupManipulationPermissions.clone();
        this.getNestedItems(true).forEach((item) => {
            manipulationPermissions.allowDelete = manipulationPermissions.allowDelete && item.manipulationPermissions.allowDelete;
        });
        Object.freeze(manipulationPermissions);
        return manipulationPermissions;
    }
    set manipulationPermissions(value) {
        throw new Error("You cannot use ManipulationPermissions setter with GroupItem. Use groupManipulationPermissions setter instead");
    }
    get groupManipulationPermissions() {
        return super.getManipulationPermissions();
    }
    set groupManipulationPermissions(value) {
        super.setManipulationPermissions(value);
    }
    isChildVisible(child) {
        return true;
    }
    equals(other) {
        const superEq = super.equals(other);
        const groupItemPermissionsEq = equals(this.groupItemPermissions, other.groupItemPermissions);
        const itemsEq = arraysIsEqual([...this.items], [...other.items], equals);
        return superEq && groupItemPermissionsEq && itemsEq;
    }
}
GroupItem.type = "GroupItem";
//# sourceMappingURL=GroupItem.js.map