@honem/native-video-compressor 0.1.0 → 0.2.1

package/README.md

@@ -1,14 +1,9 @@
 # @honem/native-video-compressor
 
-Capacitor plugin for video compression using native platform APIs (iOS AVFoundation, Android MediaCodec, Electron FFmpeg).
+Capacitor plugin for video compression using native platform APIs.
 
-## Features
-
-- ✅ **Native Performance**: Uses platform-native APIs for optimal performance
-- ✅ **Multiple Formats**: Supports MP4, MOV, M4V, 3GP, and WebM
-- ✅ **Configurable Quality**: Low, Medium, High, and Custom quality presets
-- ✅ **Progress Tracking**: Real-time compression progress callbacks
-- ✅ **Cross-Platform**: iOS, Android, and Electron support
+- **iOS**: AVFoundation with VideoToolbox hardware acceleration
+- **Android**: MediaCodec with hardware acceleration
 
 ## Installation
 
@@ -17,267 +12,73 @@ npm install @honem/native-video-compressor
 npx cap sync
 ```
 
-### Electron Setup
-
-For Electron apps, you also need to install FFmpeg dependencies:
-
-```bash
-npm install fluent-ffmpeg @ffmpeg-installer/ffmpeg
-```
-
-Then register the plugin in your Electron main process (see [Electron Setup](#electron-setup) below).
-
 ## Usage
 
-### Basic Usage
-
 ```typescript
 import { VideoCompressor } from '@honem/native-video-compressor';
 
+// Compress a video
 const result = await VideoCompressor.compressVideo({
-  inputPath: '/path/to/input/video.mp4',
-  quality: 'medium',
-  // Format will be auto-detected from input file (MOV → MOV, MP4 → MP4)
-  // format: 'mp4', // Optional: specify format to override auto-detection
-  onProgress: (progress) => {
-    console.log(`Compression progress: ${progress}%`);
-  }
-});
-
-console.log(`Compressed video saved to: ${result.outputPath}`);
-console.log(`Compression ratio: ${result.compressionRatio}x`);
-```
-
-### Quality Presets
-
-#### Low Quality
-```typescript
-await VideoCompressor.compressVideo({
-  inputPath: '/path/to/video.mp4',
-  quality: 'low', // 640x480, 500 kbps
-});
-```
-
-#### Medium Quality (Default)
-```typescript
-await VideoCompressor.compressVideo({
-  inputPath: '/path/to/video.mp4',
-  quality: 'medium', // 1280x720, 2 Mbps
-});
-```
-
-#### High Quality
-```typescript
-await VideoCompressor.compressVideo({
-  inputPath: '/path/to/video.mp4',
-  quality: 'high', // Original resolution, 8 Mbps
-});
-```
-
-#### Custom Quality
-```typescript
-await VideoCompressor.compressVideo({
-  inputPath: '/path/to/video.mp4',
-  quality: 'custom',
-  bitrate: 4000000, // 4 Mbps
-  width: 1920,
-  height: 1080,
-  format: 'mp4',
-});
-```
-
-### Progress Tracking
-
-**Note**: Progress callbacks (`onProgress`) are currently not supported on iOS and Android due to Capacitor's architecture limitations. Progress tracking would require implementing Capacitor's event system with `notifyListeners()`. For now, progress callbacks only work on Electron.
-
-```typescript
-await VideoCompressor.compressVideo({
   inputPath: '/path/to/video.mp4',
   quality: 'medium',
-  onProgress: (progress) => {
-    // Progress is a number from 0 to 100
-    // Currently only works on Electron
-    updateProgressBar(progress);
-  }
 });
