@umituz/react-native-video-editor 1.1.62 → 1.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-video-editor",
-  "version": "1.1.62",
+  "version": "1.1.64",
   "description": "Professional video editor with layer-based timeline, text/image/shape/audio/animation layers, and export functionality",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/base/base-layer-operations.service.ts

@@ -0,0 +1,201 @@
+/**
+ * Base Layer Operations Service
+ * Provides common layer operation logic with type safety
+ * Eliminates code duplication across layer types
+ */
+
+import type { Scene, Layer, LayerOperationResult } from "../../../domain/entities/video-project.types";
+
+/**
+ * Abstract base class for layer operations
+ * Implements template method pattern for layer-specific operations
+ */
+export abstract class BaseLayerOperationsService<T extends Layer> {
+  /**
+   * Create a new layer instance (layer-specific)
+   */
+  protected abstract createLayer(data: unknown): T;
+
+  /**
+   * Validate layer data before creation (layer-specific)
+   */
+  protected abstract validateLayerData(data: unknown): string | null;
+
+  /**
+   * Get the layer type for type checking
+   */
+  protected abstract getLayerType(): T["type"];
+
+  /**
+   * Add layer to scene
+   */
+  addLayer(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerData: unknown,
+  ): LayerOperationResult {
+    try {
+      const validationError = this.validateSceneIndex(scenes, sceneIndex);
+      if (validationError) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: validationError,
+        };
+      }
+
+      const dataValidationError = this.validateLayerData(layerData);
+      if (dataValidationError) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: dataValidationError,
+        };
+      }
+
+      const newLayer = this.createLayer(layerData);
+      const updatedScenes = this.addLayerToScene(scenes, sceneIndex, newLayer);
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error: error instanceof Error ? error.message : "Failed to add layer",
+      };
+    }
+  }
+
+  /**
+   * Edit existing layer
+   */
+  editLayer(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    layerData: Partial<T>,
+  ): LayerOperationResult {
+    try {
+      const validationError = this.validateSceneIndex(scenes, sceneIndex);
+      if (validationError) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: validationError,
+        };
+      }
+
+      const layerResult = this.findLayer(scenes, sceneIndex, layerId);
+      if (!layerResult) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: "Layer not found",
+        };
+      }
+
+      const typeError = this.validateLayerType(layerResult.layer);
+      if (typeError) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: typeError,
+        };
+      }
+
+      const updatedScenes = this.updateLayerInScene(
+        scenes,
+        sceneIndex,
+        layerResult.index,
+        layerData,
+      );
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error: error instanceof Error ? error.message : "Failed to edit layer",
+      };
+    }
+  }
+
+  /**
+   * Validate scene index
+   */
+  protected validateSceneIndex(
+    scenes: Scene[],
+    sceneIndex: number,
+  ): string | null {
+    if (sceneIndex < 0 || sceneIndex >= scenes.length) {
+      return "Invalid scene index";
+    }
+    return null;
+  }
+
+  /**
+   * Find layer by ID
+   */
+  protected findLayer(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+  ): { layer: Layer; index: number } | null {
+    const layerIndex = scenes[sceneIndex].layers.findIndex(
+      (l) => l.id === layerId,
+    );
+
+    if (layerIndex === -1) {
+      return null;
+    }
+
+    return {
+      layer: scenes[sceneIndex].layers[layerIndex],
+      index: layerIndex,
+    };
+  }
+
+  /**
+   * Validate layer type matches service type
+   */
+  protected validateLayerType(layer: Layer): string | null {
+    if (layer.type !== this.getLayerType()) {
+      return `Layer is not a ${this.getLayerType()} layer`;
+    }
+    return null;
+  }
+
+  /**
+   * Add layer to scene (immutable update)
+   */
+  protected addLayerToScene(
+    scenes: Scene[],
+    sceneIndex: number,
+    layer: T,
+  ): Scene[] {
+    const updatedScenes = [...scenes];
+    updatedScenes[sceneIndex] = {
+      ...updatedScenes[sceneIndex],
+      layers: [...updatedScenes[sceneIndex].layers, layer],
+    };
+    return updatedScenes;
+  }
+
+  /**
+   * Update layer in scene (immutable update)
+   */
+  protected updateLayerInScene(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerIndex: number,
+    layerData: Partial<T>,
+  ): Scene[] {
+    const updatedScenes = [...scenes];
+    const existingLayer = updatedScenes[sceneIndex].layers[layerIndex];
+    updatedScenes[sceneIndex].layers[layerIndex] = {
+      ...existingLayer,
+      ...layerData,
+    };
+    return updatedScenes;
+  }
+}

