@dynlabs/react-native-image-to-webp 0.1.0

package/ios/ReactNativeImageToWebp.mm

@@ -0,0 +1,342 @@
+#import "ReactNativeImageToWebp.h"
+#import <React/RCTUtils.h>
+#import <ImageIO/ImageIO.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <Accelerate/Accelerate.h>
+#import <Foundation/Foundation.h>
+#import "ImageToWebP.h"
+
+// Error domain
+static NSString *const kErrorDomain = @"ReactNativeImageToWebp";
+
+// Error codes matching JS API
+static NSString *const kErrorCodeInvalidInput = @"INVALID_INPUT";
+static NSString *const kErrorCodeFileNotFound = @"FILE_NOT_FOUND";
+static NSString *const kErrorCodeDecodeFailed = @"DECODE_FAILED";
+static NSString *const kErrorCodeEncodeFailed = @"ENCODE_FAILED";
+static NSString *const kErrorCodeIOError = @"IO_ERROR";
+static NSString *const kErrorCodeUnsupportedFormat = @"UNSUPPORTED_FORMAT";
+
+@interface ReactNativeImageToWebp ()
+@end
+
+@implementation ReactNativeImageToWebp
+
++ (NSString *)moduleName {
+  return @"ReactNativeImageToWebp";
+}
+
+// Helper to get CGImageSource from file path
+static CGImageSourceRef createImageSource(NSString *path, NSError **error) {
+  NSURL *url = [NSURL fileURLWithPath:path];
+  if (!url) {
+    if (error) {
+      *error = [NSError errorWithDomain:kErrorDomain
+                                   code:1
+                               userInfo:@{NSLocalizedDescriptionKey: @"Invalid file path",
+                                          @"code": kErrorCodeInvalidInput}];
+    }
+    return NULL;
+  }
+
+  CGImageSourceRef source = CGImageSourceCreateWithURL((__bridge CFURLRef)url, NULL);
+  if (!source) {
+    if (error) {
+      *error = [NSError errorWithDomain:kErrorDomain
+                                   code:1
+                               userInfo:@{NSLocalizedDescriptionKey: @"File not found or cannot be read",
+                                          @"code": kErrorCodeFileNotFound}];
+    }
+    return NULL;
+  }
+
+  return source;
+}
+
+// Get image properties including orientation
+static NSDictionary *getImageProperties(CGImageSourceRef source) {
+  return (__bridge_transfer NSDictionary *)CGImageSourceCopyPropertiesAtIndex(source, 0, NULL);
+}
+
+// Apply EXIF orientation to get correctly oriented image
+static CGImageRef createOrientedImage(CGImageRef image, NSDictionary *properties) {
+  NSNumber *orientationValue = properties[(__bridge NSString *)kCGImagePropertyOrientation];
+  if (!orientationValue) {
+    return CGImageRetain(image);
+  }
+
+  int orientation = [orientationValue intValue];
+  if (orientation == 1) {
+    return CGImageRetain(image); // No rotation needed
+  }
+
+  // Calculate transform based on orientation
+  CGAffineTransform transform = CGAffineTransformIdentity;
+  CGFloat width = CGImageGetWidth(image);
+  CGFloat height = CGImageGetHeight(image);
+
+  switch (orientation) {
+    case 2: // Flip horizontal
+      transform = CGAffineTransformMakeScale(-1, 1);
+      transform = CGAffineTransformTranslate(transform, -width, 0);
+      break;
+    case 3: // Rotate 180
+      transform = CGAffineTransformMakeTranslation(width, height);
+      transform = CGAffineTransformRotate(transform, M_PI);
+      break;
+    case 4: // Flip vertical
+      transform = CGAffineTransformMakeScale(1, -1);
+      transform = CGAffineTransformTranslate(transform, 0, -height);
+      break;
+    case 5: // Rotate 90 CCW and flip
+      transform = CGAffineTransformMakeTranslation(height, 0);
+      transform = CGAffineTransformRotate(transform, M_PI_2);
+      transform = CGAffineTransformScale(transform, -1, 1);
+      break;
+    case 6: // Rotate 90 CW
+      transform = CGAffineTransformMakeTranslation(height, 0);
+      transform = CGAffineTransformRotate(transform, M_PI_2);
+      break;
+    case 7: // Rotate 90 CW and flip
+      transform = CGAffineTransformMakeTranslation(0, width);
+      transform = CGAffineTransformRotate(transform, -M_PI_2);
+      transform = CGAffineTransformScale(transform, -1, 1);
+      break;
+    case 8: // Rotate 90 CCW
+      transform = CGAffineTransformMakeTranslation(0, width);
+      transform = CGAffineTransformRotate(transform, -M_PI_2);
+      break;
+    default:
+      return CGImageRetain(image);
+  }
+
+  // Create bitmap context and draw transformed image
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(NULL,
+                                               (orientation >= 5 && orientation <= 8) ? height : width,
+                                               (orientation >= 5 && orientation <= 8) ? width : height,
+                                               8, 0, colorSpace,
+                                               kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+  CGColorSpaceRelease(colorSpace);
+
+  if (!context) {
+    return CGImageRetain(image);
+  }
+
+  CGContextConcatCTM(context, transform);
+  CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+  CGImageRef orientedImage = CGBitmapContextCreateImage(context);
+  CGContextRelease(context);
+
+  return orientedImage ?: CGImageRetain(image);
+}
+
+// Resize image if maxLongEdge is specified
+static CGImageRef resizeImageIfNeeded(CGImageRef image, NSNumber *maxLongEdge) {
+  if (!maxLongEdge || [maxLongEdge doubleValue] <= 0) {
+    return CGImageRetain(image);
+  }
+
+  CGFloat width = CGImageGetWidth(image);
+  CGFloat height = CGImageGetHeight(image);
+  CGFloat maxEdge = [maxLongEdge doubleValue];
+  CGFloat currentMax = MAX(width, height);
+
+  if (currentMax <= maxEdge) {
+    return CGImageRetain(image);
+  }
+
+  CGFloat scale = maxEdge / currentMax;
+  CGFloat newWidth = width * scale;
+  CGFloat newHeight = height * scale;
+
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(NULL,
+                                               (size_t)newWidth,
+                                               (size_t)newHeight,
+                                               8, 0, colorSpace,
+                                               kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+  CGColorSpaceRelease(colorSpace);
+
+  if (!context) {
+    return CGImageRetain(image);
+  }
+
+  CGContextSetInterpolationQuality(context, kCGInterpolationHigh);
+  CGContextDrawImage(context, CGRectMake(0, 0, newWidth, newHeight), image);
+  CGImageRef resizedImage = CGBitmapContextCreateImage(context);
+  CGContextRelease(context);
+
+  return resizedImage ?: CGImageRetain(image);
+}
+
+// Convert CGImage to RGBA buffer
+static uint8_t *createRGBABuffer(CGImageRef image, uint32_t *outWidth, uint32_t *outHeight) {
+  size_t width = CGImageGetWidth(image);
+  size_t height = CGImageGetHeight(image);
+  size_t bytesPerPixel = 4;
+  size_t bytesPerRow = width * bytesPerPixel;
+  size_t bufferSize = bytesPerRow * height;
+
+  uint8_t *buffer = (uint8_t *)malloc(bufferSize);
+  if (!buffer) {
+    return NULL;
+  }
+
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(buffer,
+                                               width,
+                                               height,
+                                               8,
+                                               bytesPerRow,
+                                               colorSpace,
+                                               kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+  CGColorSpaceRelease(colorSpace);
+
+  if (!context) {
+    free(buffer);
+    return NULL;
+  }
+
+  CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+  CGContextRelease(context);
+
+  *outWidth = (uint32_t)width;
+  *outHeight = (uint32_t)height;
+  return buffer;
+}
+
+// Derive output path from input path if not provided
+static NSString *deriveOutputPath(NSString *inputPath, NSString *outputPath) {
+  if (outputPath && outputPath.length > 0) {
+    return outputPath;
+  }
+
+  NSString *directory = [inputPath stringByDeletingLastPathComponent];
+  NSString *filename = [[inputPath lastPathComponent] stringByDeletingPathExtension];
+  return [directory stringByAppendingPathComponent:[filename stringByAppendingPathExtension:@"webp"]];
+}
+
+- (void)convertImageToWebP:(NSDictionary *)options
+                   resolver:(RCTPromiseResolveBlock)resolve
+                   rejecter:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    @autoreleasepool {
+      NSError *error = nil;
+
+      // Parse options
+      NSString *inputPath = options[@"inputPath"];
+      if (!inputPath || ![inputPath isKindOfClass:[NSString class]]) {
+        reject(kErrorCodeInvalidInput, @"inputPath is required", nil);
+        return;
+      }
+
+      NSString *outputPath = deriveOutputPath(inputPath, options[@"outputPath"]);
+      NSNumber *maxLongEdge = options[@"maxLongEdge"];
+      NSNumber *quality = options[@"quality"] ?: @80;
+      NSNumber *method = options[@"method"] ?: @3;
+      NSNumber *lossless = options[@"lossless"] ?: @NO;
+      NSNumber *stripMetadata = options[@"stripMetadata"];
+      if (!stripMetadata) {
+        stripMetadata = @YES;
+      }
+
+      // Check if input file exists
+      if (![[NSFileManager defaultManager] fileExistsAtPath:inputPath]) {
+        reject(kErrorCodeFileNotFound, [NSString stringWithFormat:@"File not found: %@", inputPath], nil);
+        return;
+      }
+
+      // Create image source
+      CGImageSourceRef source = createImageSource(inputPath, &error);
+      if (!source) {
+        reject(error.userInfo[@"code"] ?: kErrorCodeDecodeFailed,
+               error.localizedDescription ?: @"Failed to create image source",
+               error);
+        return;
+      }
+
+      // Get image properties
+      NSDictionary *properties = getImageProperties(source);
+      if (!properties) {
+        CGImageSourceRelease(source);
+        reject(kErrorCodeDecodeFailed, @"Failed to read image properties", nil);
+        return;
+      }
+
+      // Create CGImage
+      CGImageRef image = CGImageSourceCreateImageAtIndex(source, 0, NULL);
+      CGImageSourceRelease(source);
+      if (!image) {
+        reject(kErrorCodeDecodeFailed, @"Failed to decode image", nil);
+        return;
+      }
+
+      // Apply orientation
+      CGImageRef orientedImage = createOrientedImage(image, properties);
+      CGImageRelease(image);
+      if (!orientedImage) {
+        reject(kErrorCodeDecodeFailed, @"Failed to apply orientation", nil);
+        return;
+      }
+
+      // Resize if needed
+      CGImageRef finalImage = resizeImageIfNeeded(orientedImage, maxLongEdge);
+      CGImageRelease(orientedImage);
+      if (!finalImage) {
+        reject(kErrorCodeDecodeFailed, @"Failed to resize image", nil);
+        return;
+      }
+
+      // Convert to RGBA buffer
+      uint32_t width, height;
+      uint8_t *rgbaData = createRGBABuffer(finalImage, &width, &height);
+      CGImageRelease(finalImage);
+      if (!rgbaData) {
+        reject(kErrorCodeDecodeFailed, @"Failed to create RGBA buffer", nil);
+        return;
+      }
+
+      // Prepare WebP encoding options
+      WebPEncodeOptions encodeOptions;
+      encodeOptions.quality = [quality intValue];
+      encodeOptions.method = [method intValue];
+      encodeOptions.lossless = [lossless boolValue];
+      encodeOptions.stripMetadata = [stripMetadata boolValue];
+      encodeOptions.threadLevel = 1;
+
+      // Encode to WebP
+      std::string outputPathStr = [outputPath UTF8String];
+      WebPEncodeResult result = encodeWebP(rgbaData, width, height, encodeOptions, outputPathStr);
+      free(rgbaData);
+
+      if (!result.success) {
+        NSString *errorMsg = [NSString stringWithUTF8String:result.errorMessage.c_str()];
+        reject(kErrorCodeEncodeFailed, errorMsg, nil);
+        return;
+      }
+
+      // Get file size
+      NSDictionary *fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:outputPath error:&error];
+      NSNumber *fileSize = fileAttributes[NSFileSize];
+      if (!fileSize) {
+        fileSize = @0;
+      }
+
+      // Return result
+      resolve(@{
+        @"outputPath": outputPath,
+        @"width": @(result.width ?: width),
+        @"height": @(result.height ?: height),
+        @"sizeBytes": fileSize,
+      });
+    }
+  });
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeReactNativeImageToWebpSpecJSI>(params);
+}
+
+@end

