bun-image-turbo 0.0.2-beta

package/dist/index.d.ts

@@ -0,0 +1,327 @@
+/**
+ * bun-image-turbo Types
+ */
+/** Supported image formats */
+type ImageFormat = 'jpeg' | 'png' | 'webp' | 'gif' | 'bmp' | 'ico' | 'tiff' | 'avif';
+/** Resize filter/algorithm */
+type ResizeFilter = 'nearest' | 'bilinear' | 'catmullRom' | 'mitchell' | 'lanczos3';
+/** Image fit mode for resize */
+type FitMode = 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+/** Resize options */
+interface ResizeOptions {
+    /** Target width (optional if height is provided) */
+    width?: number;
+    /** Target height (optional if width is provided) */
+    height?: number;
+    /** Resize filter/algorithm (default: lanczos3) */
+    filter?: ResizeFilter;
+    /** Fit mode (default: cover) */
+    fit?: FitMode;
+    /** Background color for padding [r, g, b, a] (default: transparent) */
+    background?: number[];
+}
+/** JPEG encode options */
+interface JpegOptions {
+    /** Quality 1-100 (default: 80) */
+    quality?: number;
+}
+/** PNG encode options */
+interface PngOptions {
+    /** Compression level 0-9 (default: 6) */
+    compression?: number;
+}
+/** WebP encode options */
+interface WebPOptions {
+    /** Quality 1-100 for lossy, ignored for lossless (default: 80) */
+    quality?: number;
+    /** Use lossless compression (default: false) */
+    lossless?: boolean;
+}
+/** AVIF encode options */
+interface AvifOptions {
+    /** Quality 1-100 (default: 80) */
+    quality?: number;
+    /** Speed 1-10, higher is faster but lower quality (default: 6) */
+    speed?: number;
+}
+/** Output format options */
+interface OutputOptions {
+    /** Output format */
+    format: ImageFormat;
+    /** JPEG options (if format is jpeg) */
+    jpeg?: JpegOptions;
+    /** PNG options (if format is png) */
+    png?: PngOptions;
+    /** WebP options (if format is webp) */
+    webp?: WebPOptions;
+    /** AVIF options (if format is avif) */
+    avif?: AvifOptions;
+}
+/** Image metadata (sharp-compatible) */
+interface ImageMetadata {
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+    /** Detected format (jpeg, png, webp, gif, bmp, ico, tiff) */
+    format: string;
+    /** File size in bytes */
+    size?: number;
+    /** Color space (srgb, rgb, grayscale) */
+    space: string;
+    /** Number of channels (1, 2, 3, or 4) */
+    channels: number;
+    /** Bit depth per sample (uchar = 8-bit, ushort = 16-bit) */
+    depth: string;
+    /** Whether the image has an alpha channel */
+    hasAlpha: boolean;
+    /** Bits per sample */
+    bitsPerSample: number;
+    /** Whether the image is progressive (JPEG) or interlaced (PNG) */
+    isProgressive: boolean;
+    /** Whether the image uses palette/indexed colors (PNG/GIF) */
+    isPalette: boolean;
+    /** Whether the image has an embedded ICC profile */
+    hasProfile: boolean;
+    /** EXIF orientation value (1-8, if present) */
+    orientation?: number;
+    /** Page/frame count for multi-page images (GIF, TIFF) */
+    pages?: number;
+    /** Loop count for animated images */
+    loopCount?: number;
+    /** Delay between frames in ms (for animated images) */
+    delay?: number[];
+    /** Background color (for GIF) */
+    background?: number[];
+    /** Compression type used */
+    compression?: string;
+    /** Density/DPI info */
+    density?: number;
+}
+/** Blurhash result */
+interface BlurHashResult {
+    /** The blurhash string */
+    hash: string;
+    /** Original width */
+    width: number;
+    /** Original height */
+    height: number;
+}
+/** Transform options (all-in-one processing) */
+interface TransformOptions {
+    /** Resize options */
+    resize?: ResizeOptions;
+    /** Output options */
+    output?: OutputOptions;
+    /** Rotate degrees (90, 180, 270) */
+    rotate?: number;
+    /** Flip horizontally */
+    flipH?: boolean;
+    /** Flip vertically */
+    flipV?: boolean;
+    /** Grayscale conversion */
+    grayscale?: boolean;
+    /** Blur radius (0-100) */
+    blur?: number;
+    /** Sharpen amount (0-100) */
+    sharpen?: number;
+    /** Brightness adjustment (-100 to 100) */
+    brightness?: number;
+    /** Contrast adjustment (-100 to 100) */
+    contrast?: number;
+}
+
+/**
+ * bun-image-turbo - High-performance image processing for Bun and Node.js
+ *
+ * @module bun-image-turbo
+ * @author Aissam Irhir <aissamirhir@gmail.com>
+ *
+ * @example
+ * ```typescript
+ * import { resize, toWebp, metadata } from 'bun-image-turbo';
+ *
+ * // Read image
+ * const input = await Bun.file('input.jpg').arrayBuffer();
+ *
+ * // Resize image
+ * const resized = await resize(Buffer.from(input), { width: 800, height: 600 });
+ *
+ * // Convert to WebP
+ * const webp = await toWebp(Buffer.from(input), { quality: 85 });
+ *
+ * // Get metadata
+ * const info = await metadata(Buffer.from(input));
+ * console.log(info.width, info.height, info.format);
+ * ```
+ */
+
+/**
+ * Get image metadata asynchronously
+ *
+ * @param input - Image buffer
+ * @returns Promise resolving to image metadata
+ *
+ * @example
+ * ```typescript
+ * const info = await metadata(imageBuffer);
+ * console.log(`${info.width}x${info.height} ${info.format}`);
+ * ```
+ */
+declare function metadata(input: Buffer): Promise<ImageMetadata>;
+/**
+ * Resize image asynchronously
+ *
+ * @param input - Image buffer
+ * @param options - Resize options
+ * @returns Promise resolving to resized image buffer (PNG)
+ *
+ * @example
+ * ```typescript
+ * // Resize to specific dimensions
+ * const resized = await resize(imageBuffer, { width: 800, height: 600 });
+ *
+ * // Resize maintaining aspect ratio
+ * const thumb = await resize(imageBuffer, { width: 200 });
+ *
+ * // High-quality resize
+ * const hq = await resize(imageBuffer, {
+ *   width: 1920,
+ *   filter: 'lanczos3',
+ *   fit: 'contain'
+ * });
+ * ```
+ */
+declare function resize(input: Buffer, options: ResizeOptions): Promise<Buffer>;
+/**
+ * Convert image to JPEG asynchronously
+ *
+ * @param input - Image buffer
+ * @param options - JPEG encoding options
+ * @returns Promise resolving to JPEG buffer
+ *
+ * @example
+ * ```typescript
+ * const jpeg = await toJpeg(imageBuffer, { quality: 85 });
+ * ```
+ */
+declare function toJpeg(input: Buffer, options?: JpegOptions): Promise<Buffer>;
+/**
+ * Convert image to PNG asynchronously
+ *
+ * @param input - Image buffer
+ * @param options - PNG encoding options
+ * @returns Promise resolving to PNG buffer
+ *
+ * @example
+ * ```typescript
+ * const png = await toPng(imageBuffer, { compression: 9 });
+ * ```
+ */
+declare function toPng(input: Buffer, options?: PngOptions): Promise<Buffer>;
+/**
+ * Convert image to WebP asynchronously
+ *
+ * @param input - Image buffer
+ * @param options - WebP encoding options
+ * @returns Promise resolving to WebP buffer
+ *
+ * @example
+ * ```typescript
+ * // Lossy WebP
+ * const webp = await toWebp(imageBuffer, { quality: 80 });
+ *
+ * // Lossless WebP
+ * const lossless = await toWebp(imageBuffer, { lossless: true });
+ * ```
+ */
+declare function toWebp(input: Buffer, options?: WebPOptions): Promise<Buffer>;
+/**
+ * Transform image with multiple operations asynchronously
+ *
+ * This is the most efficient way to apply multiple transformations
+ * as it processes the image only once.
+ *
+ * @param input - Image buffer
+ * @param options - Transform options
+ * @returns Promise resolving to transformed image buffer
+ *
+ * @example
+ * ```typescript
+ * const result = await transform(imageBuffer, {
+ *   resize: { width: 800, height: 600 },
+ *   rotate: 90,
+ *   grayscale: true,
+ *   output: { format: 'webp', webp: { quality: 85 } }
+ * });
+ * ```
+ */
+declare function transform(input: Buffer, options: TransformOptions): Promise<Buffer>;
+/**
+ * Generate blurhash from image asynchronously
+ *
+ * Blurhash is a compact representation of a placeholder for an image.
+ *
+ * @param input - Image buffer
+ * @param componentsX - Number of X components (default: 4)
+ * @param componentsY - Number of Y components (default: 3)
+ * @returns Promise resolving to blurhash result
+ *
+ * @example
+ * ```typescript
+ * const { hash, width, height } = await blurhash(imageBuffer);
+ * console.log(hash); // "LEHV6nWB2yk8pyo0adR*.7kCMdnj"
+ * ```
+ */
+declare function blurhash(input: Buffer, componentsX?: number, componentsY?: number): Promise<BlurHashResult>;
+/**
+ * Get image metadata synchronously
+ */
+declare function metadataSync(input: Buffer): ImageMetadata;
+/**
+ * Resize image synchronously
+ */
+declare function resizeSync(input: Buffer, options: ResizeOptions): Buffer;
+/**
+ * Convert image to JPEG synchronously
+ */
+declare function toJpegSync(input: Buffer, options?: JpegOptions): Buffer;
+/**
+ * Convert image to PNG synchronously
+ */
+declare function toPngSync(input: Buffer, options?: PngOptions): Buffer;
+/**
+ * Convert image to WebP synchronously
+ */
+declare function toWebpSync(input: Buffer, options?: WebPOptions): Buffer;
+/**
+ * Transform image with multiple operations synchronously
+ */
+declare function transformSync(input: Buffer, options: TransformOptions): Buffer;
+/**
+ * Generate blurhash from image synchronously
+ */
+declare function blurhashSync(input: Buffer, componentsX?: number, componentsY?: number): BlurHashResult;
+/**
+ * Get library version
+ */
+declare function version(): string;
+declare const _default: {
+    metadata: typeof metadata;
+    metadataSync: typeof metadataSync;
+    resize: typeof resize;
+    resizeSync: typeof resizeSync;
+    toJpeg: typeof toJpeg;
+    toJpegSync: typeof toJpegSync;
+    toPng: typeof toPng;
+    toPngSync: typeof toPngSync;
+    toWebp: typeof toWebp;
+    toWebpSync: typeof toWebpSync;
+    transform: typeof transform;
+    transformSync: typeof transformSync;
+    blurhash: typeof blurhash;
+    blurhashSync: typeof blurhashSync;
+    version: typeof version;
+};
+
+export { type AvifOptions, type BlurHashResult, type FitMode, type ImageFormat, type ImageMetadata, type JpegOptions, type OutputOptions, type PngOptions, type ResizeFilter, type ResizeOptions, type TransformOptions, type WebPOptions, blurhash, blurhashSync, _default as default, metadata, metadataSync, resize, resizeSync, toJpeg, toJpegSync, toPng, toPngSync, toWebp, toWebpSync, transform, transformSync, version };