-```
 
-### Custom Output Path
+console.log(result.outputPath);       // Path to compressed file
+console.log(result.compressionRatio); // e.g., 3.5
 
-```typescript
-await VideoCompressor.compressVideo({
-  inputPath: '/path/to/input/video.mp4',
-  outputPath: '/path/to/output/compressed.mp4',
-  quality: 'medium',
-});
+// Optional: delete temp file immediately after use
+await VideoCompressor.deleteFile({ path: result.outputPath });
 ```
 
-If `outputPath` is not provided, the plugin will automatically generate a path by appending `_compressed` to the input filename.
-
-## API Reference
-
-### `compressVideo(options: CompressionOptions): Promise<CompressionResult>`
+## API
 
-Compresses a video file.
+### compressVideo(options)
 
-#### Parameters
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `inputPath` | string | Yes | Path to input video |
+| `outputPath` | string | No | Output path (temp file if omitted) |
+| `quality` | `'low'` \| `'medium'` \| `'high'` \| `'custom'` | No | Default: `'medium'` |
+| `bitrate` | number | No | Bitrate in bps (for `'custom'` quality) |
+| `width` | number | No | Output width (for `'custom'` quality) |
+| `height` | number | No | Output height (for `'custom'` quality) |
+| `format` | `'mp4'` \| `'mov'` \| `'m4v'` \| `'3gp'` \| `'webm'` | No | Default: same as input |
 
-**`options`** (CompressionOptions)
+**Returns:**
 
-- `inputPath` (string, required): Path to the input video file
-- `outputPath` (string, optional): Path for the output file. If not provided, will be generated automatically.
-- `quality` ('low' | 'medium' | 'high' | 'custom', optional): Quality preset. Default: 'medium'
-- `bitrate` (number, optional): Video bitrate in bits per second (only used when quality is 'custom')
-- `width` (number, optional): Output video width in pixels (only used when quality is 'custom')
-- `height` (number, optional): Output video height in pixels (only used when quality is 'custom')
-- `format` ('mp4' | 'mov' | 'm4v' | '3gp' | 'webm', optional): Output video format. If not specified, will be auto-detected from the input file extension (MOV → MOV, MP4 → MP4, etc.). Default: auto-detect from input file
-- `onProgress` ((progress: number) => void, optional): Callback function for progress updates (0-100)
+| Property | Type | Description |
+|----------|------|-------------|
+| `outputPath` | string | Path to compressed file |
+| `originalSize` | number | Original size in bytes |
+| `compressedSize` | number | Compressed size in bytes |
+| `compressionRatio` | number | originalSize / compressedSize |
+| `duration` | number | Compression time in ms |
 
-#### Returns
+### deleteFile(options)
 
-**`Promise<CompressionResult>`**
+When `outputPath` is not provided, compressed files are saved to the system temp directory which is automatically cleaned up by the OS. Use `deleteFile()` if you want to delete the file immediately after use.
 
-- `outputPath` (string): Path to the compressed video file
-- `originalSize` (number): Original file size in bytes
-- `compressedSize` (number): Compressed file size in bytes
-- `compressionRatio` (number): Compression ratio (originalSize / compressedSize)
-- `duration` (number): Duration of the compression process in milliseconds
-
-## Platform Support
-
-### iOS
-
-- **Framework**: AVFoundation
-- **Supported Formats**: MP4, MOV, M4V
-- **Hardware Acceleration**: Yes (VideoToolbox)
-- **Minimum iOS Version**: iOS 11.0+
-- **Progress Callbacks**: Not supported (Capacitor limitation - would require event listeners)
-
-### Android
-
-- **API**: MediaCodec, MediaMuxer
-- **Supported Formats**: MP4, 3GP, WebM
-- **Hardware Acceleration**: Yes (MediaCodec)
-- **Minimum Android Version**: API 21 (Android 5.0)+
-- **Progress Callbacks**: Not supported (Capacitor limitation - would require event listeners)
-
-### Electron
-
-- **Library**: FFmpeg (via fluent-ffmpeg)
-- **Supported Formats**: All formats supported by FFmpeg (MP4, MOV, M4V, 3GP, WebM, etc.)
-- **FFmpeg Source**: Bundled via @ffmpeg-installer/ffmpeg or system FFmpeg
-
-#### Electron Setup
-
-1. Install dependencies:
-```bash
-npm install fluent-ffmpeg @ffmpeg-installer/ffmpeg
-```
-
-2. The plugin works automatically with Capacitor's standard plugin system. No additional registration is required. Simply import and use:
+Deletes a file. 
 
 ```typescript
