cross-image 0.2.3 → 0.4.0

package/esm/src/formats/apng.js

@@ -67,8 +67,8 @@ export class APNGFormat extends PNGBase {
      * @param data Raw APNG image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    async decode(data) {
-        const frames = await this.decodeFrames(data);
+    async decode(data, settings) {
+        const frames = await this.decodeFrames(data, settings);
         const firstFrame = frames.frames[0];
         return {
             width: firstFrame.width,
@@ -82,7 +82,7 @@ export class APNGFormat extends PNGBase {
      * @param data Raw APNG image data
      * @returns Decoded multi-frame image data
      */
-    async decodeFrames(data) {
+    async decodeFrames(data, _settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid APNG signature or missing acTL chunk");
         }
@@ -169,9 +169,7 @@ export class APNGFormat extends PNGBase {
                 const delayDen = this.readUint16(chunk.data, 22);
                 const disposeOp = chunk.data[24];
                 const blendOp = chunk.data[25];
-                const delay = delayDen === 0
-                    ? delayNum * 10
-                    : Math.round((delayNum / delayDen) * 1000);
+                const delay = delayDen === 0 ? delayNum * 10 : Math.round((delayNum / delayDen) * 1000);
                 let disposal = "none";
                 if (disposeOp === 1)
                     disposal = "background";
@@ -254,7 +252,7 @@ export class APNGFormat extends PNGBase {
      * @param imageData Image data to encode
      * @returns Encoded APNG image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         // For single frame, create a multi-frame with one frame
         const multiFrame = {
             width: imageData.width,
@@ -267,14 +265,14 @@ export class APNGFormat extends PNGBase {
                 }],
             metadata: imageData.metadata,
         };
-        return this.encodeFrames(multiFrame);
+        return this.encodeFrames(multiFrame, _options);
     }
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
      * @returns Encoded APNG image bytes
      */
-    async encodeFrames(imageData) {
+    async encodeFrames(imageData, _options) {
         const { width, height, frames, metadata } = imageData;
         if (frames.length === 0) {
             throw new Error("No frames to encode");
@@ -361,4 +359,101 @@ export class APNGFormat extends PNGBase {
         const rgba = this.unfilterAndConvert(decompressed, width, height, bitDepth, colorType);
         return rgba;
     }
+    /**
+     * Get the list of metadata fields supported by APNG format
+     * Includes all PNG fields plus frame count
+     */
+    getSupportedMetadata() {
+        return [
+            ...super.getSupportedMetadata(),
+            "frameCount", // acTL chunk
+        ];
+    }
+    /**
+     * Extract metadata from APNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata including frame count
+     * @param data Raw APNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        let pos = 8; // Skip PNG signature
+        let width = 0;
+        let height = 0;
+        let frameCount = 0;
+        const metadata = {
+            format: "apng",
+            compression: "deflate",
+        };
+        // Parse chunks for metadata only
+        while (pos < data.length) {
+            if (pos + 8 > data.length)
+                break;
+            const length = this.readUint32(data, pos);
+            pos += 4;
+            const type = String.fromCharCode(data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
+            pos += 4;
+            if (pos + length + 4 > data.length)
+                break;
+            const chunkData = data.slice(pos, pos + length);
+            pos += length;
+            pos += 4; // Skip CRC
+            if (type === "IHDR") {
+                width = this.readUint32(chunkData, 0);
+                height = this.readUint32(chunkData, 4);
+                // Parse bit depth and color type from IHDR
+                if (chunkData.length >= 9) {
+                    metadata.bitDepth = chunkData[8];
+                    const colorTypeCode = chunkData[9];
+                    // PNG color types: 0=grayscale, 2=rgb, 3=indexed, 4=grayscale+alpha, 6=rgba
+                    switch (colorTypeCode) {
+                        case 0:
+                            metadata.colorType = "grayscale";
+                            break;
+                        case 2:
+                            metadata.colorType = "rgb";
+                            break;
+                        case 3:
+                            metadata.colorType = "indexed";
+                            break;
+                        case 4:
+                            metadata.colorType = "grayscale-alpha";
+                            break;
+                        case 6:
+                            metadata.colorType = "rgba";
+                            break;
+                    }
+                }
+            }
+            else if (type === "acTL") {
+                // Animation control chunk - contains frame count
+                if (chunkData.length >= 4) {
+                    frameCount = this.readUint32(chunkData, 0);
+                    metadata.frameCount = frameCount;
+                }
+            }
+            else if (type === "pHYs") {
+                // Physical pixel dimensions
+                this.parsePhysChunk(chunkData, metadata, width, height);
+            }
+            else if (type === "tEXt") {
+                // Text chunk
+                this.parseTextChunk(chunkData, metadata);
+            }
+            else if (type === "iTXt") {
+                // International text chunk
+                this.parseITxtChunk(chunkData, metadata);
+            }
+            else if (type === "eXIf") {
+                // EXIF chunk
+                this.parseExifChunk(chunkData, metadata);
+            }
+            else if (type === "IEND") {
+                break;
+            }
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }

package/esm/src/formats/ascii.d.ts

@@ -1,4 +1,4 @@
-import type { ASCIIOptions, ImageData, ImageFormat } from "../types.js";
+import type { ASCIIEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * ASCII format handler
  * Converts images to ASCII art text representation
@@ -22,17 +22,27 @@ export declare class ASCIIFormat implements ImageFormat {
      * @param data Raw ASCII art data
      * @returns Decoded image data with grayscale RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to ASCII art
      * @param imageData Image data to encode
      * @param options Optional ASCII encoding options
      * @returns Encoded ASCII art as UTF-8 bytes
      */
-    encode(imageData: ImageData, options?: ASCIIOptions): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: ASCIIEncoderOptions): Promise<Uint8Array>;
     /**
      * Parse options from the options line
      */
     private parseOptions;
+    /**
+     * Get the list of metadata fields supported by ASCII format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from ASCII art data without fully decoding
+     * @param data Raw ASCII art data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=ascii.d.ts.map

package/esm/src/formats/ascii.js

@@ -68,7 +68,7 @@ export class ASCIIFormat {
      * @param data Raw ASCII art data
      * @returns Decoded image data with grayscale RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid ASCII art signature");
         }
@@ -183,4 +183,28 @@ export class ASCIIFormat {
         }
         return options;
     }
+    /**
+     * Get the list of metadata fields supported by ASCII format
+     */
+    getSupportedMetadata() {
+        return []; // ASCII art doesn't support metadata preservation
+    }
+    /**
+     * Extract metadata from ASCII art data without fully decoding
+     * @param data Raw ASCII art data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "ascii",
+            compression: "none",
+            frameCount: 1,
+            bitDepth: 1, // ASCII is 1-bit (character or no character)
+            colorType: "grayscale",
+        };
+        return Promise.resolve(metadata);
+    }
 }

package/esm/src/formats/avif.d.ts

@@ -0,0 +1,96 @@
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
+/**
+ * AVIF format handler
+ * Supports AVIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
+ * Note: Pure JavaScript encode/decode is not supported due to complexity
+ */
+export declare class AVIFFormat implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "avif";
+    /** MIME type for AVIF images */
+    readonly mimeType = "image/avif";
+    /**
+     * Check if the given data is an AVIF image
+     * @param data Raw image data to check
+     * @returns true if data has AVIF signature
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode AVIF image data to RGBA
+     * Uses runtime APIs (ImageDecoder) for decoding
+     * @param data Raw AVIF image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
+    /**
+     * Encode RGBA image data to AVIF format
+     * Uses runtime APIs (OffscreenCanvas) for encoding
+     *
+     * Note: Metadata injection is not currently implemented. Metadata may be lost during encoding
+     * as it would require parsing and modifying the ISOBMFF container structure.
+     *
+     * @param imageData Image data to encode
+     * @returns Encoded AVIF image bytes
+     */
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    /**
+     * Decode using runtime APIs
+     * @param data Raw AVIF data
+     * @returns Decoded image dimensions and pixel data
+     */
+    private decodeUsingRuntime;
+    /**
+     * Parse EXIF metadata from AVIF data
+     *
+     * Note: This is a simplified implementation that searches for EXIF headers linearly.
+     * A full implementation would require navigating the ISOBMFF box structure to find
+     * the 'meta' box and then the 'Exif' item. This simplified approach may not work
+     * in all cases but is suitable for basic metadata extraction when runtime APIs are
+     * not available or as a fallback.
+     *
+     * @param data Raw AVIF data
+     * @param metadata Metadata object to populate
+     */
+    private parseEXIF;
+    /**
+     * Parse TIFF-formatted EXIF data
+     * @param data EXIF data in TIFF format
+     * @param metadata Metadata object to populate
+     */
+    private parseTIFFExif;
+    /**
+     * Parse Exif Sub-IFD for camera settings
+     * @param data EXIF data
+     * @param exifIfdOffset Offset to Exif Sub-IFD
+     * @param littleEndian Byte order
+     * @param metadata Metadata object to populate
+     */
+    private parseExifSubIFD;
+    /**
+     * Parse GPS IFD for location data
+     * @param data EXIF data
+     * @param gpsIfdOffset Offset to GPS IFD
+     * @param littleEndian Byte order
+     * @param metadata Metadata object to populate
+     */
+    private parseGPSIFD;
+    /**
+     * Read a rational value (numerator/denominator)
+     * @param data Data buffer
+     * @param offset Offset to rational
+     * @param littleEndian Byte order
+     * @returns Decimal value
+     */
+    private readRational;
+    /**
+     * Get the list of metadata fields supported by AVIF format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from AVIF data without fully decoding the pixel data
+     * @param data Raw AVIF data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
+}
+//# sourceMappingURL=avif.d.ts.map