package/dist/index.js

@@ -0,0 +1,228 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  blurhash: () => blurhash,
+  blurhashSync: () => blurhashSync,
+  default: () => index_default,
+  metadata: () => metadata,
+  metadataSync: () => metadataSync,
+  resize: () => resize,
+  resizeSync: () => resizeSync,
+  toJpeg: () => toJpeg,
+  toJpegSync: () => toJpegSync,
+  toPng: () => toPng,
+  toPngSync: () => toPngSync,
+  toWebp: () => toWebp,
+  toWebpSync: () => toWebpSync,
+  transform: () => transform,
+  transformSync: () => transformSync,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_url = require("url");
+var import_meta = {};
+var getCurrentDir = () => {
+  try {
+    return (0, import_path.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+  } catch {
+    return __dirname;
+  }
+};
+function loadNativeBinding() {
+  const platform = process.platform;
+  const arch = process.arch;
+  let targetName;
+  switch (platform) {
+    case "darwin":
+      targetName = arch === "arm64" ? "darwin-arm64" : "darwin-x64";
+      break;
+    case "linux":
+      const isMusl = (0, import_fs.existsSync)("/etc/alpine-release") || process.env.npm_config_libc === "musl";
+      if (arch === "arm64") {
+        targetName = isMusl ? "linux-arm64-musl" : "linux-arm64-gnu";
+      } else {
+        targetName = isMusl ? "linux-x64-musl" : "linux-x64-gnu";
+      }
+      break;
+    case "win32":
+      targetName = "win32-x64-msvc";
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
+  const currentDir = getCurrentDir();
+  const possiblePaths = [
+    // Same directory as this file (dist/)
+    (0, import_path.join)(currentDir, `image-turbo.${targetName}.node`),
+    // Parent directory (package root)
+    (0, import_path.join)(currentDir, "..", `image-turbo.${targetName}.node`),
+    // CWD (development)
+    (0, import_path.join)(process.cwd(), `image-turbo.${targetName}.node`)
+  ];
+  for (const modulePath of possiblePaths) {
+    try {
+      if ((0, import_fs.existsSync)(modulePath)) {
+        return require(modulePath);
+      }
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(
+    `Failed to load native binding for ${platform}-${arch}. Tried: ${possiblePaths.join(", ")}`
+  );
+}
+var native = loadNativeBinding();
+function toNapiFilter(filter) {
+  if (!filter) return void 0;
+  return filter.charAt(0).toUpperCase() + filter.slice(1);
+}
+function toNapiFit(fit) {
+  if (!fit) return void 0;
+  return fit.charAt(0).toUpperCase() + fit.slice(1);
+}
+function toNapiResizeOptions(options) {
+  return {
+    width: options.width,
+    height: options.height,
+    filter: toNapiFilter(options.filter),
+    fit: toNapiFit(options.fit),
+    background: options.background
+  };
+}
+function toNapiFormat(format) {
+  const formatMap = {
+    jpeg: "Jpeg",
+    png: "Png",
+    webp: "WebP",
+    gif: "Gif",
+    bmp: "Bmp",
+    ico: "Ico",
+    tiff: "Tiff"
+  };
+  return formatMap[format.toLowerCase()] || format;
+}
+function toNapiTransformOptions(options) {
+  const result = {};
+  if (options.resize) {
+    result.resize = toNapiResizeOptions(options.resize);
+  }
+  if (options.output) {
+    result.output = {
+      format: toNapiFormat(options.output.format),
+      jpeg: options.output.jpeg,
+      png: options.output.png,
+      webp: options.output.webp
+    };
+  }
+  result.rotate = options.rotate;
+  result.flipH = options.flipH;
+  result.flipV = options.flipV;
+  result.grayscale = options.grayscale;
+  result.blur = options.blur;
+  result.sharpen = options.sharpen;
+  result.brightness = options.brightness;
+  result.contrast = options.contrast;
+  return result;
+}
+async function metadata(input) {
+  return native.metadata(input);
+}
+async function resize(input, options) {
+  return native.resize(input, toNapiResizeOptions(options));
+}
+async function toJpeg(input, options) {
+  return native.toJpeg(input, options);
+}
+async function toPng(input, options) {
+  return native.toPng(input, options);
+}
+async function toWebp(input, options) {
+  return native.toWebp(input, options);
+}
+async function transform(input, options) {
+  return native.transform(input, toNapiTransformOptions(options));
+}
+async function blurhash(input, componentsX, componentsY) {
+  return native.blurhash(input, componentsX, componentsY);
+}
+function metadataSync(input) {
+  return native.metadataSync(input);
+}
+function resizeSync(input, options) {
+  return native.resizeSync(input, toNapiResizeOptions(options));
+}
+function toJpegSync(input, options) {
+  return native.toJpegSync(input, options);
+}
+function toPngSync(input, options) {
+  return native.toPngSync(input, options);
+}
+function toWebpSync(input, options) {
+  return native.toWebpSync(input, options);
+}
+function transformSync(input, options) {
+  return native.transformSync(input, toNapiTransformOptions(options));
+}
+function blurhashSync(input, componentsX, componentsY) {
+  return native.blurhashSync(input, componentsX, componentsY);
+}
+function version() {
+  return native.version();
+}
+var index_default = {
+  metadata,
+  metadataSync,
+  resize,
+  resizeSync,
+  toJpeg,
+  toJpegSync,
+  toPng,
+  toPngSync,
+  toWebp,
+  toWebpSync,
+  transform,
+  transformSync,
+  blurhash,
+  blurhashSync,
+  version
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blurhash,
+  blurhashSync,
+  metadata,
+  metadataSync,
+  resize,
+  resizeSync,
+  toJpeg,
+  toJpegSync,
+  toPng,
+  toPngSync,
+  toWebp,
+  toWebpSync,
+  transform,
+  transformSync,
+  version
+});