-import { VideoCompressor } from '@honem/native-video-compressor';
-
-// Works automatically in Electron
-const result = await VideoCompressor.compressVideo({
-  inputPath: '/path/to/video.mp4',
-  quality: 'medium'
-});
+await VideoCompressor.deleteFile({ path: result.outputPath });
 ```
 
-**Note**: The plugin automatically detects the Electron platform and uses the FFmpeg-based implementation. Make sure FFmpeg is available (via `@ffmpeg-installer/ffmpeg` or system PATH).
-
-**Important**: This plugin does not require `@capacitor-community/electron`. It uses Capacitor's standard plugin system with `WebPlugin`, which is compatible with Capacitor 6.0.0+. If you encounter issues with plugin registration in Electron, you may need to manually register it in your Electron main process (see the [Electron README](./electron/README.md) for details).
-
-### Web
-
-- **Status**: Not supported
-- **Reason**: Video compression requires native APIs or FFmpeg, which are not available in web browsers
-- **Fallback**: Returns an error message directing users to use a native platform
-
 ## Quality Presets
 
-| Preset | Resolution | Bitrate | Use Case |
-|--------|-----------|---------|----------|
-| Low | 640x480 | 500 kbps | Maximum compression, lowest quality |
-| Medium | 1280x720 | 2 Mbps | Balanced quality and file size (default) |
-| High | Original | 8 Mbps | High quality, larger file size |
-| Custom | User-defined | User-defined | Full control over compression parameters |
+| Preset | Max Resolution | Bitrate |
+|--------|---------------|---------|
+| `low` | 854x480 | 800 kbps |
+| `medium` | 1280x720 | 1.5 Mbps |
+| `high` | Original | 8 Mbps |
+| `custom` | User-defined | User-defined |
 
-## File Path Handling
+## Platform Requirements
 
-The plugin supports various path formats:
-
-- **Absolute paths**: `/path/to/video.mp4`
-- **File URLs**: `file:///path/to/video.mp4`
-- **Capacitor file paths**: `capacitor://localhost/_capacitor_file_/path/to/video.mp4`
-- **Relative paths**: Resolved from the platform's default document directory
-
-## Error Handling
-
-The plugin throws errors for:
-
-- Missing input file
-- Invalid file paths
-- Unsupported formats
-- Compression failures
-- Missing FFmpeg (Electron only)
-
-Always wrap compression calls in try-catch blocks:
-
-```typescript
-try {
-  const result = await VideoCompressor.compressVideo({
-    inputPath: '/path/to/video.mp4',
-    quality: 'medium',
-  });
-} catch (error) {
-  console.error('Compression failed:', error);
-}
-```
-
-## Examples
-
-See the [example app](../src/App.tsx) in the main project for a complete React implementation.
-
-## Development
-
-### Building the Plugin
-
-```bash
-cd zoobook-compressor-plugin
-npm install
-npm run build
-```
-
-### Project Structure
-
-```
-zoobook-compressor-plugin/
-├── src/                    # TypeScript source
-│   ├── definitions.ts      # Type definitions
-│   ├── index.ts           # Plugin registration
-│   └── web.ts             # Web implementation (fallback)
-├── ios/                    # iOS native code
-│   └── Plugin/
-│       ├── VideoCompressor.swift
-│       ├── VideoCompressorPlugin.swift
-│       └── Plugin.m
-├── android/                # Android native code
-│   └── src/main/java/com/honem/nativevideocompressor/
-│       ├── VideoCompressor.java
-│       └── VideoCompressorPlugin.java
-├── electron/               # Electron implementation
-│   └── src/
-│       └── video-compressor.ts
-└── package.json
-```
+- **iOS**: 15.0+
+- **Android**: API 22+ (Android 5.1)
+- **Web**: Not supported
 
 ## License
 
 MIT
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.

package/dist/index.js

@@ -1,11 +1,6 @@
 import { registerPlugin } from '@capacitor/core';
-// Register plugin with platform-specific implementations
-// For Electron, the plugin will use the Electron implementation automatically
-// when running in an Electron environment (via Capacitor's plugin bridge)
 const VideoCompressor = registerPlugin('VideoCompressor', {
     web: () => import('./web').then(m => new m.VideoCompressorWeb()),
-    // Electron implementation extends WebPlugin and works with Capacitor's standard plugin system
-    // It will be automatically used when the plugin is called in an Electron environment
 });
 export * from './definitions';
 export { VideoCompressor };

package/dist/web.js

@@ -1,9 +1,9 @@
 import { WebPlugin } from '@capacitor/core';
 export class VideoCompressorWeb extends WebPlugin {
     async compressVideo(_options) {
-        throw new Error('Video compression is not supported in web browsers. Please use a native platform (iOS, Android, or Electron).');
+        throw new Error('Video compression is not supported in web browsers. Please use a native platform (iOS or Android).');
     }
     async deleteFile(_options) {
-        throw new Error('File deletion is not supported in web browsers. Please use a native platform (iOS, Android, or Electron).');
+        throw new Error('File deletion is not supported in web browsers. Please use a native platform (iOS or Android).');
     }
 }

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@honem/native-video-compressor",
-  "version": "0.1.0",
-  "description": "Capacitor plugin for video compression using native platform APIs (iOS AVFoundation, Android MediaCodec, Electron FFmpeg)",
+  "version": "0.2.1",
+  "description": "Capacitor plugin for video compression using native platform APIs (iOS AVFoundation, Android MediaCodec)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist/",
     "ios/",
     "android/",
