@umituz/react-native-video-editor 1.0.1

package/src/infrastructure/services/export-orchestrator.service.ts

@@ -0,0 +1,122 @@
+/**
+ * Export Orchestrator Service
+ * Handles export business logic and notifications
+ */
+
+import * as Device from "expo-device";
+import { Alert } from "react-native";
+import { notificationService } from "@umituz/react-native-notifications";
+import {
+  videoExportService,
+  ExportProgress,
+} from "@domains/video/infrastructure/services/video-export.service";
+import type { ExportSettings, VideoProject } from "@domains/video";
+
+export interface ExportResult {
+  success: boolean;
+  uri?: string;
+  error?: string;
+}
+
+export interface ExportOrchestratorService {
+  exportVideo: (
+    project: VideoProject,
+    settings: ExportSettings,
+    onProgress: (progress: ExportProgress) => void,
+  ) => Promise<ExportResult>;
+  requestNotificationPermissions: () => Promise<void>;
+}
+
+class ExportOrchestratorServiceImpl implements ExportOrchestratorService {
+  async requestNotificationPermissions(): Promise<void> {
+    if (Device.isDevice) {
+      await notificationService.requestPermissions();
+    }
+  }
+
+  async exportVideo(
+    project: VideoProject,
+    settings: ExportSettings,
+    onProgress: (progress: ExportProgress) => void,
+  ): Promise<ExportResult> {
+    const projectToExport: VideoProject = {
+      ...project,
+      exportSettings: settings,
+    };
+
+    try {
+      const result = await videoExportService.exportVideo(
+        projectToExport,
+        onProgress,
+      );
+
+      if (result.success) {
+        await this.showSuccessNotification(project.title, result.uri);
+        this.showSuccessAlert();
+        return { success: true, uri: result.uri };
+      } else {
+        await this.showFailureNotification(project.title, result.error);
+        this.showFailureAlert(result.error);
+        return { success: false, error: result.error };
+      }
+    } catch (error) {
+      await this.showFailureNotification(
+        project.title,
+        "An unexpected error occurred",
+      );
+      this.showFailureAlert("An unexpected error occurred");
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  }
+
+  private async showSuccessNotification(
+    projectTitle: string,
+    uri?: string,
+  ): Promise<void> {
+    if (!Device.isDevice) return;
+
+    try {
+      await notificationService.notifications.scheduleNotification({
+        title: "Export Complete",
+        body: `${projectTitle} has been exported successfully!`,
+        trigger: { type: "date", date: new Date() },
+        data: { uri: uri || "" },
+      });
+    } catch (error) {
+      // Silent failure - notification is optional
+    }
+  }
+
+  private async showFailureNotification(
+    projectTitle: string,
+    error?: string,
+  ): Promise<void> {
+    if (!Device.isDevice) return;
+
+    try {
+      await notificationService.notifications.scheduleNotification({
+        title: "Export Failed",
+        body: `Failed to export ${projectTitle}: ${error || "Unknown error"}`,
+        trigger: { type: "date", date: new Date() },
+      });
+    } catch (error) {
+      // Silent failure - notification is optional
+    }
+  }
+
+  private showSuccessAlert(): void {
+    Alert.alert(
+      "Export Complete",
+      "Your video has been exported successfully!",
+    );
+  }
+
+  private showFailureAlert(error?: string): void {
+    Alert.alert("Export Failed", error || "An error occurred during export");
+  }
+}
+
+export const exportOrchestratorService = new ExportOrchestratorServiceImpl();

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

@@ -0,0 +1,108 @@
+/**
+ * Image Layer Operations Service
+ * Single Responsibility: Image layer business logic
+ */
+
+import { generateUUID } from "@umituz/react-native-uuid";
+import type { Scene, ImageLayer } from "@domains/video";
+import type { LayerOperationResult, AddImageLayerData } from "../../types";
+
+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",
+        };
+      }
+
+      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",
+      };
+    }
+  }
+
+  /**
+   * 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",
+        };
+      }
+
+      updatedScenes[sceneIndex].layers[layerIndex] = {
+        ...updatedScenes[sceneIndex].layers[layerIndex],
+        ...layerData,
+      } as ImageLayer;
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error:
+          error instanceof Error ? error.message : "Failed to edit image layer",
+      };
+    }
+  }
+}
+
+export const imageLayerOperationsService = new ImageLayerOperationsService();

package/src/infrastructure/services/layer-manipulation.service.ts

@@ -0,0 +1,93 @@
+/**
+ * Layer Manipulation Service
+ * Orchestrator service that delegates to specialized layer operation services
+ */
+
+import type { Scene, Animation } from "@domains/video";
+import type { LayerOperationResult, LayerOrderAction } from "../../types";
+import {
+  layerDeleteService,
+  layerOrderService,
+  layerDuplicateService,
+  layerTransformService,
+} from "./layer-operations";
+
+class LayerManipulationService {
+  deleteLayer(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+  ): LayerOperationResult {
+    return layerDeleteService.deleteLayer(scenes, sceneIndex, layerId);
+  }
+
+  changeLayerOrder(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    action: LayerOrderAction,
+  ): LayerOperationResult {
+    return layerOrderService.changeLayerOrder(
+      scenes,
+      sceneIndex,
+      layerId,
+      action,
+    );
+  }
+
+  duplicateLayer(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+  ): LayerOperationResult {
+    return layerDuplicateService.duplicateLayer(scenes, sceneIndex, layerId);
+  }
+
+  updateLayerPosition(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    x: number,
+    y: number,
+  ): LayerOperationResult {
+    return layerTransformService.updateLayerPosition(
+      scenes,
+      sceneIndex,
+      layerId,
+      x,
+      y,
+    );
+  }
+
+  updateLayerSize(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    width: number,
+    height: number,
+  ): LayerOperationResult {
+    return layerTransformService.updateLayerSize(
+      scenes,
+      sceneIndex,
+      layerId,
+      width,
+      height,
+    );
+  }
+
+  updateLayerAnimation(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    animation: Animation | undefined,
+  ): LayerOperationResult {
+    return layerTransformService.updateLayerAnimation(
+      scenes,
+      sceneIndex,
+      layerId,
+      animation,
+    );
+  }
+}
+
+export const layerManipulationService = new LayerManipulationService();

