@contrail/documents 1.1.9 → 1.1.11

package/lib/components/color-component.service.js

@@ -4,8 +4,8 @@ exports.ColorComponentService = void 0;
 const document_element_constants_1 = require("../document-element-constants");
 class ColorComponentService {
     static isColorComponent(element) {
-        var _a, _b;
-        return element && element.type === 'component' && ((_a = element.modelBindings) === null || _a === void 0 ? void 0 : _a.color) && !((_b = element.modelBindings) === null || _b === void 0 ? void 0 : _b.item);
+        var _a;
+        return element && element.type === 'component' && ((_a = element.modelBindings) === null || _a === void 0 ? void 0 : _a.color);
     }
     static isColorHexComponent(element) {
         var _a;

package/lib/document-element-sort-order.service.d.ts

@@ -0,0 +1,17 @@
+import { DocumentElement } from './types';
+export interface SortOrderChange {
+    sortIds: string[] | {
+        id: string;
+        index: number;
+    }[];
+    addAfterElementId?: string;
+    targetSortIndex?: number;
+}
+export declare class DocumentElementSortOrderService {
+    private static removeSortIdsFromSortOrder;
+    static updateSortOrder(sortOrder: string[], { sortIds, targetSortIndex, addAfterElementId }: SortOrderChange): string[];
+    static updateSortOrderByArray(sortOrder: string[], sorts: SortOrderChange[]): string[];
+    static sortDocumentElements(elements: DocumentElement[], sorts?: SortOrderChange[], sort?: SortOrderChange): DocumentElement[];
+    private static addFrameMembersToSortArray;
+    private static addFrameMembersToSort;
+}

package/lib/document-element-sort-order.service.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentElementSortOrderService = void 0;
+class DocumentElementSortOrderService {
+    static removeSortIdsFromSortOrder(sortOrder, sortIds) {
+        sortIds.forEach((id) => {
+            const sourceSortIndex = sortOrder.indexOf(id);
+            if (sourceSortIndex > -1) {
+                sortOrder.splice(sourceSortIndex, 1);
+            }
+        });
+    }
+    static updateSortOrder(sortOrder, { sortIds, targetSortIndex, addAfterElementId }) {
+        if (addAfterElementId) {
+            sortIds = sortIds;
+            this.removeSortIdsFromSortOrder(sortOrder, sortIds);
+            const lastIndex = sortOrder.lastIndexOf(addAfterElementId);
+            if (lastIndex > -1) {
+                sortOrder.splice(lastIndex + 1, 0, ...sortIds);
+            }
+            else {
+                sortOrder.push(...sortIds);
+            }
+        }
+        else if (targetSortIndex != null && targetSortIndex >= 0) {
+            sortIds = sortIds;
+            this.removeSortIdsFromSortOrder(sortOrder, sortIds);
+            sortOrder.splice(targetSortIndex, 0, ...sortIds);
+        }
+        else if (targetSortIndex === -1) {
+            this.removeSortIdsFromSortOrder(sortOrder, sortIds);
+        }
+        else {
+            sortIds = sortIds;
+            const sortedMoves = [...sortIds].sort((a, b) => a.index - b.index);
+            const newSortOrder = [...sortOrder];
+            sortedMoves.forEach((sortId) => {
+                const currentIndex = newSortOrder.indexOf(sortId.id);
+                if (currentIndex > -1) {
+                    newSortOrder.splice(currentIndex, 1);
+                }
+            });
+            sortedMoves.forEach((sortId) => {
+                if (sortId.index <= newSortOrder.length) {
+                    newSortOrder.splice(sortId.index, 0, sortId.id);
+                }
+                else {
+                    newSortOrder.push(sortId.id);
+                }
+            });
+            sortOrder = newSortOrder;
+        }
+        return sortOrder;
+    }
+    static updateSortOrderByArray(sortOrder, sorts) {
+        for (const sort of sorts) {
+            sortOrder = this.updateSortOrder(sortOrder, sort);
+        }
+        return sortOrder;
+    }
+    static sortDocumentElements(elements, sorts, sort) {
+        if (!(elements === null || elements === void 0 ? void 0 : elements.length) || (!(sorts === null || sorts === void 0 ? void 0 : sorts.length) && !sort))
+            return elements;
+        let newSortOrder = [];
+        if ((sorts === null || sorts === void 0 ? void 0 : sorts.length) > 0) {
+            newSortOrder = this.updateSortOrderByArray(elements.map((element) => element.id), sorts);
+        }
+        else if (sort) {
+            newSortOrder = this.updateSortOrder(elements.map((element) => element.id), sort);
+        }
+        const newSortOrderIndexMap = new Map(newSortOrder.map((id, index) => [id, index]));
+        const lastIndex = elements.length;
+        return elements.sort((a, b) => {
+            var _a, _b;
+            const aIdx = (_a = newSortOrderIndexMap.get(a.id)) !== null && _a !== void 0 ? _a : lastIndex;
+            const bIdx = (_b = newSortOrderIndexMap.get(b.id)) !== null && _b !== void 0 ? _b : lastIndex;
+            return aIdx - bIdx;
+        });
+    }
+    static addFrameMembersToSortArray(elements, frames, sorts) {
+        for (const sort of sorts) {
+            sort.sortIds = this.addFrameMembersToSort(elements, frames, sort);
+        }
+        return sorts;
+    }
+    static addFrameMembersToSort(elements, frames, sort) {
+        var _a;
+        const sortIds = sort.sortIds;
+        if ((elements === null || elements === void 0 ? void 0 : elements.length) > 0 && (frames === null || frames === void 0 ? void 0 : frames.size) > 0) {
+            const elementsMap = new Map(elements.map((element) => [element.id, element]));
+            if (sort.targetSortIndex != null || sort.addAfterElementId != null) {
+                const frameIds = sortIds.filter((id) => { var _a; return ((_a = elementsMap.get(id)) === null || _a === void 0 ? void 0 : _a.type) === 'frame'; });
+                if ((frameIds === null || frameIds === void 0 ? void 0 : frameIds.length) > 0) {
+                    for (const frameId of frameIds) {
+                        const frame = frames.get(frameId);
+                        const frameMemberIds = (_a = frame === null || frame === void 0 ? void 0 : frame.elements) === null || _a === void 0 ? void 0 : _a.map((e) => e.id);
+                        if (frame && (frameMemberIds === null || frameMemberIds === void 0 ? void 0 : frameMemberIds.length) > 0) {
+                            this.removeSortIdsFromSortOrder(sortIds, frameMemberIds);
+                            sortIds.splice(sortIds.indexOf(frameId) + 1, 0, ...frameMemberIds);
+                        }
+                    }
+                }
+            }
+        }
+        return sortIds;
+    }
+}
+exports.DocumentElementSortOrderService = DocumentElementSortOrderService;

package/lib/types/document-change.d.ts

@@ -1,3 +1,4 @@
+import { SortOrderChange } from '../document-element-sort-order.service';
 import { DocumentElement } from './document-element';
 export declare enum DocumentChangeType {
     ADD_ELEMENT = "ADD_ELEMENT",
@@ -11,6 +12,7 @@ export interface DocumentChange {
     changeType: DocumentChangeType;
     documentId?: string;
     elementData?: DocumentElement;
+    sortData?: SortOrderChange[];
     elementId?: string;
     documentGenerationConfig?: any;
     backingAssortmentItemData?: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/documents",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "description": "Documents library for contrail platform",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",