-    "electron/",
     "HonemNativeVideoCompressor.podspec"
   ],
   "scripts": {
@@ -26,8 +25,6 @@
     "native",
     "ios",
     "android",
-    "electron",
-    "ffmpeg",
     "mediacodec",
     "avfoundation"
   ],
@@ -55,10 +52,5 @@
   "devDependencies": {
     "@capacitor/core": "^6.2.0",
     "typescript": "~5.9.3"
-  },
-  "optionalDependencies": {
-    "fluent-ffmpeg": "^2.1.2",
-    "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@types/fluent-ffmpeg": "^2.1.24"
   }
 }

package/electron/README.md

@@ -1,53 +0,0 @@
-# Electron Implementation
-
-This directory contains the Electron-specific implementation of the video compressor plugin.
-
-## Setup
-
-To use this plugin in an Electron app, you need to:
-
-1. Install the required dependencies:
-```bash
-npm install fluent-ffmpeg @ffmpeg-installer/ffmpeg
-```
-
-2. Register the plugin in your Electron main process:
-
-The plugin uses Capacitor's standard plugin registration. In your Electron main process, you can register it manually if needed:
-
-```typescript
-import { VideoCompressorElectron } from '@honem/native-video-compressor/electron';
-import { Capacitor } from '@capacitor/core';
-
-// Register the Electron implementation
-if (Capacitor.getPlatform() === 'electron') {
-  // The plugin will be automatically registered when imported
-  // If you need manual registration, you can do:
-  const compressor = new VideoCompressorElectron();
-  // Register with Capacitor's bridge if needed
-}
-```
-
-Alternatively, you can use the plugin directly in your renderer process:
-
-```typescript
-import { VideoCompressor } from '@honem/native-video-compressor';
-
-// The plugin will automatically use the Electron implementation
-// when running in an Electron environment
-const result = await VideoCompressor.compressVideo({
-  inputPath: '/path/to/video.mp4',
-  quality: 'medium'
-});
-```
-
-**Note**: The plugin automatically detects the Electron platform and uses the appropriate implementation. No additional registration is typically required.
-
-## FFmpeg
-
-The Electron implementation uses FFmpeg for video compression. It will:
-1. First try to use the bundled FFmpeg from `@ffmpeg-installer/ffmpeg`
-2. Fall back to system FFmpeg if available in PATH
-
-Make sure FFmpeg is available either via the npm package or installed on the system.
-

package/electron/src/index.ts

@@ -1,4 +0,0 @@
-// Electron plugin registration
-// This file is used when the plugin is loaded in an Electron environment
-export { VideoCompressorElectron } from './video-compressor';
-

package/electron/src/video-compressor.ts