package/src/infrastructure/services/layer-operations/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Layer Operations
+ * Barrel file for all layer operation services
+ */
+
+export * from "./layer-delete.service";
+export * from "./layer-order.service";
+export * from "./layer-duplicate.service";
+export * from "./layer-transform.service";

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

@@ -0,0 +1,47 @@
+/**
+ * Layer Delete Service
+ * Single Responsibility: Handle layer deletion operations
+ */
+
+import type { Scene } from "@domains/video";
+import type { LayerOperationResult } from "../../../types";
+
+class LayerDeleteService {
+  /**
+   * Delete layer from scene
+   */
+  deleteLayer(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+  ): LayerOperationResult {
+    try {
+      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: "Invalid scene index",
+        };
+      }
+
+      const updatedScenes = [...scenes];
+      updatedScenes[sceneIndex] = {
+        ...updatedScenes[sceneIndex],
+        layers: updatedScenes[sceneIndex].layers.filter(
+          (l) => l.id !== layerId,
+        ),
+      };
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error:
+          error instanceof Error ? error.message : "Failed to delete layer",
+      };
+    }
+  }
+}
+
+export const layerDeleteService = new LayerDeleteService();

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

@@ -0,0 +1,66 @@
+/**
+ * Layer Duplicate Service
+ * Single Responsibility: Handle layer duplication operations
+ */
+
+import { generateUUID } from "@umituz/react-native-uuid";
+import type { Scene } from "@domains/video";
+import type { LayerOperationResult } from "../../../types";
+
+class LayerDuplicateService {
+  /**
+   * Duplicate layer
+   */
+  duplicateLayer(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+  ): LayerOperationResult {
+    try {
+      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: "Invalid scene index",
+        };
+      }
+
+      const updatedScenes = [...scenes];
+      const layers = updatedScenes[sceneIndex].layers;
+      const layerToDuplicate = layers.find((l) => l.id === layerId);
+
+      if (!layerToDuplicate) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: "Layer not found",
+        };
+      }
+
+      const duplicatedLayer = {
+        ...JSON.parse(JSON.stringify(layerToDuplicate)),
+        id: generateUUID(),
+        position: {
+          x: layerToDuplicate.position.x + 5,
+          y: layerToDuplicate.position.y + 5,
+        },
+      };
+
+      updatedScenes[sceneIndex] = {
+        ...updatedScenes[sceneIndex],
+        layers: [...layers, duplicatedLayer],
+      };
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error:
+          error instanceof Error ? error.message : "Failed to duplicate layer",
+      };
+    }
+  }
+}
+
+export const layerDuplicateService = new LayerDuplicateService();

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

