cross-image 0.2.2 → 0.2.3

package/esm/src/types.d.ts

@@ -24,6 +24,32 @@ export interface ImageMetadata {
     copyright?: string;
     /** Creation date */
     creationDate?: Date;
+    /** Camera make/manufacturer (e.g., "Canon", "Nikon") */
+    cameraMake?: string;
+    /** Camera model (e.g., "Canon EOS 5D Mark IV") */
+    cameraModel?: string;
+    /** Lens make/manufacturer */
+    lensMake?: string;
+    /** Lens model */
+    lensModel?: string;
+    /** ISO speed rating (e.g., 100, 400, 3200) */
+    iso?: number;
+    /** Exposure time / Shutter speed in seconds (e.g., 0.0125 = 1/80s) */
+    exposureTime?: number;
+    /** F-number / Aperture (e.g., 2.8, 5.6, 16) */
+    fNumber?: number;
+    /** Focal length in millimeters (e.g., 50, 85, 200) */
+    focalLength?: number;
+    /** Flash mode (0 = no flash, 1 = flash fired) */
+    flash?: number;
+    /** White balance mode (0 = auto, 1 = manual) */
+    whiteBalance?: number;
+    /** Orientation (1 = normal, 3 = 180°, 6 = 90° CW, 8 = 90° CCW) */
+    orientation?: number;
+    /** Software used to create/edit the image */
+    software?: string;
+    /** User comment / notes */
+    userComment?: string;
     /** Custom metadata fields */
     custom?: Record<string, string | number | boolean>;
 }
@@ -88,7 +114,16 @@ export interface ResizeOptions {
     /** Target height in pixels */
     height: number;
     /** Resize method (default: "bilinear") */
-    method?: "nearest" | "bilinear";
+    method?: "nearest" | "bilinear" | "bicubic";
+    /**
+     * Fitting mode (default: "stretch")
+     * - "stretch": Stretch image to fill dimensions (may distort)
+     * - "fit": Fit image within dimensions maintaining aspect ratio (may have letterboxing)
+     * - "fill": Fill dimensions maintaining aspect ratio (may crop)
+     * - "cover": Alias for "fill"
+     * - "contain": Alias for "fit"
+     */
+    fit?: "stretch" | "fit" | "fill" | "cover" | "contain";
 }
 /**
  * Options for ASCII art encoding
@@ -163,5 +198,10 @@ export interface ImageFormat {
      * Check if the format supports multiple frames
      */
     supportsMultipleFrames?(): boolean;
+    /**
+     * Get the list of metadata fields supported by this format
+     * @returns Array of metadata field names that can be persisted
+     */
+    getSupportedMetadata?(): Array<keyof ImageMetadata>;
 }
 //# sourceMappingURL=types.d.ts.map

package/esm/src/utils/image_processing.d.ts

@@ -44,6 +44,13 @@ export declare function adjustExposure(data: Uint8Array, amount: number): Uint8A
  * @returns New image data with adjusted saturation
  */
 export declare function adjustSaturation(data: Uint8Array, amount: number): Uint8Array;
+/**
+ * Adjust hue of an image by rotating the hue wheel
+ * @param data Image data (RGBA)
+ * @param degrees Hue rotation in degrees (any value accepted, wraps at 360)
+ * @returns New image data with adjusted hue
+ */
+export declare function adjustHue(data: Uint8Array, degrees: number): Uint8Array;
 /**
  * Invert colors of an image
  * @param data Image data (RGBA)
@@ -131,4 +138,52 @@ export declare function sepia(data: Uint8Array): Uint8Array;
  * @returns New image data with median filter applied
  */
 export declare function medianFilter(data: Uint8Array, width: number, height: number, radius?: number): Uint8Array;