@@ -1,202 +0,0 @@
-import type { VideoCompressorPlugin, CompressionOptions, CompressionResult, DeleteFileOptions, DeleteFileResult } from '../../src/definitions';
-import { WebPlugin } from '@capacitor/core';
-import * as ffmpeg from 'fluent-ffmpeg';
-import * as ffmpegInstaller from '@ffmpeg-installer/ffmpeg';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-import { promisify } from 'util';
-
-const stat = promisify(fs.stat);
-const unlink = promisify(fs.unlink);
-
-let ffmpegPath: string | null = null;
-
-try {
-  ffmpegPath = ffmpegInstaller.path;
-  ffmpeg.setFfmpegPath(ffmpegPath);
-} catch {
-  try {
-    ffmpegPath = 'ffmpeg';
-  } catch {
-    console.warn('FFmpeg not found. Please install FFmpeg or use @ffmpeg-installer/ffmpeg');
-  }
-}
-
-export class VideoCompressorElectron extends WebPlugin implements VideoCompressorPlugin {
-  constructor() {
-    super();
-  }
-
-  async compressVideo(options: CompressionOptions): Promise<CompressionResult> {
-    if (!ffmpegPath) {
-      throw new Error('FFmpeg is not available. Please install FFmpeg or use @ffmpeg-installer/ffmpeg');
-    }
-
-    const startTime = Date.now();
-    const inputPath = this.resolveFilePath(options.inputPath);
-    const outputPath = options.outputPath 
-      ? this.resolveFilePath(options.outputPath)
-      : this.generateTempOutputPath(options.format || 'mp4');
-
-    try {
-      await stat(inputPath);
-    } catch {
-      throw new Error(`Input file not found: ${inputPath}`);
-    }
-
-    const inputStats = await stat(inputPath);
-    const originalSize = inputStats.size;
-
-    const { targetBitrate, targetWidth, targetHeight, videoCodec, audioCodec, format } = 
-      this.getCompressionParams(options);
-
-    try {
-      await stat(outputPath);
-      await unlink(outputPath);
-    } catch {
-      // File doesn't exist, which is fine
-    }
-
-    return new Promise((resolve, reject) => {
-      const command = ffmpeg(inputPath)
-        .videoCodec(videoCodec)
-        .audioCodec(audioCodec)
-        .outputOptions([
-          '-preset fast',
-          '-movflags +faststart',
-        ]);
-
-      if (targetBitrate) {
-        command.videoBitrate(targetBitrate);
-      }
-
-      if (targetWidth && targetHeight) {
-        command.size(`${targetWidth}x${targetHeight}`);
-      }
-
-      command.format(format);
-      command.output(outputPath);
-
-      command.on('error', (error) => {
-        reject(new Error(`FFmpeg error: ${error.message}`));
-      });
-
-      command.on('end', async () => {
-        try {
-          const outputStats = await stat(outputPath);
-          const compressedSize = outputStats.size;
-          const duration = Date.now() - startTime;
-          const compressionRatio = originalSize / compressedSize;
-
-          resolve({
-            outputPath,
-            originalSize,
-            compressedSize,
-            compressionRatio,
-            duration,
-          });
-        } catch (error) {
-          reject(new Error(`Failed to get output file stats: ${error}`));
-        }
-      });
-
-      command.run();
-    });
-  }
-
-  async deleteFile(options: DeleteFileOptions): Promise<DeleteFileResult> {
-    try {
-      const filePath = this.resolveFilePath(options.path);
-      await stat(filePath);
-      await unlink(filePath);
-      return { success: true };
-    } catch {
-      return { success: false };
-    }
-  }
-
-  private resolveFilePath(filePath: string): string {
-    if (filePath.startsWith('file://')) {
-      return filePath.replace('file://', '');
-    }
-
-    if (path.isAbsolute(filePath)) {
-      return filePath;
-    }
-
-    return path.resolve(process.cwd(), filePath);
-  }
-
-  private generateTempOutputPath(format: string): string {
-    const tempDir = os.tmpdir();
-    const extension = this.getFileExtension(format);
-    const uniqueName = `compressed_${Date.now()}.${extension}`;
-    return path.join(tempDir, uniqueName);
-  }
-
-  private getFileExtension(format: string): string {
-    switch (format.toLowerCase()) {
-      case 'mov':
-        return 'mov';
-      case 'm4v':
-        return 'm4v';
-      case 'webm':
-        return 'webm';
-      case '3gp':
-        return '3gp';
-      case 'mp4':
-      default:
-        return 'mp4';
-    }
-  }
-
-  private getCompressionParams(options: CompressionOptions) {
-    let targetBitrate: number | undefined;
-    let targetWidth: number | undefined;
-    let targetHeight: number | undefined;
-    let videoCodec = 'libx264';
-    let audioCodec = 'aac';
-    const format = options.format || 'mp4';
-
-    switch (options.quality) {
-      case 'low':
-        targetBitrate = 800;
-        targetWidth = 854;
-        targetHeight = 480;
-        break;
-      case 'high':
-        targetBitrate = options.bitrate ? options.bitrate / 1000 : 8000;
-        targetWidth = options.width;
-        targetHeight = options.height;
-        break;
-      case 'custom':
-        targetBitrate = options.bitrate ? options.bitrate / 1000 : 2000;
-        targetWidth = options.width;
-        targetHeight = options.height;
-        break;
-      default: // 'medium'
-        targetBitrate = 1500;
-        targetWidth = 1280;
-        targetHeight = 720;
-        break;
-    }
-
-    if (format === 'webm') {
-      videoCodec = 'libvpx-vp9';
-      audioCodec = 'libopus';
-    } else if (format === '3gp') {
-      videoCodec = 'h263';
-      audioCodec = 'amr_nb';
-    }
-
-    return {
-      targetBitrate,
-      targetWidth,
-      targetHeight,
-      videoCodec,
-      audioCodec,
-      format,
-    };
-  }
-}