pixel-data-js 0.3.0 → 0.4.0

package/dist/index.prod.d.ts

@@ -243,6 +243,29 @@ declare function deserializeRawImageData<T extends SerializedImageData>(serializ
 declare function deserializeImageData<T extends SerializedImageData>(serialized: T): ImageData;
 declare function deserializeNullableImageData<T extends SerializedImageData | null>(serialized: T): T extends null ? null : ImageData;
 
+declare function writeImageData(imageData: ImageData, data: Uint8ClampedArray, rect: Rect): void;
+declare function writeImageData(imageData: ImageData, data: Uint8ClampedArray, x: number, y: number, w: number, h: number): void;
+
+/**
+ * Creates a new copy of a mask.
+ * Uses the underlying buffer's slice method for high-performance memory copying.
+ */
+declare function copyMask<T extends AnyMask>(src: T): T;
+
+/**
+ * Inverts a BinaryMask in-place.
+ */
+declare function invertBinaryMask(dst: BinaryMask): void;
+/**
+ * Inverts an AlphaMask in-place.
+ */
+declare function invertAlphaMask(dst: AlphaMask): void;
+
+/**
+ * Merges a source mask into a destination AlphaMask.
+ */
+declare function mergeMasks(dst: AlphaMask, dstWidth: number, src: AnyMask, opts: ApplyMaskOptions): void;
+
 declare class PixelData {
     readonly imageData: ImageDataLike;
     readonly data32: Uint32Array;
@@ -251,6 +274,18 @@ declare class PixelData {
     constructor(imageData: ImageDataLike);
 }
 
+/**
+ * Directly applies a mask to a region of PixelData,
+ * modifying the destination's alpha channel in-place.
+ */
+declare function applyMaskToPixelData(dst: PixelData, mask: AnyMask, opts: ApplyMaskOptions): void;
+
+/**
+ * Fills a rectangle in the destination PixelData with a single color,
+ * supporting blend modes, global alpha, and masking.
+ */
+declare function blendColorPixelData(dst: PixelData, color: Color32, opts: ColorBlendOptions): void;
+
 /**
  * Blits source PixelData into a destination PixelData using 32-bit integer bitwise blending.
  * This function bypasses standard ImageData limitations by operating directly on
@@ -267,4 +302,15 @@ declare class PixelData {
  */
 declare function blendPixelData(dst: PixelData, src: PixelData, opts: PixelBlendOptions): void;
 
-export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, COLOR_32_BLEND_MODES, type Color32, type ColorBlendOptions, type ImageDataLike, MaskType, type PixelBlendOptions, type PixelOptions, type RGBA, type Rect, type SerializedImageData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendPixelData, color32ToCssRGBA, color32ToHex, colorBurnColor32, colorDistance, copyImageData, copyImageDataLike, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceColor32, extractImageData, hardLightColor32, lerpColor32, lerpColor32Fast, linearDodgeColor32, multiplyColor32, overlayColor32, packColor, packRGBA, screenColor32, serializeImageData, serializeNullableImageData, sourceOverColor32, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed };
+/**
+ * Clears a region of the PixelData to transparent (0x00000000).
+ * Internally uses the optimized fillPixelData.
+ */
+declare function clearPixelData(dst: PixelData, rect?: Partial<Rect>): void;
+
+/**
+ * A high-performance solid fill for PixelData.
+ */
+declare function fillPixelData(dst: PixelData, color: Color32, rect?: Partial<Rect>): void;
+
+export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, COLOR_32_BLEND_MODES, type Color32, type ColorBlendOptions, type ImageDataLike, MaskType, type PixelBlendOptions, type PixelOptions, type RGBA, type Rect, type SerializedImageData, applyMaskToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnColor32, colorDistance, copyImageData, copyImageDataLike, copyMask, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceColor32, extractImageData, fillPixelData, hardLightColor32, invertAlphaMask, invertBinaryMask, lerpColor32, lerpColor32Fast, linearDodgeColor32, mergeMasks, multiplyColor32, overlayColor32, packColor, packRGBA, screenColor32, serializeImageData, serializeNullableImageData, sourceOverColor32, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, writeImageData };

package/dist/index.prod.js

@@ -279,6 +279,306 @@ function deserializeNullableImageData(serialized) {
   return deserializeImageData(serialized);
 }
 