package/lib/module/NativeReactNativeImageToWebp.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('ReactNativeImageToWebp');
+//# sourceMappingURL=NativeReactNativeImageToWebp.js.map

package/lib/module/NativeReactNativeImageToWebp.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"..\\..\\src","sources":["NativeReactNativeImageToWebp.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AA+BpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,wBAAwB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,78 @@
+"use strict";
+
+import NativeReactNativeImageToWebp from "./NativeReactNativeImageToWebp.js";
+import { validateOptions } from "./validation.js";
+import { applyPreset } from "./presets.js";
+const ERROR_CODES = {
+  INVALID_INPUT: 'INVALID_INPUT',
+  FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+  DECODE_FAILED: 'DECODE_FAILED',
+  ENCODE_FAILED: 'ENCODE_FAILED',
+  IO_ERROR: 'IO_ERROR',
+  UNSUPPORTED_FORMAT: 'UNSUPPORTED_FORMAT'
+};
+export class ImageToWebPError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'ImageToWebPError';
+    this.code = code;
+    Object.setPrototypeOf(this, ImageToWebPError.prototype);
+  }
+}
+
+/**
+ * Convert an image file to WebP format.
+ *
+ * @param options - Conversion options
+ * @returns Promise resolving to conversion result with output path and metadata
+ * @throws {ImageToWebPError} If conversion fails
+ *
+ * @example
+ * ```ts
+ * const result = await convertImageToWebP({
+ *   inputPath: '/path/to/image.jpg',
+ *   preset: 'balanced',
+ *   maxLongEdge: 2048,
+ * });
+ * console.log(`Output: ${result.outputPath}, Size: ${result.sizeBytes} bytes`);
+ * ```
+ */
+export async function convertImageToWebP(options) {
+  // Validate input
+  const validationError = validateOptions(options);
+  if (validationError) {
+    throw new ImageToWebPError(validationError.code, validationError.message);
+  }
+
+  // Apply preset defaults
+  const finalOptions = applyPreset(options);
+  try {
+    return await NativeReactNativeImageToWebp.convertImageToWebP(finalOptions);
+  } catch (error) {
+    // Map native errors to our error types
+    if (error instanceof Error) {
+      const message = error.message;
+      if (message.includes('FILE_NOT_FOUND')) {
+        throw new ImageToWebPError(ERROR_CODES.FILE_NOT_FOUND, `File not found: ${options.inputPath}`);
+      }
+      if (message.includes('DECODE_FAILED')) {
+        throw new ImageToWebPError(ERROR_CODES.DECODE_FAILED, `Failed to decode image: ${message}`);
+      }
+      if (message.includes('ENCODE_FAILED')) {
+        throw new ImageToWebPError(ERROR_CODES.ENCODE_FAILED, `Failed to encode WebP: ${message}`);
+      }
+      if (message.includes('IO_ERROR')) {
+        throw new ImageToWebPError(ERROR_CODES.IO_ERROR, `I/O error: ${message}`);
+      }
+      if (message.includes('UNSUPPORTED_FORMAT')) {
+        throw new ImageToWebPError(ERROR_CODES.UNSUPPORTED_FORMAT, `Unsupported image format: ${message}`);
+      }
+      if (message.includes('INVALID_INPUT')) {
+        throw new ImageToWebPError(ERROR_CODES.INVALID_INPUT, `Invalid input: ${message}`);
+      }
+    }
+    throw error;
+  }
+}
+export { ERROR_CODES };
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeReactNativeImageToWebp","validateOptions","applyPreset","ERROR_CODES","INVALID_INPUT","FILE_NOT_FOUND","DECODE_FAILED","ENCODE_FAILED","IO_ERROR","UNSUPPORTED_FORMAT","ImageToWebPError","Error","constructor","code","message","name","Object","setPrototypeOf","prototype","convertImageToWebP","options","validationError","finalOptions","error","includes","inputPath"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,4BAA4B,MAI5B,mCAAgC;AACvC,SAASC,eAAe,QAAQ,iBAAc;AAC9C,SAASC,WAAW,QAAQ,cAAW;AAIvC,MAAMC,WAAW,GAAG;EAClBC,aAAa,EAAE,eAAe;EAC9BC,cAAc,EAAE,gBAAgB;EAChCC,aAAa,EAAE,eAAe;EAC9BC,aAAa,EAAE,eAAe;EAC9BC,QAAQ,EAAE,UAAU;EACpBC,kBAAkB,EAAE;AACtB,CAAU;AAIV,OAAO,MAAMC,gBAAgB,SAASC,KAAK,CAAC;EAG1CC,WAAWA,CAACC,IAAe,EAAEC,OAAe,EAAE;IAC5C,KAAK,CAACA,OAAO,CAAC;IACd,IAAI,CAACC,IAAI,GAAG,kBAAkB;IAC9B,IAAI,CAACF,IAAI,GAAGA,IAAI;IAChBG,MAAM,CAACC,cAAc,CAAC,IAAI,EAAEP,gBAAgB,CAACQ,SAAS,CAAC;EACzD;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,kBAAkBA,CACtCC,OAAuB,EACC;EACxB;EACA,MAAMC,eAAe,GAAGpB,eAAe,CAACmB,OAAO,CAAC;EAChD,IAAIC,eAAe,EAAE;IACnB,MAAM,IAAIX,gBAAgB,CAACW,eAAe,CAACR,IAAI,EAAEQ,eAAe,CAACP,OAAO,CAAC;EAC3E;;EAEA;EACA,MAAMQ,YAAY,GAAGpB,WAAW,CAACkB,OAAO,CAAC;EAEzC,IAAI;IACF,OAAO,MAAMpB,4BAA4B,CAACmB,kBAAkB,CAACG,YAAY,CAAC;EAC5E,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd;IACA,IAAIA,KAAK,YAAYZ,KAAK,EAAE;MAC1B,MAAMG,OAAO,GAAGS,KAAK,CAACT,OAAO;MAC7B,IAAIA,OAAO,CAACU,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QACtC,MAAM,IAAId,gBAAgB,CACxBP,WAAW,CAACE,cAAc,EAC1B,mBAAmBe,OAAO,CAACK,SAAS,EACtC,CAAC;MACH;MACA,IAAIX,OAAO,CAACU,QAAQ,CAAC,eAAe,CAAC,EAAE;QACrC,MAAM,IAAId,gBAAgB,CACxBP,WAAW,CAACG,aAAa,EACzB,2BAA2BQ,OAAO,EACpC,CAAC;MACH;MACA,IAAIA,OAAO,CAACU,QAAQ,CAAC,eAAe,CAAC,EAAE;QACrC,MAAM,IAAId,gBAAgB,CACxBP,WAAW,CAACI,aAAa,EACzB,0BAA0BO,OAAO,EACnC,CAAC;MACH;MACA,IAAIA,OAAO,CAACU,QAAQ,CAAC,UAAU,CAAC,EAAE;QAChC,MAAM,IAAId,gBAAgB,CACxBP,WAAW,CAACK,QAAQ,EACpB,cAAcM,OAAO,EACvB,CAAC;MACH;MACA,IAAIA,OAAO,CAACU,QAAQ,CAAC,oBAAoB,CAAC,EAAE;QAC1C,MAAM,IAAId,gBAAgB,CACxBP,WAAW,CAACM,kBAAkB,EAC9B,6BAA6BK,OAAO,EACtC,CAAC;MACH;MACA,IAAIA,OAAO,CAACU,QAAQ,CAAC,eAAe,CAAC,EAAE;QACrC,MAAM,IAAId,gBAAgB,CACxBP,WAAW,CAACC,aAAa,EACzB,kBAAkBU,OAAO,EAC3B,CAAC;MACH;IACF;IACA,MAAMS,KAAK;EACb;AACF;AAEA,SAASpB,WAAW","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/presets.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const PRESETS = {
+  balanced: {
+    quality: 80,
+    method: 3,
+    lossless: false,
+    stripMetadata: true,
+    threadLevel: 1
+  },
+  small: {
+    quality: 74,
+    method: 5,
+    lossless: false,
+    stripMetadata: true,
+    threadLevel: 1
+  },
+  fast: {
+    quality: 78,
+    method: 1,
+    lossless: false,
+    stripMetadata: true,
+    threadLevel: 1
+  },
+  lossless: {
+    lossless: true,
+    method: 4,
+    stripMetadata: true
+  },
+  document: {
+    quality: 82,
+    method: 4,
+    lossless: false,
+    stripMetadata: true,
+    exact: true // Will be set conditionally if alpha present
+  }
+};
+export function applyPreset(options) {
+  const preset = options.preset || 'balanced';
+  const presetConfig = PRESETS[preset];
+  const result = {
+    ...options
+  };
+
+  // Apply preset values only if not explicitly overridden
+  if (result.quality === undefined && presetConfig.quality !== undefined) {
+    result.quality = presetConfig.quality;
+  }
+  if (result.method === undefined && presetConfig.method !== undefined) {
+    result.method = presetConfig.method;
+  }
+  if (result.lossless === undefined && presetConfig.lossless !== undefined) {
+    result.lossless = presetConfig.lossless;
+  }
+  if (result.stripMetadata === undefined && presetConfig.stripMetadata !== undefined) {
+    result.stripMetadata = presetConfig.stripMetadata;
+  }
+
+  // Note: threadLevel and exact are handled natively, not passed through JS API
+  // They are documented here for reference but applied in native code
+
+  return result;
+}
+//# sourceMappingURL=presets.js.map

