@cloudwerk/images 0.1.3

package/dist/index.js

@@ -0,0 +1,823 @@
+// src/errors.ts
+var ImageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ImageError";
+  }
+};
+var ImageConfigError = class extends ImageError {
+  field;
+  constructor(message, field) {
+    super(`Image configuration error in '${field}': ${message}`);
+    this.name = "ImageConfigError";
+    this.field = field;
+  }
+};
+var ImageEnvError = class extends ImageError {
+  envVar;
+  constructor(envVar) {
+    super(
+      `Missing required environment variable '${envVar}' for Cloudflare Images`
+    );
+    this.name = "ImageEnvError";
+    this.envVar = envVar;
+  }
+};
+var ImageNotFoundError = class extends ImageError {
+  imageId;
+  constructor(imageId) {
+    super(`Image '${imageId}' not found`);
+    this.name = "ImageNotFoundError";
+    this.imageId = imageId;
+  }
+};
+var ImageUploadError = class extends ImageError {
+  statusCode;
+  details;
+  constructor(message, statusCode, details) {
+    super(message);
+    this.name = "ImageUploadError";
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+var ImageApiError = class extends ImageError {
+  statusCode;
+  errors;
+  constructor(statusCode, errors) {
+    const messages = errors.map((e) => e.message).join(", ");
+    super(`Cloudflare Images API error (${statusCode}): ${messages}`);
+    this.name = "ImageApiError";
+    this.statusCode = statusCode;
+    this.errors = errors;
+  }
+};
+var ImageVariantError = class extends ImageError {
+  variant;
+  availableVariants;
+  constructor(variant, availableVariants) {
+    const available = availableVariants.length > 0 ? `Available variants: ${availableVariants.join(", ")}` : "No variants are configured";
+    super(`Invalid variant '${variant}'. ${available}`);
+    this.name = "ImageVariantError";
+    this.variant = variant;
+    this.availableVariants = availableVariants;
+  }
+};
+var ImageContextError = class extends ImageError {
+  constructor() {
+    super(`Image accessed outside of request handler.
+
+This can happen when:
+1. Accessing images at module-load time (top-level code)
+2. Accessing images in a setTimeout/setInterval callback
+3. The request context was not properly initialized
+
+Images can only be accessed during request handling within a Cloudwerk application.
+
+Example of correct usage:
+  import { images } from '@cloudwerk/core/bindings'
+
+  export async function POST(request: Request) {
+    const formData = await request.formData()
+    const file = formData.get('image') as File
+    const result = await images.avatars.upload(file)
+    return json(result)
+  }
+`);
+    this.name = "ImageContextError";
+  }
+};
+var ImageBindingNotFoundError = class extends ImageError {
+  name;
+  availableImages;
+  constructor(name, availableImages) {
+    const available = availableImages.length > 0 ? `Available images: ${availableImages.join(", ")}` : "No images are configured";
+    super(`Image '${name}' not found in current environment.
+
+${available}
+
+To add this image, create a file at app/images/${name}.ts with:
+  import { defineImage } from '@cloudwerk/images'
+  export default defineImage({
+    variants: {
+      thumbnail: { width: 100, height: 100, fit: 'cover' },
+    },
+  })
+`);
+    this.name = "ImageBindingNotFoundError";
+    this.availableImages = availableImages;
+  }
+};
+
+// src/define-image.ts
+function validateVariant(variant, name) {
+  if (variant.width !== void 0) {
+    if (!Number.isInteger(variant.width) || variant.width < 1) {
+      throw new ImageConfigError(
+        `width must be a positive integer`,
+        `variants.${name}.width`
+      );
+    }
+  }
+  if (variant.height !== void 0) {
+    if (!Number.isInteger(variant.height) || variant.height < 1) {
+      throw new ImageConfigError(
+        `height must be a positive integer`,
+        `variants.${name}.height`
+      );
+    }
+  }
+  if (variant.blur !== void 0) {
+    if (variant.blur < 1 || variant.blur > 250) {
+      throw new ImageConfigError(
+        `blur must be between 1 and 250`,
+        `variants.${name}.blur`
+      );
+    }
+  }
+  if (variant.quality !== void 0) {
+    if (variant.quality < 1 || variant.quality > 100) {
+      throw new ImageConfigError(
+        `quality must be between 1 and 100`,
+        `variants.${name}.quality`
+      );
+    }
+  }
+  if (variant.dpr !== void 0) {
+    if (variant.dpr < 1 || variant.dpr > 3) {
+      throw new ImageConfigError(
+        `dpr must be between 1 and 3`,
+        `variants.${name}.dpr`
+      );
+    }
+  }
+  if (variant.sharpen !== void 0) {
+    if (variant.sharpen < 0 || variant.sharpen > 10) {
+      throw new ImageConfigError(
+        `sharpen must be between 0 and 10`,
+        `variants.${name}.sharpen`
+      );
+    }
+  }
+  if (variant.brightness !== void 0) {
+    if (variant.brightness < -1 || variant.brightness > 1) {
+      throw new ImageConfigError(
+        `brightness must be between -1 and 1`,
+        `variants.${name}.brightness`
+      );
+    }
+  }
+  if (variant.contrast !== void 0) {
+    if (variant.contrast < -1 || variant.contrast > 1) {
+      throw new ImageConfigError(
+        `contrast must be between -1 and 1`,
+        `variants.${name}.contrast`
+      );
+    }
+  }
+  if (variant.rotate !== void 0) {
+    if (variant.rotate < 0 || variant.rotate > 360) {
+      throw new ImageConfigError(
+        `rotate must be between 0 and 360`,
+        `variants.${name}.rotate`
+      );
+    }
+  }
+  const validFits = ["cover", "contain", "scale-down", "crop", "pad"];
+  if (variant.fit !== void 0 && !validFits.includes(variant.fit)) {
+    throw new ImageConfigError(
+      `fit must be one of: ${validFits.join(", ")}`,
+      `variants.${name}.fit`
+    );
+  }
+  const validFormats = ["webp", "avif", "json", "jpeg", "png"];
+  if (variant.format !== void 0 && !validFormats.includes(variant.format)) {
+    throw new ImageConfigError(
+      `format must be one of: ${validFormats.join(", ")}`,
+      `variants.${name}.format`
+    );
+  }
+  const validGravities = ["auto", "center", "top", "bottom", "left", "right", "face"];
+  if (variant.gravity !== void 0 && !validGravities.includes(variant.gravity)) {
+    throw new ImageConfigError(
+      `gravity must be one of: ${validGravities.join(", ")}`,
+      `variants.${name}.gravity`
+    );
+  }
+  const validMetadatas = ["keep", "copyright", "none"];
+  if (variant.metadata !== void 0 && !validMetadatas.includes(variant.metadata)) {
+    throw new ImageConfigError(
+      `metadata must be one of: ${validMetadatas.join(", ")}`,
+      `variants.${name}.metadata`
+    );
+  }
+}
+function validateConfig(config) {
+  if (config.name !== void 0) {
+    if (typeof config.name !== "string" || config.name.length === 0) {
+      throw new ImageConfigError("name must be a non-empty string", "name");
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(config.name)) {
+      throw new ImageConfigError(
+        "name must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens",
+        "name"
+      );
+    }
+  }
+  if (config.deliveryUrl !== void 0) {
+    if (typeof config.deliveryUrl !== "string") {
+      throw new ImageConfigError(
+        "deliveryUrl must be a string",
+        "deliveryUrl"
+      );
+    }
+    try {
+      new URL(config.deliveryUrl);
+    } catch {
+      throw new ImageConfigError(
+        "deliveryUrl must be a valid URL",
+        "deliveryUrl"
+      );
+    }
+  }
+  if (config.variants !== void 0) {
+    if (typeof config.variants !== "object" || config.variants === null) {
+      throw new ImageConfigError("variants must be an object", "variants");
+    }
+    for (const [name, variant] of Object.entries(config.variants)) {
+      if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+        throw new ImageConfigError(
+          `variant name '${name}' must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens`,
+          "variants"
+        );
+      }
+      validateVariant(variant, name);
+    }
+  }
+  if (config.defaultVariant !== void 0 && config.variants !== void 0) {
+    if (!(config.defaultVariant in config.variants)) {
+      throw new ImageConfigError(
+        `defaultVariant '${config.defaultVariant}' is not defined in variants`,
+        "defaultVariant"
+      );
+    }
+  }
+}
+function defineImage(config = {}) {
+  validateConfig(config);
+  const definition = {
+    __brand: "cloudwerk-image",
+    name: config.name ?? "",
+    // Will be set from filename if empty
+    config,
+    variants: config.variants ?? {}
+  };
+  return definition;
+}
+function isImageDefinition(value) {
+  return typeof value === "object" && value !== null && "__brand" in value && value.__brand === "cloudwerk-image";
+}
+
+// src/cloudflare-types.ts
+var CLOUDFLARE_IMAGES_API = {
+  /** Base URL for Cloudflare API v4 */
+  BASE: "https://api.cloudflare.com/client/v4",
+  /**
+   * Get the images endpoint for an account.
+   */
+  images: (accountId) => `https://api.cloudflare.com/client/v4/accounts/${accountId}/images/v1`,
+  /**
+   * Get the direct upload endpoint.
+   */
+  directUpload: (accountId) => `https://api.cloudflare.com/client/v4/accounts/${accountId}/images/v2/direct_upload`,
+  /**
+   * Get a specific image endpoint.
+   */
+  image: (accountId, imageId) => `https://api.cloudflare.com/client/v4/accounts/${accountId}/images/v1/${imageId}`,
+  /**
+   * Get the default delivery URL format.
+   */
+  deliveryUrl: (accountId, imageId, variant) => `https://imagedelivery.net/${accountId}/${imageId}/${variant}`
+};
+
+// src/client.ts
+function parseExpiry(duration) {
+  let seconds;
+  if (typeof duration === "number") {
+    seconds = duration;
+  } else {
+    const match = duration.match(/^(\d+)(s|m|h|d)$/);
+    if (!match) {
+      seconds = 30 * 60;
+    } else {
+      const value = parseInt(match[1], 10);
+      const unit = match[2];
+      switch (unit) {
+        case "s":
+          seconds = value;
+          break;
+        case "m":
+          seconds = value * 60;
+          break;
+        case "h":
+          seconds = value * 3600;
+          break;
+        case "d":
+          seconds = value * 86400;
+          break;
+        default:
+          seconds = 30 * 60;
+      }
+    }
+  }
+  const expiryDate = new Date(Date.now() + seconds * 1e3);
+  return expiryDate.toISOString();
+}
+function toImageResult(image) {
+  return {
+    id: image.id,
+    filename: image.filename || void 0,
+    uploaded: new Date(image.uploaded),
+    variants: image.variants.map((url) => {
+      const parts = url.split("/");
+      return parts[parts.length - 1];
+    }),
+    metadata: image.meta,
+    requireSignedURLs: image.requireSignedURLs
+  };
+}
+var ImageClient = class {
+  accountId;
+  apiToken;
+  deliveryUrl;
+  variants;
+  variantNames;
+  constructor(accountId, apiToken, variants = {}, deliveryUrl) {
+    this.accountId = accountId;
+    this.apiToken = apiToken;
+    this.variants = variants;
+    this.variantNames = Object.keys(variants);
+    this.deliveryUrl = deliveryUrl;
+  }
+  /**
+   * Make an authenticated API request.
+   */
+  async fetch(endpoint, options = {}) {
+    const response = await fetch(endpoint, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${this.apiToken}`,
+        ...options.headers
+      }
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new ImageApiError(response.status, data.errors || []);
+    }
+    return data;
+  }
+  /**
+   * Upload an image file.
+   */
+  async upload(file, options = {}) {
+    const endpoint = CLOUDFLARE_IMAGES_API.images(this.accountId);
+    const formData = new FormData();
+    if (file instanceof ReadableStream) {
+      const response = new Response(file);
+      const blob = await response.blob();
+      formData.append("file", blob);
+    } else {
+      formData.append("file", file);
+    }
+    if (options.id) {
+      formData.append("id", options.id);
+    }
+    if (options.requireSignedURLs !== void 0) {
+      formData.append("requireSignedURLs", String(options.requireSignedURLs));
+    }
+    if (options.metadata) {
+      formData.append("metadata", JSON.stringify(options.metadata));
+    }
+    try {
+      const response = await this.fetch(endpoint, {
+        method: "POST",
+        body: formData
+      });
+      return toImageResult(response.result);
+    } catch (error) {
+      if (error instanceof ImageApiError) {
+        throw new ImageUploadError(
+          `Failed to upload image: ${error.message}`,
+          error.statusCode,
+          error.errors.map((e) => e.message).join(", ")
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Generate a direct upload URL for client-side uploads.
+   */
+  async getDirectUploadUrl(options = {}) {
+    const endpoint = CLOUDFLARE_IMAGES_API.directUpload(this.accountId);
+    const body = {};
+    if (options.requireSignedURLs !== void 0) {
+      body.requireSignedURLs = options.requireSignedURLs;
+    }
+    if (options.metadata) {
+      body.metadata = options.metadata;
+    }
+    if (options.expiry) {
+      body.expiry = parseExpiry(options.expiry);
+    }
+    const response = await this.fetch(
+      endpoint,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    return {
+      uploadUrl: response.result.uploadURL,
+      id: response.result.id
+    };
+  }
+  /**
+   * Delete an image.
+   */
+  async delete(imageId) {
+    const endpoint = CLOUDFLARE_IMAGES_API.image(this.accountId, imageId);
+    try {
+      await this.fetch(endpoint, {
+        method: "DELETE"
+      });
+    } catch (error) {
+      if (error instanceof ImageApiError && error.statusCode === 404) {
+        throw new ImageNotFoundError(imageId);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get image details.
+   */
+  async get(imageId) {
+    const endpoint = CLOUDFLARE_IMAGES_API.image(this.accountId, imageId);
+    try {
+      const response = await this.fetch(endpoint);
+      return toImageResult(response.result);
+    } catch (error) {
+      if (error instanceof ImageApiError && error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List images with pagination.
+   */
+  async list(options = {}) {
+    const endpoint = CLOUDFLARE_IMAGES_API.images(this.accountId);
+    const params = new URLSearchParams();
+    if (options.page !== void 0) {
+      params.set("page", String(options.page));
+    }
+    if (options.perPage !== void 0) {
+      params.set("per_page", String(Math.min(100, Math.max(1, options.perPage))));
+    }
+    const urlWithParams = params.toString() ? `${endpoint}?${params}` : endpoint;
+    const response = await this.fetch(urlWithParams);
+    return response.result.images.map(toImageResult);
+  }
+  /**
+   * Generate URL for an image with optional variant.
+   */
+  url(imageId, variant) {
+    if (variant !== void 0 && !this.variantNames.includes(variant)) {
+      throw new ImageVariantError(variant, this.variantNames);
+    }
+    if (this.deliveryUrl) {
+      const variantPath = variant ? `/${variant}` : "";
+      return `${this.deliveryUrl}/${imageId}${variantPath}`;
+    }
+    const variantName = variant ?? "public";
+    return CLOUDFLARE_IMAGES_API.deliveryUrl(
+      this.accountId,
+      imageId,
+      variantName
+    );
+  }
+};
+function createImageClient(accountId, apiToken, variants = {}, deliveryUrl) {
+  return new ImageClient(accountId, apiToken, variants, deliveryUrl);
+}
+
+// src/transformer.ts
+var ImageTransformError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "ImageTransformError";
+    this.status = status;
+    this.code = code;
+  }
+};
+function parseTransformParams(searchParams, config) {
+  const options = {};
+  const presetName = searchParams.get("preset");
+  if (presetName && config.presets?.[presetName]) {
+    Object.assign(options, config.presets[presetName]);
+  }
+  if (config.defaults) {
+    Object.assign(options, config.defaults, options);
+  }
+  if (config.allowArbitrary !== false) {
+    const width = searchParams.get("w") || searchParams.get("width");
+    if (width) {
+      const w = parseInt(width, 10);
+      if (!isNaN(w) && w > 0) {
+        options.width = Math.min(w, config.maxWidth ?? 4096);
+      }
+    }
+    const height = searchParams.get("h") || searchParams.get("height");
+    if (height) {
+      const h = parseInt(height, 10);
+      if (!isNaN(h) && h > 0) {
+        options.height = Math.min(h, config.maxHeight ?? 4096);
+      }
+    }
+    const fit = searchParams.get("fit");
+    if (fit && ["cover", "contain", "scale-down", "crop", "pad"].includes(fit)) {
+      options.fit = fit;
+    }
+    const format = searchParams.get("format") || searchParams.get("f");
+    if (format && ["webp", "avif", "jpeg", "png", "auto"].includes(format)) {
+      options.format = format;
+    }
+    const quality = searchParams.get("q") || searchParams.get("quality");
+    if (quality) {
+      const q = parseInt(quality, 10);
+      if (!isNaN(q) && q >= 1 && q <= 100) {
+        options.quality = q;
+      }
+    }
+    const dpr = searchParams.get("dpr");
+    if (dpr) {
+      const d = parseFloat(dpr);
+      if (!isNaN(d) && d >= 1 && d <= 3) {
+        options.dpr = d;
+      }
+    }
+    const gravity = searchParams.get("gravity");
+    if (gravity && ["auto", "center", "top", "bottom", "left", "right", "face"].includes(gravity)) {
+      options.gravity = gravity;
+    }
+    const blur = searchParams.get("blur");
+    if (blur) {
+      const b = parseInt(blur, 10);
+      if (!isNaN(b) && b >= 1 && b <= 250) {
+        options.blur = b;
+      }
+    }
+    const sharpen = searchParams.get("sharpen");
+    if (sharpen) {
+      const s = parseFloat(sharpen);
+      if (!isNaN(s) && s >= 0 && s <= 10) {
+        options.sharpen = s;
+      }
+    }
+    const brightness = searchParams.get("brightness");
+    if (brightness) {
+      const br = parseFloat(brightness);
+      if (!isNaN(br) && br >= -1 && br <= 1) {
+        options.brightness = br;
+      }
+    }
+    const contrast = searchParams.get("contrast");
+    if (contrast) {
+      const c = parseFloat(contrast);
+      if (!isNaN(c) && c >= -1 && c <= 1) {
+        options.contrast = c;
+      }
+    }
+    const rotate = searchParams.get("rotate");
+    if (rotate) {
+      const r = parseInt(rotate, 10);
+      if ([0, 90, 180, 270].includes(r)) {
+        options.rotate = r;
+      }
+    }
+  }
+  return options;
+}
+function presetToCfOptions(preset) {
+  const options = {};
+  if (preset.width !== void 0) options.width = preset.width;
+  if (preset.height !== void 0) options.height = preset.height;
+  if (preset.fit !== void 0) options.fit = preset.fit;
+  if (preset.format !== void 0) options.format = preset.format;
+  if (preset.quality !== void 0) options.quality = preset.quality;
+  if (preset.dpr !== void 0) options.dpr = preset.dpr;
+  if (preset.gravity !== void 0) options.gravity = preset.gravity;
+  if (preset.sharpen !== void 0) options.sharpen = preset.sharpen;
+  if (preset.blur !== void 0) options.blur = preset.blur;
+  if (preset.brightness !== void 0) options.brightness = preset.brightness;
+  if (preset.contrast !== void 0) options.contrast = preset.contrast;
+  if (preset.rotate !== void 0) options.rotate = preset.rotate;
+  if (preset.metadata !== void 0) options.metadata = preset.metadata;
+  if (preset.background !== void 0) options.background = preset.background;
+  return options;
+}
+function validateOrigin(sourceUrl, allowedOrigins) {
+  if (!allowedOrigins || allowedOrigins.length === 0) {
+    return true;
+  }
+  const sourceOrigin = sourceUrl.origin;
+  return allowedOrigins.some((origin) => {
+    if (origin === sourceOrigin) return true;
+    if (origin.includes("*")) {
+      const pattern = origin.replace(/\*/g, "[^.]+");
+      const regex = new RegExp(`^${pattern}$`);
+      return regex.test(sourceOrigin);
+    }
+    return false;
+  });
+}
+function createImageTransformer(config = {}) {
+  const {
+    allowedOrigins,
+    presets = {},
+    defaults = {},
+    maxWidth = 4096,
+    maxHeight = 4096,
+    cacheControl = "public, max-age=31536000",
+    allowArbitrary = true,
+    validateSource
+  } = config;
+  return async (request, context) => {
+    const pathParam = context.params.path;
+    if (!pathParam) {
+      return new Response(JSON.stringify({ error: "Missing image path" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const sourcePath = Array.isArray(pathParam) ? pathParam.join("/") : pathParam;
+    let sourceUrl;
+    try {
+      sourceUrl = new URL(sourcePath);
+    } catch {
+      return new Response(JSON.stringify({ error: "Invalid image URL" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (!validateOrigin(sourceUrl, allowedOrigins)) {
+      return new Response(JSON.stringify({ error: "Origin not allowed" }), {
+        status: 403,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (validateSource) {
+      const isValid = await validateSource(sourceUrl);
+      if (!isValid) {
+        return new Response(JSON.stringify({ error: "Source URL rejected" }), {
+          status: 403,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    const requestUrl = new URL(request.url);
+    const transformOptions = parseTransformParams(requestUrl.searchParams, {
+      presets,
+      defaults,
+      maxWidth,
+      maxHeight,
+      allowArbitrary
+    });
+    const cfOptions = presetToCfOptions(transformOptions);
+    const hasTransforms = Object.keys(cfOptions).length > 0;
+    try {
+      const imageRequest = new Request(sourceUrl.toString(), {
+        headers: request.headers
+      });
+      const fetchOptions = {};
+      if (hasTransforms) {
+        fetchOptions.cf = { image: cfOptions };
+      }
+      const response = await fetch(imageRequest, fetchOptions);
+      if (!response.ok) {
+        return new Response(JSON.stringify({ error: "Failed to fetch source image" }), {
+          status: response.status,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const headers = new Headers(response.headers);
+      headers.set("Cache-Control", cacheControl);
+      headers.set("Vary", "Accept");
+      return new Response(response.body, {
+        status: 200,
+        headers
+      });
+    } catch (error) {
+      console.error("Image transform error:", error);
+      return new Response(JSON.stringify({ error: "Image transformation failed" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+}
+function variantToPreset(variant) {
+  const preset = {};
+  if (variant.width !== void 0) preset.width = variant.width;
+  if (variant.height !== void 0) preset.height = variant.height;
+  if (variant.fit !== void 0) preset.fit = variant.fit;
+  if (variant.format !== void 0) preset.format = variant.format;
+  if (variant.quality !== void 0) preset.quality = variant.quality;
+  if (variant.dpr !== void 0) preset.dpr = variant.dpr;
+  if (variant.gravity !== void 0) {
+    preset.gravity = variant.gravity;
+  }
+  if (variant.sharpen !== void 0) preset.sharpen = variant.sharpen;
+  if (variant.blur !== void 0) preset.blur = variant.blur;
+  if (variant.brightness !== void 0) preset.brightness = variant.brightness;
+  if (variant.contrast !== void 0) preset.contrast = variant.contrast;
+  if (variant.rotate !== void 0) {
+    if ([0, 90, 180, 270].includes(variant.rotate)) {
+      preset.rotate = variant.rotate;
+    }
+  }
+  if (variant.metadata !== void 0) preset.metadata = variant.metadata;
+  return preset;
+}
+
+// src/binding-types.ts
+var IMAGE_PRESETS = {
+  /** Small thumbnail (100x100 cover) */
+  thumbnail: {
+    width: 100,
+    height: 100,
+    fit: "cover",
+    quality: 80
+  },
+  /** Medium preview (400x400 contain) */
+  preview: {
+    width: 400,
+    height: 400,
+    fit: "contain",
+    quality: 85
+  },
+  /** Large display (1200px wide) */
+  large: {
+    width: 1200,
+    fit: "scale-down",
+    quality: 90
+  },
+  /** Hero banner (1920x1080 cover) */
+  hero: {
+    width: 1920,
+    height: 1080,
+    fit: "cover",
+    quality: 85
+  },
+  /** Social share (1200x630 for Open Graph) */
+  social: {
+    width: 1200,
+    height: 630,
+    fit: "cover",
+    quality: 85
+  },
+  /** Mobile optimized (640px wide, WebP) */
+  mobile: {
+    width: 640,
+    fit: "scale-down",
+    quality: 75,
+    format: "image/webp"
+  }
+};
+export {
+  CLOUDFLARE_IMAGES_API,
+  IMAGE_PRESETS,
+  ImageApiError,
+  ImageBindingNotFoundError,
+  ImageClient,
+  ImageConfigError,
+  ImageContextError,
+  ImageEnvError,
+  ImageError,
+  ImageNotFoundError,
+  ImageTransformError,
+  ImageUploadError,
+  ImageVariantError,
+  createImageClient,
+  createImageTransformer,
+  defineImage,
+  isImageDefinition,
+  variantToPreset
+};
+//# sourceMappingURL=index.js.map