@capgo/capacitor-file-compressor 7.0.0

package/CapgoCapacitorFileCompressor.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoCapacitorFileCompressor'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Martin Donadieu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapgoCapacitorFileCompressor",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "CapgoCapacitorFileCompressor",
+            targets: ["FileCompressorPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+    ],
+    targets: [
+        .target(
+            name: "FileCompressorPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/FileCompressorPlugin"),
+        .testTarget(
+            name: "FileCompressorPluginTests",
+            dependencies: ["FileCompressorPlugin"],
+            path: "ios/Tests/FileCompressorPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,136 @@
+# @capgo/capacitor-file-compressor
+ <a href="https://capgo.app/"><img src='https://raw.githubusercontent.com/Cap-go/capgo/main/assets/capgo_banner.png' alt='Capgo - Instant updates for capacitor'/></a>
+
+<div align="center">
+  <h2><a href="https://capgo.app/?ref=plugin_file-compressor"> ➡️ Get Instant updates for your App with Capgo</a></h2>
+  <h2><a href="https://capgo.app/consulting/?ref=plugin_file-compressor"> Missing a feature? We'll build the plugin for you 💪</a></h2>
+</div>
+
+Capacitor plugin for efficient image compression supporting PNG, JPEG, and WebP formats across iOS, Android, and Web platforms.
+
+## Why File Compressor?
+
+A free, open-source alternative for **client-side image compression**:
+
+- **Multiple formats** - JPEG and WebP compression support
+- **Quality control** - Adjustable compression quality (0.0 - 1.0)
+- **Smart resizing** - Automatic aspect ratio preservation
+- **Cross-platform** - Consistent API across iOS, Android, and Web
+- **Zero backend** - All compression happens on the device
+
+Essential for apps that need to optimize image uploads, reduce storage, or improve performance without server-side processing.
+
+## Documentation
+
+The most complete doc is available here: https://capgo.app/docs/plugins/file-compressor/
+
+## Install
+
+```bash
+npm install @capgo/capacitor-file-compressor
+npx cap sync
+```
+
+## Platform Support
+
+| Platform | Supported Formats | Notes |
+|----------|-------------------|-------|
+| iOS | JPEG | Only JPEG compression supported |
+| Android | JPEG, WebP | Both formats fully supported |
+| Web | JPEG, WebP | Canvas API-based compression |
+
+Note: EXIF metadata is removed during compression on all platforms.
+
+## API
+
+<docgen-index>
+
+* [`compressImage(...)`](#compressimage)
+* [`getPluginVersion()`](#getpluginversion)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+Capacitor File Compressor Plugin interface for image compression.
+
+### compressImage(...)
+
+```typescript
+compressImage(options: CompressImageOptions) => Promise<CompressImageResult>
+```
+
+Compresses an image file with specified dimensions and quality settings.
+
+This method compresses images to reduce file size while maintaining acceptable quality.
+It supports resizing and format conversion (JPEG/WebP depending on platform).
+
+**Important Notes:**
+- EXIF metadata is removed during compression on all platforms
+- Aspect ratio is automatically maintained if only one dimension is provided
+- Compressed files are saved to temporary directories on native platforms
+
+| Param         | Type                                                                  | Description                                   |
+| ------------- | --------------------------------------------------------------------- | --------------------------------------------- |
+| **`options`** | <code><a href="#compressimageoptions">CompressImageOptions</a></code> | - Configuration options for image compression |
+
+**Returns:** <code>Promise&lt;<a href="#compressimageresult">CompressImageResult</a>&gt;</code>
+
+**Since:** 7.0.0
+
+--------------------
+
+
+### getPluginVersion()
+
+```typescript
+getPluginVersion() => Promise<{ version: string; }>
+```
+
+Get the native Capacitor plugin version.
+
+Returns the version of the native plugin implementation.
+Useful for debugging and ensuring compatibility.
+
+**Returns:** <code>Promise&lt;{ version: string; }&gt;</code>
+
+**Since:** 7.0.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### CompressImageResult
+
+The result of compressing an image.
+
+Contains either a file path (native platforms) or a Blob (web platform)
+depending on where the compression was performed.
+
+| Prop       | Type                | Description                                                                                                                                                                                                                                                                                                                                                       | Since |
+| ---------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`path`** | <code>string</code> | The file path of the compressed image. **Platform:** Android, iOS only (undefined on Web) Points to a temporary file containing the compressed image. On iOS, typically in `NSTemporaryDirectory()`. On Android, typically in app cache directory. **Important:** These files may be cleaned up by the OS. Copy to permanent storage if needed for long-term use. | 7.0.0 |
+| **`blob`** | <code>Blob</code>   | The blob of the compressed image. **Platform:** Web only (undefined on iOS/Android) A Blob object containing the compressed image data. Can be used to: - Create object URLs for preview: `URL.createObjectURL(blob)` - Upload to server via FormData - Save to IndexedDB or other storage - Convert to base64 with FileReader                                    | 7.0.0 |
+
+
+#### CompressImageOptions
+
+Options for compressing an image.
+
+Configure the compression behavior including quality, dimensions, and output format.
+Platform-specific options are available for path (native) and blob (web).
+
+| Prop           | Type                | Description                                                                                                                                                                                                                                                                                                                                                                                             | Default                   | Since |
+| -------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- | ----- |
+| **`path`**     | <code>string</code> | The file path of the image to compress. **Platform:** Android, iOS only (not supported on Web) Accepts various path formats: - iOS: `file://` URLs or absolute paths - Android: `content://` URIs, `file://` URLs, or absolute paths                                                                                                                                                                    |                           | 7.0.0 |
+| **`blob`**     | <code>Blob</code>   | The file blob of the image to compress. **Platform:** Web only (not supported on iOS/Android) Use this when compressing images from file inputs, fetch responses, or any other Blob source in web applications.                                                                                                                                                                                         |                           | 7.0.0 |
+| **`quality`**  | <code>number</code> | The quality of the compressed image. **Range:** 0.0 to 1.0 - `0.0` = Maximum compression (lowest quality, smallest file) - `1.0` = Minimum compression (highest quality, largest file) - `0.6` = Default balanced compression **Platform:** All platforms Higher quality values result in larger files but better visual quality. The actual compression ratio depends on the image content and format. | <code>0.6</code>          | 7.0.0 |
+| **`width`**    | <code>number</code> | The width of the compressed image in pixels. **Platform:** All platforms If only width is specified, height is calculated automatically to maintain the original aspect ratio. If both width and height are specified, the image is resized to exact dimensions (may distort if ratio differs).                                                                                                         |                           | 7.0.0 |
+| **`height`**   | <code>number</code> | The height of the compressed image in pixels. **Platform:** All platforms If only height is specified, width is calculated automatically to maintain the original aspect ratio. If both width and height are specified, the image is resized to exact dimensions (may distort if ratio differs).                                                                                                        |                           | 7.0.0 |
+| **`mimeType`** | <code>string</code> | The MIME type of the compressed output image. **Platform Support:** - **iOS:** `image/jpeg` only - **Android:** `image/jpeg`, `image/webp` - **Web:** `image/jpeg`, `image/webp` **Format Characteristics:** - **JPEG:** Universal support, good for photos, no transparency - **WebP:** Better compression, supports transparency, not on iOS                                                          | <code>"image/jpeg"</code> | 7.0.0 |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,57 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "io.capgo.filecompressor"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/io/capgo/filecompressor/FileCompressorPlugin.java

@@ -0,0 +1,163 @@
+package io.capgo.filecompressor;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.webkit.MimeTypeMap;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.UUID;
+
+@CapacitorPlugin(name = "FileCompressor")
+public class FileCompressorPlugin extends Plugin {
+
+    private final String pluginVersion = "7.0.0";
+
+    @PluginMethod
+    public void compressImage(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        float quality = call.getFloat("quality", 0.6f);
+        Integer width = call.getInt("width");
+        Integer height = call.getInt("height");
+        String mimeType = call.getString("mimeType", "image/jpeg");
+
+        // Validate mime type for Android
+        if (!mimeType.equals("image/jpeg") && !mimeType.equals("image/webp")) {
+            call.reject("Only image/jpeg and image/webp are supported on Android");
+            return;
+        }
+
+        // Validate quality range
+        if (quality < 0.0f || quality > 1.0f) {
+            call.reject("quality must be between 0.0 and 1.0");
+            return;
+        }
+
+        try {
+            // Load bitmap from path
+            Bitmap bitmap = loadBitmapFromPath(path);
+            if (bitmap == null) {
+                call.reject("Failed to load image from path");
+                return;
+            }
+
+            // Resize bitmap if dimensions are provided
+            Bitmap processedBitmap = bitmap;
+            if (width != null && height != null) {
+                processedBitmap = Bitmap.createScaledBitmap(bitmap, width, height, true);
+            } else if (width != null) {
+                float aspectRatio = (float) bitmap.getHeight() / bitmap.getWidth();
+                int targetHeight = (int) (width * aspectRatio);
+                processedBitmap = Bitmap.createScaledBitmap(bitmap, width, targetHeight, true);
+            } else if (height != null) {
+                float aspectRatio = (float) bitmap.getWidth() / bitmap.getHeight();
+                int targetWidth = (int) (height * aspectRatio);
+                processedBitmap = Bitmap.createScaledBitmap(bitmap, targetWidth, height, true);
+            }
+
+            // Compress bitmap
+            File compressedFile = compressBitmap(processedBitmap, quality, mimeType);
+            if (compressedFile == null) {
+                call.reject("Failed to compress image");
+                return;
+            }
+
+            // Clean up
+            if (processedBitmap != bitmap) {
+                processedBitmap.recycle();
+            }
+            bitmap.recycle();
+
+            // Return result
+            JSObject result = new JSObject();
+            result.put("path", compressedFile.getAbsolutePath());
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject("Error compressing image: " + e.getMessage(), e);
+        }
+    }
+
+    private Bitmap loadBitmapFromPath(String path) {
+        try {
+            // Handle content:// URIs
+            if (path.startsWith("content://")) {
+                Uri uri = Uri.parse(path);
+                InputStream inputStream = getContext().getContentResolver().openInputStream(uri);
+                if (inputStream != null) {
+                    Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
+                    inputStream.close();
+                    return bitmap;
+                }
+            }
+            // Handle file:// URIs and absolute paths
+            else if (path.startsWith("file://")) {
+                path = path.substring(7); // Remove "file://" prefix
+            }
+
+            // Try loading as file path
+            File file = new File(path);
+            if (file.exists()) {
+                return BitmapFactory.decodeFile(file.getAbsolutePath());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private File compressBitmap(Bitmap bitmap, float quality, String mimeType) {
+        try {
+            // Determine compression format and file extension
+            Bitmap.CompressFormat format;
+            String extension;
+
+            if (mimeType.equals("image/webp")) {
+                format = Bitmap.CompressFormat.WEBP;
+                extension = ".webp";
+            } else {
+                format = Bitmap.CompressFormat.JPEG;
+                extension = ".jpg";
+            }
+
+            // Create temporary file
+            File tempDir = getContext().getCacheDir();
+            String fileName = "compressed_" + UUID.randomUUID().toString() + extension;
+            File compressedFile = new File(tempDir, fileName);
+
+            // Compress and save
+            FileOutputStream outputStream = new FileOutputStream(compressedFile);
+            int qualityInt = (int) (quality * 100);
+            bitmap.compress(format, qualityInt, outputStream);
+            outputStream.flush();
+            outputStream.close();
+
+            return compressedFile;
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @PluginMethod
+    public void getPluginVersion(final PluginCall call) {
+        try {
+            final JSObject ret = new JSObject();
+            ret.put("version", this.pluginVersion);
+            call.resolve(ret);
+        } catch (final Exception e) {
+            call.reject("Could not get plugin version", e);
+        }
+    }
+}