canvas-editor-engine 2.3.42 → 2.3.44

package/dist/index.mjs

@@ -1388,6 +1388,10 @@ var DrawLayersState = function() {
           case "ADD_LAYER":
             reducer.addLayer(payload);
             break;
+
+          case "REMOVE_LAYER":
+            reducer.removeLayer(payload);
+            break;
         }
     };
     DrawLayersState.prototype.emerge = function(completeIt) {
@@ -1438,6 +1442,21 @@ var Reducer$1 = function() {
             this.state._emergeCompleteIt(this.state._layers);
         }
     };
+    Reducer.prototype.removeLayer = function(payload) {
+        var isUpdate = false;
+        if (!!payload) {
+            var targetLayerIndex = this.state._layers.findIndex((function(layer) {
+                return layer.id === payload.id;
+            }));
+            if (targetLayerIndex != -1) {
+                this.state._layers.splice(targetLayerIndex, 1);
+                isUpdate = true;
+            }
+        }
+        if (isUpdate && !!this.state._emergeCompleteIt) {
+            this.state._emergeCompleteIt(this.state._layers);
+        }
+    };
     Reducer.prototype.popLayer = function() {
         this.state._layers.pop();
         if (!!this.state._emergeCompleteIt) {
@@ -2448,17 +2467,27 @@ var DrawLayersService = function() {
         this.appStoreRepository.store.drawLayersState.reduce("UPDATE_LAYER", layer);
     };
     DrawLayersService.prototype.updateLayer = function(id, updateData) {
-        var layerIndex = this.layerList.findIndex((function(layer) {
-            return layer.id === id;
-        }));
-        var fields = Object.keys(updateData);
-        if (!fields.length || layerIndex === -1) return;
-        var layer = this.layerList[layerIndex];
-        fields.forEach((function(field) {
-            layer[field] = updateData[field];
+        var _this = this;
+        return new Promise((function(resolve, reject) {
+            var layerIndex = _this.layerList.findIndex((function(layer) {
+                return layer.id === id;
+            }));
+            var fields = Object.keys(updateData);
+            if (!fields.length || layerIndex === -1) return reject({
+                status: "error",
+                message: "Layer not found"
+            });
+            var layer = _this.layerList[layerIndex];
+            fields.forEach((function(field) {
+                layer[field] = updateData[field];
+            }));
+            _this.layerList[layerIndex] = layer;
+            _this.appStoreRepository.store.drawLayersState.reduce("UPDATE_LAYER", layer);
+            resolve({
+                status: "success",
+                message: "Layer updated"
+            });
         }));
-        this.layerList[layerIndex] = layer;
-        this.appStoreRepository.store.drawLayersState.reduce("UPDATE_LAYER", layer);
     };
     DrawLayersService.prototype.removePainter = function(id) {
         var layerIndex = this.layerList.findIndex((function(layer) {
@@ -2487,6 +2516,25 @@ var DrawLayersService = function() {
         var layer = this.layerList[layerIndex];
         this.appStoreRepository.store.drawLayersState.reduce("UPDATE_LAYER", layer);
     };
+    DrawLayersService.prototype.removeLayer = function(id) {
+        var _this = this;
+        return new Promise((function(resolve, reject) {
+            var layerIndex = _this.layerList.findIndex((function(layer) {
+                return layer.id === id;
+            }));
+            if (layerIndex === -1) return reject({
+                status: "error",
+                message: "Layer not found"
+            });
+            var layer = _this.layerList[layerIndex];
+            _this.layerList.splice(layerIndex, 1);
+            _this.appStoreRepository.store.drawLayersState.reduce("REMOVE_LAYER", layer);
+            resolve({
+                status: "success",
+                message: "Layer removed"
+            });
+        }));
+    };
     DrawLayersService.prototype.changeLayerOrder = function(id, options) {
         return __awaiter(this, void 0, void 0, (function() {
             var _this = this;
@@ -2633,6 +2681,18 @@ var DrawAccumulatorService = function() {
             }));
         }));
     };
+    DrawAccumulatorService.prototype.getPainterById = function(painterId) {
+        return __awaiter(this, void 0, void 0, (function() {
+            var painter;
+            return __generator(this, (function(_a) {
+                painter = this.painters.find((function(painter) {
+                    return painter.id === painterId;
+                }));
+                if (!painter) throw new Error("Painter not found");
+                return [ 2, painter ];
+            }));
+        }));
+    };
     DrawAccumulatorService.prototype.removePainter = function(painterId) {
         return __awaiter(this, void 0, void 0, (function() {
             var painter, filteredPainters, len;
@@ -2698,6 +2758,49 @@ var DrawAccumulatorService = function() {
             }));
         }));
     };
+    DrawAccumulatorService.prototype.renameLayer = function(id, newName) {
+        return __awaiter(this, void 0, void 0, (function() {
+            var updateData;
+            var _this = this;
+            return __generator(this, (function(_a) {
+                updateData = {
+                    name: newName
+                };
+                this.drawLayersService.updateLayer(id, updateData).then((function(res) {
+                    if (res.status === "success") {
+                        _this.update();
+                    } else {
+                        console.warn(res === null || res === void 0 ? void 0 : res.message);
+                    }
+                })).catch((function(ex) {
+                    console.warn("".concat(ex.status, ": ").concat(ex.message));
+                }));
+                return [ 2 ];
+            }));
+        }));
+    };
+    DrawAccumulatorService.prototype.removeLayer = function(layerId) {
+        return __awaiter(this, void 0, void 0, (function() {
+            var layer;
+            var _this = this;
+            return __generator(this, (function(_a) {
+                layer = this.drawLayersService.getLayerById(layerId);
+                layer.painters.map((function(painter) {
+                    return painter.id;
+                })).forEach((function(painterId) {
+                    _this.removePainter(painterId);
+                }));
+                this.drawLayersService.removeLayer(layerId).then((function(res) {
+                    if (res.status === "success") {
+                        _this.update();
+                    }
+                })).catch((function(ex) {
+                    console.warn("".concat(ex.status, ": ").concat(ex.message));
+                }));
+                return [ 2 ];
+            }));
+        }));
+    };
     DrawAccumulatorService.prototype.updateLayerOrder = function(layerId, options) {
         var _this = this;
         this.drawLayersService.changeLayerOrder(layerId, options).then((function(res) {

package/dist/services/draw-accumulator.service.d.ts

@@ -1,6 +1,6 @@
 import AppConfig from "../config";
 import AppStoreRepository from "../store/storeRepository";
-import { ILayer, IUpdateLayerOptions } from "../types/draw-layers";
+import { ILayer, ILayerUpdate, IUpdateLayerOptions } from "../types/draw-layers";
 import { IPainter, ISmoothFilterOptions, TDrawType } from "../types/draw-service";
 import { ITempCanvasOptions } from "../types/temp-canvas";
 import Painter from "../utils/painter";
@@ -15,9 +15,12 @@ export default class DrawAccumulatorService {
     painters: Painter[];
     constructor(appConfig: AppConfig, appStoreRepository: AppStoreRepository, eventService: EventService, drawLayersService: DrawLayersService);
     add<DrawType extends TDrawType>(layerId: ILayer['id'], drawType: DrawType, options: DrawService['options'][DrawType], initialSize: ITempCanvasOptions): Promise<void>;
+    getPainterById(painterId: string): Promise<Painter>;
     removePainter(painterId: string): Promise<void>;
     renamePainter(painterId: IPainter['id'], name: string): void;
     smoothFilter(painterId: IPainter['id'], smoothFilterOptions: ISmoothFilterOptions): Promise<void>;
+    renameLayer(id: ILayer["id"], newName: ILayerUpdate['name']): Promise<void>;
+    removeLayer(layerId: ILayer['id']): Promise<void>;
     updateLayerOrder(layerId: ILayer['id'], options: IUpdateLayerOptions): void;
     private update;
     private get gradient();

package/dist/services/draw-layers.service.d.ts

@@ -14,8 +14,9 @@ export default class DrawLayersService {
     getLayersByOrder(order: number): ILayer[];
     getLayerById(layerId: ILayer['id']): ILayer;
     addToLayer(id: ILayer['id'], painter: IPainter): void;
-    updateLayer(id: ILayer['id'], updateData?: ILayerUpdate): void;
+    updateLayer(id: ILayer['id'], updateData?: ILayerUpdate): Promise<unknown>;
     removePainter(id: IPainter['id']): void;
     updatePainterData(painter: Painter): void;
+    removeLayer(id: ILayer['id']): Promise<unknown>;
     changeLayerOrder(id: ILayer['id'], options: IUpdateLayerOptions): Promise<unknown>;
 }

package/dist/types/draw-layers.d.ts

@@ -10,7 +10,7 @@ export interface ILayerUpdate {
     order?: ILayer['order'];
     name?: ILayer['name'];
 }
-export type TReducerNames = 'SET_LAYERS' | 'UPDATE_LAYER' | 'ADD_LAYER';
+export type TReducerNames = 'SET_LAYERS' | 'UPDATE_LAYER' | 'ADD_LAYER' | 'REMOVE_LAYER';
 export interface IUpdateLayerOptions {
     to?: number;
     direction?: 'up' | 'down';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canvas-editor-engine",
-  "version": "2.3.42",
+  "version": "2.3.44",
   "description": "CanvasEditorEngine library, use: [typescript] [canvas]",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",