package/src/infrastructure/services/image-layer-operations.service.ts

@@ -4,122 +4,57 @@
  */
 
 import { generateUUID } from "@umituz/react-native-design-system/uuid";
-import type { Scene, ImageLayer } from "../../domain/entities/video-project.types";
+import type { ImageLayer, Scene } from "../../domain/entities/video-project.types";
 import type { LayerOperationResult, AddImageLayerData } from "../../domain/entities/video-project.types";
+import { BaseLayerOperationsService } from "./base/base-layer-operations.service";
+
+class ImageLayerOperationsService extends BaseLayerOperationsService<ImageLayer> {
+  protected createLayer(data: unknown): ImageLayer {
+    const layerData = data as AddImageLayerData;
+
+    return {
+      id: generateUUID(),
+      type: "image",
+      uri: layerData.uri ?? "",
+      position: { x: 15, y: 30 },
+      size: { width: 70, height: 40 },
+      rotation: 0,
+      opacity: layerData.opacity ?? 1,
+      animation: {
+        type: "fade",
+        duration: 500,
+        easing: "ease-in-out",
+      },
+    };
+  }
+
+  protected validateLayerData(data: unknown): string | null {
+    const layerData = data as AddImageLayerData;
+    if (!layerData.uri || layerData.uri.trim().length === 0) {
+      return "Image URI is required";
+    }
+    return null;
+  }
+
+  protected getLayerType(): ImageLayer["type"] {
+    return "image";
+  }
 
-class ImageLayerOperationsService {
-  /**
-   * Add image layer to scene
-   */
   addImageLayer(
     scenes: Scene[],
     sceneIndex: number,
     layerData: AddImageLayerData,
   ): LayerOperationResult {
-    try {
-      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Invalid scene index",
-        };
-      }
-
-      // Validate URI
-      if (!layerData.uri || layerData.uri.trim().length === 0) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Image URI is required",
-        };
-      }
-
-      const newLayer: ImageLayer = {
-        id: generateUUID(),
-        type: "image",
-        uri: layerData.uri ?? "",
-        position: { x: 15, y: 30 },
-        size: { width: 70, height: 40 },
-        rotation: 0,
-        opacity: layerData.opacity ?? 1,
-        animation: {
-          type: "fade",
-          duration: 500,
-          easing: "ease-in-out",
-        },
-      };
-
-      const updatedScenes = [...scenes];
-      updatedScenes[sceneIndex] = {
-        ...updatedScenes[sceneIndex],
-        layers: [...updatedScenes[sceneIndex].layers, newLayer],
-      };
-
-      return { success: true, updatedScenes };
-    } catch (error) {
-      return {
-        success: false,
-        updatedScenes: scenes,
-        error:
-          error instanceof Error ? error.message : "Failed to add image layer",
-      };
-    }
+    return this.addLayer(scenes, sceneIndex, layerData);
   }
 
-  /**
-   * Edit image layer
-   */
   editImageLayer(
     scenes: Scene[],
     sceneIndex: number,
     layerId: string,
     layerData: Partial<ImageLayer>,
   ): LayerOperationResult {
-    try {
-      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Invalid scene index",
-        };
-      }
-
-      const updatedScenes = [...scenes];
-      const layerIndex = updatedScenes[sceneIndex].layers.findIndex(
-        (l) => l.id === layerId,
-      );
-
-      if (layerIndex === -1) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Layer not found",
-        };
-      }
-
-      const existingLayer = updatedScenes[sceneIndex].layers[layerIndex];
-      if (existingLayer.type !== "image") {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Layer is not an image layer",
-        };
-      }
-
-      updatedScenes[sceneIndex].layers[layerIndex] = {
-        ...existingLayer,
-        ...layerData,
-      };
-
-      return { success: true, updatedScenes };
-    } catch (error) {
-      return {
-        success: false,
-        updatedScenes: scenes,
-        error:
-          error instanceof Error ? error.message : "Failed to edit image layer",
-      };
-    }
+    return this.editLayer(scenes, sceneIndex, layerId, layerData);
   }
 }
 