package/lib/module/presets.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PRESETS","balanced","quality","method","lossless","stripMetadata","threadLevel","small","fast","document","exact","applyPreset","options","preset","presetConfig","result","undefined"],"sourceRoot":"..\\..\\src","sources":["presets.ts"],"mappings":";;AAcA,MAAMA,OAA4C,GAAG;EACnDC,QAAQ,EAAE;IACRC,OAAO,EAAE,EAAE;IACXC,MAAM,EAAE,CAAC;IACTC,QAAQ,EAAE,KAAK;IACfC,aAAa,EAAE,IAAI;IACnBC,WAAW,EAAE;EACf,CAAC;EACDC,KAAK,EAAE;IACLL,OAAO,EAAE,EAAE;IACXC,MAAM,EAAE,CAAC;IACTC,QAAQ,EAAE,KAAK;IACfC,aAAa,EAAE,IAAI;IACnBC,WAAW,EAAE;EACf,CAAC;EACDE,IAAI,EAAE;IACJN,OAAO,EAAE,EAAE;IACXC,MAAM,EAAE,CAAC;IACTC,QAAQ,EAAE,KAAK;IACfC,aAAa,EAAE,IAAI;IACnBC,WAAW,EAAE;EACf,CAAC;EACDF,QAAQ,EAAE;IACRA,QAAQ,EAAE,IAAI;IACdD,MAAM,EAAE,CAAC;IACTE,aAAa,EAAE;EACjB,CAAC;EACDI,QAAQ,EAAE;IACRP,OAAO,EAAE,EAAE;IACXC,MAAM,EAAE,CAAC;IACTC,QAAQ,EAAE,KAAK;IACfC,aAAa,EAAE,IAAI;IACnBK,KAAK,EAAE,IAAI,CAAE;EACf;AACF,CAAC;AAED,OAAO,SAASC,WAAWA,CAACC,OAAuB,EAAkB;EACnE,MAAMC,MAAqB,GAAGD,OAAO,CAACC,MAAM,IAAI,UAAU;EAC1D,MAAMC,YAAY,GAAGd,OAAO,CAACa,MAAM,CAAC;EAEpC,MAAME,MAAsB,GAAG;IAC7B,GAAGH;EACL,CAAC;;EAED;EACA,IAAIG,MAAM,CAACb,OAAO,KAAKc,SAAS,IAAIF,YAAY,CAACZ,OAAO,KAAKc,SAAS,EAAE;IACtED,MAAM,CAACb,OAAO,GAAGY,YAAY,CAACZ,OAAO;EACvC;EACA,IAAIa,MAAM,CAACZ,MAAM,KAAKa,SAAS,IAAIF,YAAY,CAACX,MAAM,KAAKa,SAAS,EAAE;IACpED,MAAM,CAACZ,MAAM,GAAGW,YAAY,CAACX,MAAM;EACrC;EACA,IAAIY,MAAM,CAACX,QAAQ,KAAKY,SAAS,IAAIF,YAAY,CAACV,QAAQ,KAAKY,SAAS,EAAE;IACxED,MAAM,CAACX,QAAQ,GAAGU,YAAY,CAACV,QAAQ;EACzC;EACA,IACEW,MAAM,CAACV,aAAa,KAAKW,SAAS,IAClCF,YAAY,CAACT,aAAa,KAAKW,SAAS,EACxC;IACAD,MAAM,CAACV,aAAa,GAAGS,YAAY,CAACT,aAAa;EACnD;;EAEA;EACA;;EAEA,OAAOU,MAAM;AACf","ignoreList":[]}