@@ -0,0 +1,82 @@
+/**
+ * Layer Order Service
+ * Single Responsibility: Handle layer ordering operations
+ */
+
+import type { Scene } from "@domains/video";
+import type { LayerOperationResult, LayerOrderAction } from "../../../types";
+
+class LayerOrderService {
+  /**
+   * Change layer order
+   */
+  changeLayerOrder(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    action: LayerOrderAction,
+  ): LayerOperationResult {
+    try {
+      if (sceneIndex < 0 || sceneIndex >= scenes.length) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: "Invalid scene index",
+        };
+      }
+
+      const updatedScenes = [...scenes];
+      const scene = updatedScenes[sceneIndex];
+      const layerIndex = scene.layers.findIndex((l) => l.id === layerId);
+
+      if (layerIndex === -1) {
+        return {
+          success: false,
+          updatedScenes: scenes,
+          error: "Layer not found",
+        };
+      }
+
+      const updatedLayers = [...scene.layers];
+      let newIndex = layerIndex;
+
+      switch (action) {
+        case "front":
+          newIndex = updatedLayers.length - 1;
+          break;
+        case "back":
+          newIndex = 0;
+          break;
+        case "up":
+          newIndex = Math.min(layerIndex + 1, updatedLayers.length - 1);
+          break;
+        case "down":
+          newIndex = Math.max(layerIndex - 1, 0);
+          break;
+      }
+
+      if (newIndex !== layerIndex) {
+        const [layer] = updatedLayers.splice(layerIndex, 1);
+        updatedLayers.splice(newIndex, 0, layer);
+      }
+
+      updatedScenes[sceneIndex] = {
+        ...scene,
+        layers: updatedLayers,
+      };
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error:
+          error instanceof Error
+            ? error.message
+            : "Failed to change layer order",
+      };
+    }
+  }
+}
+
+export const layerOrderService = new LayerOrderService();

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

@@ -0,0 +1,160 @@
+/**
+ * Layer Transform Service
+ * Single Responsibility: Handle layer position, size, and animation updates
+ */
+
+import type { Scene, Animation, Layer } from "@domains/video";
+import type { LayerOperationResult } from "../../../types";
+
+class LayerTransformService {
+  /**
+   * Update layer position
+   */
+  updateLayerPosition(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    x: number,
+    y: number,
+  ): 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",
+        };
+      }
+
+      updatedScenes[sceneIndex].layers[layerIndex] = {
+        ...updatedScenes[sceneIndex].layers[layerIndex],
+        position: { x, y },
+      };
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error:
+          error instanceof Error
+            ? error.message
+            : "Failed to update layer position",
+      };
+    }
+  }
+
+  /**
+   * Update layer size
+   */
+  updateLayerSize(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    width: number,
+    height: number,
+  ): 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",
+        };
+      }
+
+      updatedScenes[sceneIndex].layers[layerIndex] = {
+        ...updatedScenes[sceneIndex].layers[layerIndex],
+        size: { width, height },
+      };
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error:
+          error instanceof Error
+            ? error.message
+            : "Failed to update layer size",
+      };
+    }
+  }
+
+  /**
+   * Update layer animation
+   */
+  updateLayerAnimation(
+    scenes: Scene[],
+    sceneIndex: number,
+    layerId: string,
+    animation: Animation | undefined,
+  ): 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",
+        };
+      }
+
+      updatedScenes[sceneIndex].layers[layerIndex] = {
+        ...updatedScenes[sceneIndex].layers[layerIndex],
+        animation,
+      } as Layer;
+
+      return { success: true, updatedScenes };
+    } catch (error) {
+      return {
+        success: false,
+        updatedScenes: scenes,
+        error:
+          error instanceof Error
+            ? error.message
+            : "Failed to update layer animation",
+      };
+    }
+  }
+}
+
+export const layerTransformService = new LayerTransformService();