package/src/infrastructure/services/shape-layer-operations.service.ts

@@ -4,61 +4,52 @@
  */
 
 import { generateUUID } from "@umituz/react-native-design-system/uuid";
-import type { Scene, ShapeLayer } from "../../domain/entities/video-project.types";
+import type { ShapeLayer, Scene } from "../../domain/entities/video-project.types";
 import type { LayerOperationResult, AddShapeLayerData } from "../../domain/entities/video-project.types";
+import { BaseLayerOperationsService } from "./base/base-layer-operations.service";
+
+interface ShapeLayerDataWithDefault extends AddShapeLayerData {
+  defaultColor: string;
+}
+
+class ShapeLayerOperationsService extends BaseLayerOperationsService<ShapeLayer> {
+  protected createLayer(data: unknown): ShapeLayer {
+    const { defaultColor, ...layerData } = data as ShapeLayerDataWithDefault;
+
+    return {
+      id: generateUUID(),
+      type: "shape",
+      shape: (layerData.shape ?? "rectangle") as ShapeLayer["shape"],
+      position: { x: 25, y: 25 },
+      size: { width: 50, height: 50 },
+      rotation: 0,
+      opacity: layerData.opacity ?? 1,
+      fillColor: layerData.fillColor ?? defaultColor,
+      borderColor: layerData.borderColor,
+      borderWidth: layerData.borderWidth,
+      animation: {
+        type: "fade",
+        duration: 500,
+        easing: "ease-in-out",
+      },
+    };
+  }
+
+  protected validateLayerData(): string | null {
+    return null;
+  }
+
+  protected getLayerType(): ShapeLayer["type"] {
+    return "shape";
+  }
 
-class ShapeLayerOperationsService {
-  /**
-   * Add shape layer to scene
-   */
   addShapeLayer(
     scenes: Scene[],
     sceneIndex: number,
     layerData: AddShapeLayerData,
     defaultColor: string,
   ): LayerOperationResult {
-    try {
-      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Invalid scene index",
-        };
-      }
-
-      const newLayer: ShapeLayer = {
-        id: generateUUID(),
-        type: "shape",
-        shape: (layerData.shape ?? "rectangle") as ShapeLayer["shape"],
-        position: { x: 25, y: 25 },
-        size: { width: 50, height: 50 },
-        rotation: 0,
-        opacity: layerData.opacity ?? 1,
-        fillColor: layerData.fillColor ?? defaultColor,
-        borderColor: layerData.borderColor,
-        borderWidth: layerData.borderWidth,
-        animation: {
-          type: "fade",
-          duration: 500,
-          easing: "ease-in-out",
-        },
-      };
-
-      const updatedScenes = [...scenes];
-      updatedScenes[sceneIndex] = {
-        ...updatedScenes[sceneIndex],
-        layers: [...updatedScenes[sceneIndex].layers, newLayer],
-      };
-
-      return { success: true, updatedScenes };
-    } catch (error) {
-      return {
-        success: false,
-        updatedScenes: scenes,
-        error:
-          error instanceof Error ? error.message : "Failed to add shape layer",
-      };
-    }
+    return this.addLayer(scenes, sceneIndex, { ...layerData, defaultColor });
   }
 }
 

package/src/infrastructure/services/text-layer-operations.service.ts

@@ -4,119 +4,67 @@
  */
 
 import { generateUUID } from "@umituz/react-native-design-system/uuid";
-import type { Scene, TextLayer } from "../../domain/entities/video-project.types";
+import type { TextLayer, Scene } from "../../domain/entities/video-project.types";
 import type { LayerOperationResult, AddTextLayerData } from "../../domain/entities/video-project.types";