package/lib/module/validation.js

@@ -0,0 +1,36 @@
+"use strict";
+
+export function validateOptions(options) {
+  if (!options.inputPath || typeof options.inputPath !== 'string') {
+    return {
+      code: 'INVALID_INPUT',
+      message: 'inputPath is required and must be a string'
+    };
+  }
+  if (options.maxLongEdge !== undefined) {
+    if (typeof options.maxLongEdge !== 'number' || options.maxLongEdge <= 0) {
+      return {
+        code: 'INVALID_INPUT',
+        message: 'maxLongEdge must be a positive number'
+      };
+    }
+  }
+  if (options.quality !== undefined) {
+    if (typeof options.quality !== 'number' || options.quality < 0 || options.quality > 100) {
+      return {
+        code: 'INVALID_INPUT',
+        message: 'quality must be a number between 0 and 100'
+      };
+    }
+  }
+  if (options.method !== undefined) {
+    if (typeof options.method !== 'number' || options.method < 0 || options.method > 6) {
+      return {
+        code: 'INVALID_INPUT',
+        message: 'method must be a number between 0 and 6'
+      };
+    }
+  }
+  return null;
+}
+//# sourceMappingURL=validation.js.map

package/lib/module/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["validateOptions","options","inputPath","code","message","maxLongEdge","undefined","quality","method"],"sourceRoot":"..\\..\\src","sources":["validation.ts"],"mappings":";;AAQA,OAAO,SAASA,eAAeA,CAC7BC,OAAuB,EACC;EACxB,IAAI,CAACA,OAAO,CAACC,SAAS,IAAI,OAAOD,OAAO,CAACC,SAAS,KAAK,QAAQ,EAAE;IAC/D,OAAO;MACLC,IAAI,EAAE,eAAe;MACrBC,OAAO,EAAE;IACX,CAAC;EACH;EAEA,IAAIH,OAAO,CAACI,WAAW,KAAKC,SAAS,EAAE;IACrC,IAAI,OAAOL,OAAO,CAACI,WAAW,KAAK,QAAQ,IAAIJ,OAAO,CAACI,WAAW,IAAI,CAAC,EAAE;MACvE,OAAO;QACLF,IAAI,EAAE,eAAe;QACrBC,OAAO,EAAE;MACX,CAAC;IACH;EACF;EAEA,IAAIH,OAAO,CAACM,OAAO,KAAKD,SAAS,EAAE;IACjC,IACE,OAAOL,OAAO,CAACM,OAAO,KAAK,QAAQ,IACnCN,OAAO,CAACM,OAAO,GAAG,CAAC,IACnBN,OAAO,CAACM,OAAO,GAAG,GAAG,EACrB;MACA,OAAO;QACLJ,IAAI,EAAE,eAAe;QACrBC,OAAO,EAAE;MACX,CAAC;IACH;EACF;EAEA,IAAIH,OAAO,CAACO,MAAM,KAAKF,SAAS,EAAE;IAChC,IACE,OAAOL,OAAO,CAACO,MAAM,KAAK,QAAQ,IAClCP,OAAO,CAACO,MAAM,GAAG,CAAC,IAClBP,OAAO,CAACO,MAAM,GAAG,CAAC,EAClB;MACA,OAAO;QACLL,IAAI,EAAE,eAAe;QACrBC,OAAO,EAAE;MACX,CAAC;IACH;EACF;EAEA,OAAO,IAAI;AACb","ignoreList":[]}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NativeReactNativeImageToWebp.d.ts

