pixel-data-js 0.17.1 → 0.18.0

package/dist/index.dev.cjs

@@ -72,6 +72,7 @@ __export(src_exports, {
   fileToImageData: () => fileToImageData,
   fillPixelData: () => fillPixelData,
   floodFillSelection: () => floodFillSelection,
+  getCircleBrushBounds: () => getCircleBrushBounds,
   getImageDataFromClipboard: () => getImageDataFromClipboard,
   getIndexedImageColorCounts: () => getIndexedImageColorCounts,
   getRectBrushBounds: () => getRectBrushBounds,
@@ -1925,6 +1926,148 @@ var PixelEngineConfig = class {
   }
 };
 
+// src/PixelData/applyCircleBrushToPixelData.ts
+function applyCircleBrushToPixelData(target, color, centerX, centerY, brushSize, alpha = 255, fallOff, blendFn = sourceOverPerfect, bounds) {
+  const targetWidth = target.width;
+  const targetHeight = target.height;
+  const b = bounds ?? getCircleBrushBounds(
+    centerX,
+    centerY,
+    brushSize,
+    targetWidth,
+    targetHeight
+  );
+  if (b.w <= 0 || b.h <= 0) return;
+  const data32 = target.data32;
+  const r = brushSize / 2;
+  const rSqr = r * r;
+  const invR = 1 / r;
+  const centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
+  const baseColor = color & 16777215;
+  const constantSrc = (alpha << 24 | baseColor) >>> 0;
+  const endX = b.x + b.w;
+  const endY = b.y + b.h;
+  const fCenterX = Math.floor(centerX);
+  const fCenterY = Math.floor(centerY);
+  for (let cy = b.y; cy < endY; cy++) {
+    const relY = cy - fCenterY + centerOffset;
+    const dySqr = relY * relY;
+    const rowOffset = cy * targetWidth;
+    for (let cx = b.x; cx < endX; cx++) {
+      const relX = cx - fCenterX + centerOffset;
+      const dSqr = relX * relX + dySqr;
+      if (dSqr <= rSqr) {
+        const idx = rowOffset + cx;
+        if (fallOff) {
+          const strength = fallOff(Math.sqrt(dSqr) * invR);
+          const fAlpha = alpha * strength & 255;
+          const src = (fAlpha << 24 | baseColor) >>> 0;
+          data32[idx] = blendFn(src, data32[idx]);
+        } else {
+          data32[idx] = blendFn(constantSrc, data32[idx]);
+        }
+      }
+    }
+  }
+}
+function getCircleBrushBounds(centerX, centerY, brushSize, targetWidth, targetHeight, out) {
+  const r = brushSize / 2;
+  const minOffset = -Math.ceil(r - 0.5);
+  const maxOffset = Math.floor(r - 0.5);
+  const startX = Math.floor(centerX + minOffset);
+  const startY = Math.floor(centerY + minOffset);
+  const endX = Math.floor(centerX + maxOffset) + 1;
+  const endY = Math.floor(centerY + maxOffset) + 1;
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  const cStartX = targetWidth !== void 0 ? Math.max(0, startX) : startX;
+  const cStartY = targetHeight !== void 0 ? Math.max(0, startY) : startY;
+  const cEndX = targetWidth !== void 0 ? Math.min(targetWidth, endX) : endX;
+  const cEndY = targetHeight !== void 0 ? Math.min(targetHeight, endY) : endY;
+  res.x = cStartX;
+  res.y = cStartY;
+  res.w = Math.max(0, cEndX - cStartX);
+  res.h = Math.max(0, cEndY - cStartY);
+  return res;
+}
+
+// src/History/PixelWriter.ts
+var PixelWriter = class {
+  target;
+  historyManager;
+  accumulator;
+  config;
+  mutator;
+  constructor(target, mutatorFactory, {
+    tileSize = 256,
+    maxHistorySteps = 50,
+    historyManager = new HistoryManager(maxHistorySteps)
+  } = {}) {
+    this.target = target;
+    this.config = new PixelEngineConfig(tileSize);
+    this.historyManager = historyManager;
+    this.accumulator = new PixelAccumulator(target, this.config);
+    this.mutator = mutatorFactory(this);
+  }
+  withHistory(cb) {
+    cb(this.mutator);
+    this.captureHistory();
+  }
+  captureHistory() {
+    const beforeTiles = this.accumulator.beforeTiles;
+    if (beforeTiles.length === 0) return;
+    const afterTiles = this.accumulator.extractAfterTiles();
+    const patch = {
+      beforeTiles,
+      afterTiles
+    };
+    const target = this.target;
+    const tileSize = this.config.tileSize;
+    const accumulator = this.accumulator;
+    const action = {
+      undo: () => applyPatchTiles(target, patch.beforeTiles, tileSize),
+      redo: () => applyPatchTiles(target, patch.afterTiles, tileSize),
+      dispose: () => accumulator.recyclePatch(patch)
+    };
+    this.historyManager.commit(action);
+    this.accumulator.reset();
+  }
+};
+
+// src/History/PixelMutator/mutatorApplyCircleBrush.ts
+var boundsOut = { x: 0, y: 0, w: 0, h: 0 };
+function mutatorApplyCircleBrush(writer) {
+  return {
+    applyCircleBrush(color, centerX, centerY, brushSize, alpha = 255, fallOff, blendFn) {
+      const circleBounds = getCircleBrushBounds(
+        centerX,
+        centerY,
+        brushSize,
+        writer.target.width,
+        writer.target.height,
+        boundsOut
+      );
+      const { x, y, w, h } = circleBounds;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      applyCircleBrushToPixelData(
+        writer.target,
+        color,
+        centerX,
+        centerY,
+        brushSize,
+        alpha,
+        fallOff,
+        blendFn,
+        circleBounds
+      );
+    }
+  };
+}
+
 // src/PixelData/applyMaskToPixelData.ts
 function applyMaskToPixelData(dst, mask, opts = {}) {
   const {
@@ -2012,46 +2155,6 @@ function applyMaskToPixelData(dst, mask, opts = {}) {
   }
 }
 
-// src/History/PixelWriter.ts
-var PixelWriter = class {
-  target;
-  historyManager;
-  accumulator;
-  config;
-  mutator;
-  constructor(target, mutatorFactory, {
-    tileSize = 256,
-    maxHistorySteps = 50,
-    historyManager = new HistoryManager(maxHistorySteps)
-  } = {}) {
-    this.target = target;
-    this.config = new PixelEngineConfig(tileSize);
-    this.historyManager = historyManager;
-    this.accumulator = new PixelAccumulator(target, this.config);
-    this.mutator = mutatorFactory(this);
-  }
-  withHistory(cb) {
-    cb(this.mutator);
-    const beforeTiles = this.accumulator.beforeTiles;
-    if (beforeTiles.length === 0) return;
-    const afterTiles = this.accumulator.extractAfterTiles();
-    const patch = {
-      beforeTiles,
-      afterTiles
-    };
-    const target = this.target;
-    const tileSize = this.config.tileSize;
-    const accumulator = this.accumulator;
-    const action = {
-      undo: () => applyPatchTiles(target, patch.beforeTiles, tileSize),
-      redo: () => applyPatchTiles(target, patch.afterTiles, tileSize),
-      dispose: () => accumulator.recyclePatch(patch)
-    };
-    this.historyManager.commit(action);
-    this.accumulator.reset();
-  }
-};
-
 // src/History/PixelMutator/mutatorApplyMask.ts
 function mutatorApplyMask(writer) {
   return {
@@ -2069,6 +2172,143 @@ function mutatorApplyMask(writer) {
   };
 }
 
+// src/ImageData/imageDataToUInt32Array.ts
+function imageDataToUInt32Array(imageData) {
+  return new Uint32Array(
+    imageData.data.buffer,
+    imageData.data.byteOffset,
+    // Shift right by 2 is a fast bitwise division by 4.
+    imageData.data.byteLength >> 2
+  );
+}
+
+// src/PixelData/PixelData.ts
+var PixelData = class _PixelData {
+  data32;
+  imageData;
+  get width() {
+    return this.imageData.width;
+  }
+  get height() {
+    return this.imageData.height;
+  }
+  constructor(imageData) {
+    this.data32 = imageDataToUInt32Array(imageData);
+    this.imageData = imageData;
+  }
+  set(imageData) {
+    this.imageData = imageData;
+    this.data32 = imageDataToUInt32Array(imageData);
+  }
+  /**
+   * Creates a deep copy of the PixelData using the environment's ImageData constructor.
+   */
+  copy() {
+    const buffer = new Uint8ClampedArray(this.imageData.data);
+    const ImageConstructor = typeof ImageData !== "undefined" ? ImageData : this.imageData.constructor;
+    const newImageData = new ImageConstructor(
+      buffer,
+      this.width,
+      this.height
+    );
+    return new _PixelData(newImageData);
+  }
+};
+
+// src/PixelData/applyRectBrushToPixelData.ts
+function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn = sourceOverPerfect, bounds) {
+  const targetWidth = target.width;
+  const targetHeight = target.height;
+  const b = bounds ?? getRectBrushBounds(
+    centerX,
+    centerY,
+    brushWidth,
+    brushHeight,
+    targetWidth,
+    targetHeight
+  );
+  if (b.w <= 0 || b.h <= 0) return;
+  const data32 = target.data32;
+  const baseColor = color & 16777215;
+  const constantSrc = (alpha << 24 | baseColor) >>> 0;
+  const invHalfW = 1 / (brushWidth / 2);
+  const invHalfH = 1 / (brushHeight / 2);
+  const endX = b.x + b.w;
+  const endY = b.y + b.h;
+  for (let py = b.y; py < endY; py++) {
+    const rowOffset = py * targetWidth;
+    const dy = fallOff ? Math.abs(py + 0.5 - centerY) * invHalfH : 0;
+    for (let px = b.x; px < endX; px++) {
+      const idx = rowOffset + px;
+      if (fallOff) {
+        const dx = Math.abs(px + 0.5 - centerX) * invHalfW;
+        const dist = dx > dy ? dx : dy;
+        const strength = fallOff(dist);
+        const fAlpha = alpha * strength | 0;
+        const src = (fAlpha << 24 | baseColor) >>> 0;
+        data32[idx] = blendFn(src, data32[idx]);
+      } else {
+        data32[idx] = blendFn(constantSrc, data32[idx]);
+      }
+    }
+  }
+}
+function getRectBrushBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight, out) {
+  const startX = Math.floor(centerX - brushWidth / 2);
+  const startY = Math.floor(centerY - brushHeight / 2);
+  const endX = startX + brushWidth;
+  const endY = startY + brushHeight;
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+  const cStartX = targetWidth !== void 0 ? Math.max(0, startX) : startX;
+  const cStartY = targetHeight !== void 0 ? Math.max(0, startY) : startY;
+  const cEndX = targetWidth !== void 0 ? Math.min(targetWidth, endX) : endX;
+  const cEndY = targetHeight !== void 0 ? Math.min(targetHeight, endY) : endY;
+  const w = cEndX - cStartX;
+  const h = cEndY - cStartY;
+  res.x = cStartX;
+  res.y = cStartY;
+  res.w = w < 0 ? 0 : w;
+  res.h = h < 0 ? 0 : h;
+  return res;
+}
+
+// src/History/PixelMutator/mutatorApplyRectBrush.ts
+var boundsOut2 = { x: 0, y: 0, w: 0, h: 0 };
+function mutatorApplyRectBrush(writer) {
+  return {
+    applyRectBrush(color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn) {
+      const bounds = getRectBrushBounds(
+        centerX,
+        centerY,
+        brushWidth,
+        brushHeight,
+        writer.target.width,
+        writer.target.height,
+        boundsOut2
+      );
+      const { x, y, w, h } = bounds;
+      writer.accumulator.storeRegionBeforeState(x, y, w, h);
+      applyRectBrushToPixelData(
+        writer.target,
+        color,
+        centerX,
+        centerY,
+        brushWidth,
+        brushHeight,
+        alpha,
+        fallOff,
+        blendFn,
+        bounds
+      );
+    }
+  };
+}
+
 // src/PixelData/blendColorPixelData.ts
 function blendColorPixelData(dst, color, opts = {}) {
   const {
@@ -2514,21 +2754,21 @@ function makeFullPixelMutator(writer) {
     ...mutatorBlendColor(writer),
     ...mutatorBlendPixel(writer),
     ...mutatorFill(writer),
-    ...mutatorInvert(writer)
+    ...mutatorInvert(writer),
+    ...mutatorApplyCircleBrush(writer),
+    ...mutatorApplyRectBrush(writer)
   };
 }
 
 // src/ImageData/ReusableImageData.ts
 function makeReusableImageData() {
   let imageData = null;
-  let buffer = null;
   return function getReusableImageData(width, height) {
     const hasInstance = !!imageData;
     const widthMatches = hasInstance && imageData.width === width;
     const heightMatches = hasInstance && imageData.height === height;
     if (!widthMatches || !heightMatches) {
-      const buffer2 = new Uint8ClampedArray(width * height * 4);
-      imageData = new ImageData(buffer2, width, height);
+      imageData = new ImageData(width, height);
     }
     return imageData;
   };
@@ -2592,16 +2832,6 @@ function imageDataToDataUrl(imageData) {
 }
 imageDataToDataUrl.reset = get.reset;
 
-// src/ImageData/imageDataToUInt32Array.ts
-function imageDataToUInt32Array(imageData) {
-  return new Uint32Array(
-    imageData.data.buffer,
-    imageData.data.byteOffset,
-    // Shift right by 2 is a fast bitwise division by 4.
-    imageData.data.byteLength >> 2
-  );
-}
-
 // src/ImageData/invertImageData.ts
 function invertImageData(imageData) {
   const data = imageData.data;
@@ -3135,123 +3365,6 @@ function mergeMasks(dst, dstWidth, src, opts) {
   }
 }
 
-// src/PixelData/PixelData.ts
-var PixelData = class _PixelData {
-  data32;
-  imageData;
-  get width() {
-    return this.imageData.width;
-  }
-  get height() {
-    return this.imageData.height;
-  }
-  constructor(imageData) {
-    this.data32 = imageDataToUInt32Array(imageData);
-    this.imageData = imageData;
-  }
-  set(imageData) {
-    this.imageData = imageData;
-    this.data32 = imageDataToUInt32Array(imageData);
-  }
-  /**
-   * Creates a deep copy of the PixelData using the environment's ImageData constructor.
-   */
-  copy() {
-    const buffer = new Uint8ClampedArray(this.imageData.data);
-    const ImageConstructor = typeof ImageData !== "undefined" ? ImageData : this.imageData.constructor;
-    const newImageData = new ImageConstructor(
-      buffer,
-      this.width,
-      this.height
-    );
-    return new _PixelData(newImageData);
-  }
-};
-
-// src/PixelData/applyCircleBrushToPixelData.ts
-function applyCircleBrushToPixelData(target, color, centerX, centerY, brushSize, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
-  const r = brushSize / 2;
-  const rSqr = r * r;
-  const centerOffset = brushSize % 2 === 0 ? 0.5 : 0;
-  const xStart = Math.max(0, Math.ceil(centerX - r));
-  const xEnd = Math.min(target.width - 1, Math.floor(centerX + r));
-  const yStart = Math.max(0, Math.ceil(centerY - r));
-  const yEnd = Math.min(target.height - 1, Math.floor(centerY + r));
-  const data32 = target.data32;
-  const targetWidth = target.width;
-  const baseColor = color & 16777215;
-  const invR = 1 / r;
-  const constantSrc = (alpha << 24 | baseColor) >>> 0;
-  for (let cy = yStart; cy <= yEnd; cy++) {
-    const dy = cy - centerY + centerOffset;
-    const dySqr = dy * dy;
-    const rowOffset = cy * targetWidth;
-    for (let cx = xStart; cx <= xEnd; cx++) {
-      const dx = cx - centerX + centerOffset;
-      const dSqr = dx * dx + dySqr;
-      if (dSqr <= rSqr) {
-        const idx = rowOffset + cx;
-        if (fallOff) {
-          const strength = fallOff(Math.sqrt(dSqr) * invR);
-          const fAlpha = alpha * strength & 255;
-          const src = (fAlpha << 24 | baseColor) >>> 0;
-          data32[idx] = blendFn(src, data32[idx]);
-        } else {
-          data32[idx] = blendFn(constantSrc, data32[idx]);
-        }
-      }
-    }
-  }
-}
-
-// src/PixelData/applyRectBrushToPixelData.ts
-function applyRectBrushToPixelData(target, color, centerX, centerY, brushWidth, brushHeight, alpha = 255, fallOff, blendFn = sourceOverPerfect) {
-  const targetWidth = target.width;
-  const targetHeight = target.height;
-  const data32 = target.data32;
-  const rawStartX = Math.floor(centerX - brushWidth / 2);
-  const rawStartY = Math.floor(centerY - brushHeight / 2);
-  const endX = Math.min(targetWidth, rawStartX + brushWidth);
-  const endY = Math.min(targetHeight, rawStartY + brushHeight);
-  const startX = Math.max(0, rawStartX);
-  const startY = Math.max(0, rawStartY);
-  const baseColor = color & 16777215;
-  const constantSrc = (alpha << 24 | baseColor) >>> 0;
-  const invHalfW = 1 / (brushWidth / 2);
-  const invHalfH = 1 / (brushHeight / 2);
-  for (let py = startY; py < endY; py++) {
-    const rowOffset = py * targetWidth;
-    const dy = Math.abs(py + 0.5 - centerY) * invHalfH;
-    for (let px = startX; px < endX; px++) {
-      if (fallOff) {
-        const dx = Math.abs(px + 0.5 - centerX) * invHalfW;
-        const dist = dx > dy ? dx : dy;
-        const fAlpha = alpha * fallOff(dist) | 0;
-        const src = (fAlpha << 24 | baseColor) >>> 0;
-        data32[rowOffset + px] = blendFn(src, data32[rowOffset + px]);
-      } else {
-        data32[rowOffset + px] = blendFn(constantSrc, data32[rowOffset + px]);
-      }
-    }
-  }
-}
-function getRectBrushBounds(centerX, centerY, brushWidth, brushHeight, targetWidth, targetHeight) {
-  const rawStartX = Math.floor(centerX - brushWidth / 2);
-  const rawStartY = Math.floor(centerY - brushHeight / 2);
-  const rawEndX = rawStartX + brushWidth;
-  const rawEndY = rawStartY + brushHeight;
-  const startX = targetWidth !== void 0 ? Math.max(0, rawStartX) : rawStartX;
-  const startY = targetHeight !== void 0 ? Math.max(0, rawStartY) : rawStartY;
-  const endX = targetWidth !== void 0 ? Math.min(targetWidth, rawEndX) : rawEndX;
-  const endY = targetHeight !== void 0 ? Math.min(targetHeight, rawEndY) : rawEndY;
-  return {
-    x: startX,
-    y: startY,
-    w: endX - startX,
-    h: endY - startY
-  };
-}
-
 // src/PixelData/clearPixelData.ts
 function clearPixelData(dst, rect) {
   fillPixelData(dst, 0, rect);
@@ -3472,6 +3585,7 @@ function writePixelDataBuffer(target, data, _x, _y, _w, _h) {
   fileToImageData,
   fillPixelData,
   floodFillSelection,
+  getCircleBrushBounds,
   getImageDataFromClipboard,
   getIndexedImageColorCounts,
   getRectBrushBounds,