+import { BaseLayerOperationsService } from "./base/base-layer-operations.service";
+
+interface TextLayerDataWithDefault extends AddTextLayerData {
+  defaultColor: string;
+}
+
+class TextLayerOperationsService extends BaseLayerOperationsService<TextLayer> {
+  protected createLayer(data: unknown): TextLayer {
+    const { defaultColor, ...layerData } = data as TextLayerDataWithDefault;
+
+    return {
+      id: generateUUID(),
+      type: "text",
+      content: layerData.content || "",
+      position: { x: 10, y: 40 },
+      size: { width: 80, height: 20 },
+      rotation: 0,
+      opacity: 1,
+      fontSize: layerData.fontSize || 48,
+      fontFamily: layerData.fontFamily || "System",
+      fontWeight: (layerData.fontWeight as TextLayer["fontWeight"]) || "bold",
+      color: layerData.color || defaultColor,
+      textAlign: layerData.textAlign || "center",
+      animation: {
+        type: "fade",
+        duration: 500,
+        easing: "ease-in-out",
+      },
+    };
+  }
+
+  protected validateLayerData(data: unknown): string | null {
+    const layerData = data as AddTextLayerData;
+    if (!layerData.content || layerData.content.trim().length === 0) {
+      return "Text content is required";
+    }
+    return null;
+  }
+
+  protected getLayerType(): TextLayer["type"] {
+    return "text";
+  }
 
-class TextLayerOperationsService {
-  /**
-   * Add text layer to scene
-   */
   addTextLayer(
     scenes: Scene[],
     sceneIndex: number,
     layerData: AddTextLayerData,
     defaultColor: string,
   ): LayerOperationResult {
-    try {
-      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Invalid scene index",
-        };
-      }
-
-      const newLayer: TextLayer = {
-        id: generateUUID(),
-        type: "text",
-        content: layerData.content || "",
-        position: { x: 10, y: 40 },
-        size: { width: 80, height: 20 },
-        rotation: 0,
-        opacity: 1,
-        fontSize: layerData.fontSize || 48,
-        fontFamily: layerData.fontFamily || "System",
-        fontWeight: (layerData.fontWeight as TextLayer["fontWeight"]) || "bold",
-        color: layerData.color || defaultColor,
-        textAlign: layerData.textAlign || "center",
-        animation: {
-          type: "fade",
-          duration: 500,
-          easing: "ease-in-out",
-        },
-      };
-
-      const updatedScenes = [...scenes];
-      updatedScenes[sceneIndex] = {
-        ...updatedScenes[sceneIndex],
-        layers: [...updatedScenes[sceneIndex].layers, newLayer],
-      };
-
-      return { success: true, updatedScenes };
-    } catch (error) {
-      return {
-        success: false,
-        updatedScenes: scenes,
-        error:
-          error instanceof Error ? error.message : "Failed to add text layer",
-      };
-    }
+    return this.addLayer(scenes, sceneIndex, { ...layerData, defaultColor });
   }
 
-  /**
-   * Edit text layer
-   */
   editTextLayer(
     scenes: Scene[],
     sceneIndex: number,
     layerId: string,
     layerData: Partial<TextLayer>,
   ): LayerOperationResult {
-    try {
-      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Invalid scene index",
-        };
-      }
-
-      const updatedScenes = [...scenes];
-      const layerIndex = updatedScenes[sceneIndex].layers.findIndex(
-        (l) => l.id === layerId,
-      );
-
-      if (layerIndex === -1) {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Layer not found",
-        };
-      }
-
-      const existingLayer = updatedScenes[sceneIndex].layers[layerIndex];
-      if (existingLayer.type !== "text") {
-        return {
-          success: false,
-          updatedScenes: scenes,
-          error: "Layer is not a text layer",
-        };
-      }
-
-      updatedScenes[sceneIndex].layers[layerIndex] = {
-        ...existingLayer,
-        ...layerData,
-      };
-
-      return { success: true, updatedScenes };
-    } catch (error) {
-      return {
-        success: false,
-        updatedScenes: scenes,
-        error:
-          error instanceof Error ? error.message : "Failed to edit text layer",
-      };
-    }
+    return this.editLayer(scenes, sceneIndex, layerId, layerData);
   }
 }