@@ -0,0 +1,24 @@
+import { type TurboModule } from 'react-native';
+export type ConvertPreset = 'balanced' | 'small' | 'fast' | 'lossless' | 'document';
+export interface ConvertOptions {
+    inputPath: string;
+    outputPath?: string;
+    preset?: ConvertPreset;
+    maxLongEdge?: number;
+    quality?: number;
+    method?: number;
+    lossless?: boolean;
+    stripMetadata?: boolean;
+}
+export interface ConvertResult {
+    outputPath: string;
+    width: number;
+    height: number;
+    sizeBytes: number;
+}
+export interface Spec extends TurboModule {
+    convertImageToWebP(options: ConvertOptions): Promise<ConvertResult>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeReactNativeImageToWebp.d.ts.map

package/lib/typescript/src/NativeReactNativeImageToWebp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeReactNativeImageToWebp.d.ts","sourceRoot":"","sources":["../../../src/NativeReactNativeImageToWebp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,OAAO,GACP,MAAM,GACN,UAAU,GACV,UAAU,CAAC;AAEf,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACrE;;AAED,wBAAgF"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,35 @@
+import { type ConvertOptions, type ConvertResult, type ConvertPreset } from './NativeReactNativeImageToWebp';
+export type { ConvertOptions, ConvertResult, ConvertPreset };
+declare const ERROR_CODES: {
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
+    readonly DECODE_FAILED: "DECODE_FAILED";
+    readonly ENCODE_FAILED: "ENCODE_FAILED";
+    readonly IO_ERROR: "IO_ERROR";
+    readonly UNSUPPORTED_FORMAT: "UNSUPPORTED_FORMAT";
+};
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+export declare class ImageToWebPError extends Error {
+    code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+}
+/**
+ * Convert an image file to WebP format.
+ *
+ * @param options - Conversion options
+ * @returns Promise resolving to conversion result with output path and metadata
+ * @throws {ImageToWebPError} If conversion fails
+ *
+ * @example
+ * ```ts
+ * const result = await convertImageToWebP({
+ *   inputPath: '/path/to/image.jpg',
+ *   preset: 'balanced',
+ *   maxLongEdge: 2048,
+ * });
+ * console.log(`Output: ${result.outputPath}, Size: ${result.sizeBytes} bytes`);
+ * ```
+ */
+export declare function convertImageToWebP(options: ConvertOptions): Promise<ConvertResult>;
+export { ERROR_CODES };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAqC,EACnC,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,gCAAgC,CAAC;AAIxC,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC;AAE7D,QAAA,MAAM,WAAW;;;;;;;CAOP,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAEvE,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,IAAI,EAAE,SAAS,CAAC;gBAEJ,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM;CAM7C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC,CAuDxB;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/lib/typescript/src/presets.d.ts

@@ -0,0 +1,3 @@
+import type { ConvertOptions } from './NativeReactNativeImageToWebp';
+export declare function applyPreset(options: ConvertOptions): ConvertOptions;
+//# sourceMappingURL=presets.d.ts.map

package/lib/typescript/src/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../src/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,gCAAgC,CAAC;AA+CxC,wBAAgB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CA6BnE"}

package/lib/typescript/src/validation.d.ts

@@ -0,0 +1,9 @@
+import type { ConvertOptions } from './NativeReactNativeImageToWebp';
+import type { ErrorCode } from './index';
+interface ValidationError {
+    code: ErrorCode;
+    message: string;
+}
+export declare function validateOptions(options: ConvertOptions): ValidationError | null;
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/lib/typescript/src/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,UAAU,eAAe;IACvB,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,cAAc,GACtB,eAAe,GAAG,IAAI,CA4CxB"}