+// src/ImageData/writeImageData.ts
+function writeImageData(imageData, data, _x, _y, _w, _h) {
+  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
+  const { width: dstW, height: dstH, data: dst } = imageData;
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(dstW, x + w);
+  const y1 = Math.min(dstH, y + h);
+  if (x1 <= x0 || y1 <= y0) return;
+  const rowLen = (x1 - x0) * 4;
+  const srcCol = x0 - x;
+  const srcYOffset = y0 - y;
+  const actualH = y1 - y0;
+  for (let row = 0; row < actualH; row++) {
+    const dstStart = ((y0 + row) * dstW + x0) * 4;
+    const srcRow = srcYOffset + row;
+    const o = (srcRow * w + srcCol) * 4;
+    dst.set(data.subarray(o, o + rowLen), dstStart);
+  }
+}
+
+// src/Mask/copyMask.ts
+function copyMask(src) {
+  return src.slice();
+}
+
+// src/Mask/invertMask.ts
+function invertBinaryMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = dst[i] === 0 ? 1 : 0;
+  }
+}
+function invertAlphaMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = 255 - dst[i];
+  }
+}
+
+// src/Mask/mergeMasks.ts
+function mergeMasks(dst, dstWidth, src, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = 0,
+    h: height = 0,
+    alpha: globalAlpha = 255,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (width <= 0 || height <= 0 || globalAlpha === 0) {
+    return;
+  }
+  const sPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  for (let iy = 0; iy < height; iy++) {
+    const dy = targetY + iy;
+    const sy = my + iy;
+    if (dy < 0 || sy < 0) {
+      continue;
+    }
+    for (let ix = 0; ix < width; ix++) {
+      const dx = targetX + ix;
+      const sx = mx + ix;
+      if (dx < 0 || dx >= dstWidth || sx < 0 || sx >= sPitch) {
+        continue;
+      }
+      const dIdx = dy * dstWidth + dx;
+      const sIdx = sy * sPitch + sx;
+      const mVal = src[sIdx];
+      let weight = globalAlpha;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst[dIdx] = 0;
+          continue;
+        }
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst[dIdx] = 0;
+          continue;
+        }
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst[dIdx] = 0;
+        continue;
+      }
+      const da = dst[dIdx];
+      if (da === 0) {
+      } else if (weight === 255) {
+      } else if (da === 255) {
+        dst[dIdx] = weight;
+      } else {
+        dst[dIdx] = da * weight + 128 >> 8;
+      }
+    }
+  }
+}
+
+// src/PixelData/applyMaskToPixelData.ts
+function applyMaskToPixelData(dst, mask, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0 || globalAlpha === 0) {
+    return;
+  }
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const mVal = mask[mIdx];
+      let weight = globalAlpha;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      } else {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        let finalAlpha = da;
+        if (da === 0) {
+        } else if (weight === 255) {
+        } else if (da === 255) {
+          finalAlpha = weight;
+        } else {
+          finalAlpha = da * weight + 128 >> 8;
+        }
+        dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+      }
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
+// src/PixelData/blendColorPixelData.ts
+function blendColorPixelData(dst, color, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    blendFn = sourceOverColor32,
+    mask,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlphaMask = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  const baseSrcColor = color;
+  const baseSrcAlpha = baseSrcColor >>> 24;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      if (baseSrcAlpha === 0) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
+      let weight = globalAlpha;
+      if (mask) {
+        const mVal = mask[mIdx];
+        if (isAlphaMask) {
+          const effectiveM = invertMask ? 255 - mVal : mVal;
+          if (effectiveM === 0) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          if (globalAlpha === 255) {
+            weight = effectiveM;
+          } else if (effectiveM === 255) {
+            weight = globalAlpha;
+          } else {
+            weight = effectiveM * globalAlpha + 128 >> 8;
+          }
+        } else {
+          const isHit = invertMask ? mVal === 0 : mVal === 1;
+          if (!isHit) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          weight = globalAlpha;
+        }
+        if (weight === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+      }
+      let currentSrcAlpha = baseSrcAlpha;
+      let currentSrcColor = baseSrcColor;
+      if (weight < 255) {
+        if (baseSrcAlpha === 255) {
+          currentSrcAlpha = weight;
+        } else {
+          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
+        }
+        if (currentSrcAlpha === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
+      }
+      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
 // src/PixelData/blendPixelData.ts
 function blendPixelData(dst, src, opts) {
   const {
@@ -414,27 +714,78 @@ function blendPixelData(dst, src, opts) {
     mIdx += mStride;
   }
 }
+
+// src/PixelData/fillPixelData.ts
+function fillPixelData(dst, color, rect) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height
+  } = rect || {};
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) {
+    return;
+  }
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  if (actualW === dw && actualH === dst.height && x === 0 && y === 0) {
+    dst32.fill(color);
+    return;
+  }
+  for (let iy = 0; iy < actualH; iy++) {
+    const start = (y + iy) * dw + x;
+    const end = start + actualW;
+    dst32.fill(color, start, end);
+  }
+}
+
+// src/PixelData/clearPixelData.ts
+function clearPixelData(dst, rect) {
+  fillPixelData(dst, 0, rect);
+}
 export {
   COLOR_32_BLEND_MODES,
   MaskType,
+  applyMaskToPixelData,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
+  blendColorPixelData,
   blendPixelData,
+  clearPixelData,
   color32ToCssRGBA,
   color32ToHex,
   colorBurnColor32,
   colorDistance,
   copyImageData,
   copyImageDataLike,
+  copyMask,
   deserializeImageData,
   deserializeNullableImageData,
   deserializeRawImageData,
   differenceColor32,
   extractImageData,
+  fillPixelData,
   hardLightColor32,
+  invertAlphaMask,
+  invertBinaryMask,
   lerpColor32,
   lerpColor32Fast,
   linearDodgeColor32,
+  mergeMasks,
   multiplyColor32,
   overlayColor32,
   packColor,
@@ -448,6 +799,7 @@ export {
   unpackColor,
   unpackColorTo,
   unpackGreen,
-  unpackRed
+  unpackRed,
+  writeImageData
 };
 //# sourceMappingURL=index.prod.js.map