+/**
+ * Rotate image 90 degrees clockwise
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+export declare function rotate90(data: Uint8Array, width: number, height: number): {
+    data: Uint8Array;
+    width: number;
+    height: number;
+};
+/**
+ * Rotate image 180 degrees
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with same dimensions
+ */
+export declare function rotate180(data: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Rotate image 270 degrees clockwise (or 90 degrees counter-clockwise)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+export declare function rotate270(data: Uint8Array, width: number, height: number): {
+    data: Uint8Array;
+    width: number;
+    height: number;
+};
+/**
+ * Flip image horizontally (mirror)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+export declare function flipHorizontal(data: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Flip image vertically
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+export declare function flipVertical(data: Uint8Array, width: number, height: number): Uint8Array;
 //# sourceMappingURL=image_processing.d.ts.map

package/esm/src/utils/image_processing.js

@@ -131,6 +131,99 @@ export function adjustSaturation(data, amount) {
     }
     return result;
 }
+/**
+ * Convert RGB to HSL color space
+ * @param r Red component (0-255)
+ * @param g Green component (0-255)
+ * @param b Blue component (0-255)
+ * @returns HSL values: [h (0-360), s (0-1), l (0-1)]
+ */
+function rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const delta = max - min;
+    let h = 0;
+    let s = 0;
+    const l = (max + min) / 2;
+    if (delta !== 0) {
+        s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+        if (max === r) {
+            h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+        }
+        else if (max === g) {
+            h = ((b - r) / delta + 2) / 6;
+        }
+        else {
+            h = ((r - g) / delta + 4) / 6;
+        }
+    }
+    return [h * 360, s, l];
+}
+/**
+ * Convert HSL to RGB color space
+ * @param h Hue (0-360)
+ * @param s Saturation (0-1)
+ * @param l Lightness (0-1)
+ * @returns RGB values: [r (0-255), g (0-255), b (0-255)]
+ */
+function hslToRgb(h, s, l) {
+    h = h / 360;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l; // Achromatic
+    }
+    else {
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+/**
+ * Adjust hue of an image by rotating the hue wheel
+ * @param data Image data (RGBA)
+ * @param degrees Hue rotation in degrees (any value accepted, wraps at 360)
+ * @returns New image data with adjusted hue
+ */
+export function adjustHue(data, degrees) {
+    const result = new Uint8Array(data.length);
+    // Normalize rotation to -180 to 180 range
+    const rotation = ((degrees % 360) + 360) % 360;
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const b = data[i + 2];
+        // Convert to HSL
+        const [h, s, l] = rgbToHsl(r, g, b);
+        // Rotate hue
+        const newH = (h + rotation) % 360;
+        // Convert back to RGB
+        const [newR, newG, newB] = hslToRgb(newH, s, l);
+        result[i] = newR;
+        result[i + 1] = newG;
+        result[i + 2] = newB;
+        result[i + 3] = data[i + 3]; // Preserve alpha
+    }
+    return result;
+}
 /**
  * Invert colors of an image
  * @param data Image data (RGBA)
@@ -459,3 +552,120 @@ export function medianFilter(data, width, height, radius = 1) {
     }
     return result;
 }
+/**
+ * Rotate image 90 degrees clockwise
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+export function rotate90(data, width, height) {
+    const result = new Uint8Array(data.length);
+    const newWidth = height;
+    const newHeight = width;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = height - 1 - y;
+            const dstY = x;
+            const dstIdx = (dstY * newWidth + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return { data: result, width: newWidth, height: newHeight };
+}
+/**
+ * Rotate image 180 degrees
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with same dimensions
+ */
+export function rotate180(data, width, height) {
+    const result = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = width - 1 - x;
+            const dstY = height - 1 - y;
+            const dstIdx = (dstY * width + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return result;
+}
+/**
+ * Rotate image 270 degrees clockwise (or 90 degrees counter-clockwise)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+export function rotate270(data, width, height) {
+    const result = new Uint8Array(data.length);
+    const newWidth = height;
+    const newHeight = width;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = y;
+            const dstY = width - 1 - x;
+            const dstIdx = (dstY * newWidth + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return { data: result, width: newWidth, height: newHeight };
+}
+/**
+ * Flip image horizontally (mirror)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+export function flipHorizontal(data, width, height) {
+    const result = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = width - 1 - x;
+            const dstIdx = (y * width + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return result;
+}
+/**
+ * Flip image vertically
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+export function flipVertical(data, width, height) {
+    const result = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstY = height - 1 - y;
+            const dstIdx = (dstY * width + x) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return result;
+}

package/esm/src/utils/metadata/xmp.d.ts

@@ -0,0 +1,52 @@
+/**
+ * XMP (Extensible Metadata Platform) parsing and writing utilities
+ *
+ * This module provides utilities for reading and writing XMP metadata in image files.
+ * It supports Dublin Core, EXIF, and Photoshop namespaces.
+ */
+import type { ImageMetadata } from "../../types.js";
+/**
+ * XMP namespace URIs
+ */
+export declare const XMP_NAMESPACES: {
+    readonly RDF: "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+    readonly DC: "http://purl.org/dc/elements/1.1/";
+    readonly XMP: "http://ns.adobe.com/xap/1.0/";
+    readonly EXIF: "http://ns.adobe.com/exif/1.0/";
+    readonly TIFF: "http://ns.adobe.com/tiff/1.0/";
+    readonly PHOTOSHOP: "http://ns.adobe.com/photoshop/1.0/";
+    readonly XMP_RIGHTS: "http://ns.adobe.com/xap/1.0/rights/";
+};
+/**
+ * XMP Dublin Core field mapping to ImageMetadata
+ */
+export interface XMPFieldMapping {
+    xmpPath: string;
+    metadataKey: keyof ImageMetadata;
+    namespace: string;
+}
+/**
+ * Supported XMP fields and their mappings
+ */
+export declare const XMP_FIELD_MAPPINGS: XMPFieldMapping[];
+/**
+ * Escape XML special characters
+ */
+export declare function escapeXML(str: string): string;
+/**
+ * Unescape XML special characters
+ */
+export declare function unescapeXML(str: string): string;
+/**
+ * Parse XMP metadata from XML string
+ */
+export declare function parseXMP(xmpStr: string): Partial<ImageMetadata>;
+/**
+ * Create XMP packet from metadata
+ */
+export declare function createXMP(metadata: Partial<ImageMetadata>): string;
+/**
+ * Get list of supported XMP metadata fields
+ */
+export declare function getSupportedXMPFields(): Array<keyof ImageMetadata>;
+//# sourceMappingURL=xmp.d.ts.map