pixeli 0.1.8 → 1.0.3

package/lib/merges/masonry-merge/horizontal.js

@@ -1,157 +0,0 @@
-import sharp from 'sharp';
-import { roundImages, scaleImages } from '../merge-utils.js';
-import { progressBar, WRITING_TO_FILE_PERCENTAGE } from '../../helpers/progressBar.js';
-
-export const buildHorizontalMasonry = async (images, params) => {
-  const { gap, canvasColor, cornerRadius, canvasWidth, rowHeight, hAlign } = params;
-
-  // Use 5% of images.length for writing to file
-  const fileWriteAmount = Math.ceil(images.length * WRITING_TO_FILE_PERCENTAGE);
-  progressBar.start(images.length + fileWriteAmount, 0, {
-    stage: 'Merging images',
-  });
-
-  // Rescale images to match rowHeight
-  const scaledImages = await scaleImages(images, { height: rowHeight });
-
-  // Split images into rows, then calculate canvasHeight
-  const rows = await splitIntoRows(scaledImages, canvasWidth, gap, hAlign);
-  const canvasHeight = rows.length * rowHeight + (rows.length + 1) * gap;
-
-  // Create and return grid of images
-  return await createMasonryLayout(rows, rowHeight, canvasWidth, canvasHeight, canvasColor, cornerRadius, gap, hAlign);
-};
-
-const createMasonryLayout = async (rows, rowHeight, canvasWidth, canvasHeight, canvasColor, cornerRadius, gap, hAlign) => {
-  const canvas = sharp({
-    limitInputPixels: false,
-    create: {
-      width: canvasWidth,
-      height: canvasHeight,
-      channels: 4,
-      background: canvasColor,
-    },
-  });
-
-  const composites = [];
-
-  let currentWidth = gap;
-  let x = gap;
-  let y = gap;
-
-  for (const row of rows) {
-    const rowXStart = await computeRowXOffset(row, canvasWidth, gap, hAlign);
-    x = rowXStart;
-
-    for (const im of row) {
-      const meta = await im.metadata();
-      let finalizedImage = im;
-      let finalizedMeta = meta;
-      currentWidth += meta.width + gap;
-
-      if (currentWidth >= canvasWidth) {
-        // Calculate overflow
-        const overflow = currentWidth - canvasWidth;
-
-        // Resize (crop) image to justify
-        const resizeOptions = {
-          width: meta.width - overflow,
-          height: meta.height,
-          fit: 'cover',
-        };
-
-        // Update finalized image and metadata
-        const buff = await im.resize(resizeOptions).toBuffer();
-        finalizedImage = sharp(buff);
-        finalizedMeta = await finalizedImage.metadata();
-      }
-
-      // Round the finalized image
-      const roundingOptions = {
-        width: finalizedMeta.width,
-        height: finalizedMeta.height,
-        cornerRadius,
-      };
-
-      const roundedImage = (await roundImages([finalizedImage], roundingOptions))[0];
-
-      composites.push({
-        input: await roundedImage.toBuffer(),
-        left: x,
-        top: y,
-      });
-
-      x += finalizedMeta.width + gap;
-
-      // Update progress
-      progressBar.increment();
-    }
-
-    x = gap;
-    currentWidth = gap;
-    y += rowHeight + gap;
-  }
-
-  return canvas.composite(composites);
-};
-
-const splitIntoRows = async (images, canvasWidth, gap, hAlign) => {
-  const rows = [];
-  let currentRow = [];
-  let currentWidth = gap; // initial leading gap
-
-  for (const im of images) {
-    const meta = await im.metadata();
-    const nextWidth = currentWidth + meta.width + gap;
-
-    if (hAlign === 'justified') {
-      // Greedy: always push image, fix overflow later
-      currentRow.push(im);
-      currentWidth = nextWidth;
-
-      if (currentWidth + gap >= canvasWidth) {
-        rows.push(currentRow.slice());
-        currentRow.length = 0;
-        currentWidth = gap;
-      }
-    } else {
-      // Non-greedy: break BEFORE adding image that doesn't fit
-      if (nextWidth > canvasWidth && currentRow.length > 0) {
-        rows.push(currentRow.slice());
-        currentRow = [];
-        currentWidth = gap;
-      }
-
-      // Add the image (may be first in a new row)
-      currentRow.push(im);
-      currentWidth += meta.width + gap;
-    }
-  }
-
-  if (currentRow.length > 0) {
-    rows.push(currentRow);
-  }
-
-  return rows;
-};
-
-const computeRowXOffset = async (row, canvasWidth, gap, hAlign) => {
-  // Calculate total row width
-  let totalWidth = gap * (row.length + 1);
-  for (const im of row) {
-    const meta = await im.metadata();
-    totalWidth += meta.width;
-  }
-
-  // Get x offset
-  if (hAlign === 'left' || hAlign === 'justified') {
-    return gap;
-  }
-  if (hAlign === 'right') {
-    return canvasWidth - totalWidth + gap;
-  }
-  if (hAlign === 'center') {
-    const canvasGap = gap * 2;
-    return Math.floor((canvasWidth + canvasGap - totalWidth) / 2);
-  }
-};

package/lib/merges/masonry-merge/index.js

@@ -1,57 +0,0 @@
-import { calculateAvgWidth, calculateAvgHeight } from '../merge-utils.js';
-import { buildHorizontalMasonry } from './horizontal.js';
-import { buildVerticalMasonry } from './vertical.js';
-
-const FLOW_DEFAULTS = {
-  horizontal: {
-    needed: ['canvasWidth', 'rowHeight', 'hAlign'],
-    defaults: {
-      rowHeight: calculateAvgHeight,
-      hAlign: () => 'justified',
-    },
-  },
-  vertical: {
-    needed: ['canvasHeight', 'columnWidth', 'vAlign'],
-    defaults: {
-      columnWidth: calculateAvgWidth,
-      vAlign: () => 'justified',
-    },
-  },
-};
-
-export const masonryMerge = async (images, opts) => {
-  const { flow } = opts;
-  const params = await getFlowSpecificParams(images, opts);
-
-  return await generateGrid(flow, images, params);
-};
-
-const getFlowSpecificParams = async (images, currentParams) => {
-  const { flow, gap, canvasColor, cornerRadius } = currentParams;
-  const config = FLOW_DEFAULTS[flow];
-
-  const output = { gap, canvasColor, cornerRadius };
-
-  for (const key of config.needed) {
-    if (currentParams[key] != null) {
-      output[key] = currentParams[key];
-    }
-  }
-
-  // Assign static defaults
-  for (const [key, getter] of Object.entries(config.defaults)) {
-    if (output[key] == null) {
-      output[key] = await getter(images);
-    }
-  }
-
-  return output;
-};
-
-const generateGrid = async (flow, images, params) => {
-  if (flow === 'horizontal') {
-    return await buildHorizontalMasonry(images, params);
-  } else {
-    return buildVerticalMasonry(images, params);
-  }
-};

package/lib/merges/masonry-merge/vertical.js

@@ -1,152 +0,0 @@
-import sharp from 'sharp';
-import { roundImages, scaleImages } from '../merge-utils.js';
-import { progressBar, WRITING_TO_FILE_PERCENTAGE } from '../../helpers/progressBar.js';
-
-export const buildVerticalMasonry = async (images, params) => {
-  const { gap, canvasColor, cornerRadius, canvasHeight, columnWidth, vAlign } = params;
-
-  // Use 5% of images.length for writing to file
-  const fileWriteAmount = Math.ceil(images.length * WRITING_TO_FILE_PERCENTAGE);
-  progressBar.start(images.length + fileWriteAmount, 0, {
-    stage: 'Merging images',
-  });
-
-  // Rescale images to match columnWidth
-  const scaledImages = await scaleImages(images, { width: columnWidth });
-
-  // Split images into columns, then calculate canvasWidth
-  const columns = await splitIntoColumns(scaledImages, canvasHeight, gap, vAlign);
-  const canvasWidth = columns.length * columnWidth + (columns.length + 1) * gap;
-
-  // Create and return grid of images
-  return await createMasonryLayout(columns, columnWidth, canvasWidth, canvasHeight, canvasColor, cornerRadius, gap, vAlign);
-};
-
-const createMasonryLayout = async (cols, columnWidth, canvasWidth, canvasHeight, canvasColor, cornerRadius, gap, vAlign) => {
-  const composites = [];
-
-  const canvas = sharp({
-    limitInputPixels: false,
-    create: {
-      width: canvasWidth,
-      height: canvasHeight,
-      channels: 4,
-      background: canvasColor,
-    },
-  });
-
-  let x = gap;
-  let currentHeight = gap;
-
-  for (const col of cols) {
-    let y = await computeColYOffset(col, canvasHeight, gap, vAlign);
-
-    for (const im of col) {
-      let finalizedImage = im;
-      let finalizedMeta = await im.metadata();
-
-      currentHeight += finalizedMeta.height + gap;
-
-      if (currentHeight >= canvasHeight) {
-        const yOverflow = currentHeight - canvasHeight;
-
-        const resizeOptions = {
-          width: finalizedMeta.width,
-          height: finalizedMeta.height - yOverflow,
-          fit: 'cover',
-        };
-
-        const buffer = await finalizedImage.resize(resizeOptions).toBuffer();
-        finalizedImage = sharp(buffer);
-        finalizedMeta = await finalizedImage.metadata();
-      }
-
-      // Round the finalized image
-      const roundingOptions = {
-        width: finalizedMeta.width,
-        height: finalizedMeta.height,
-        cornerRadius,
-      };
-
-      const roundedImage = (await roundImages([finalizedImage], roundingOptions))[0];
-
-      composites.push({
-        input: await roundedImage.toBuffer(),
-        left: x,
-        top: y,
-      });
-
-      y += finalizedMeta.height + gap;
-
-      // Update progress bar
-      progressBar.increment();
-    }
-
-    y = gap;
-    currentHeight = gap;
-    x += columnWidth + gap;
-  }
-
-  return canvas.composite(composites);
-};
-
-const splitIntoColumns = async (images, canvasHeight, gap, vAlign) => {
-  const cols = [];
-  const currentCol = [];
-  let currentHeight = gap;
-
-  for (const im of images) {
-    const meta = await im.metadata();
-    let nextHeight = currentHeight + meta.height + gap;
-
-    if (vAlign === 'justified') {
-      // Greedy: always push image, fix overflow later
-      currentCol.push(im);
-      currentHeight = nextHeight;
-
-      if (currentHeight + gap >= canvasHeight) {
-        cols.push(currentCol.slice());
-        currentCol.length = 0;
-        currentHeight = gap;
-      }
-    } else {
-      // Non-greedy: break BEFORE adding image that doesn't fit
-      if (nextHeight > canvasHeight && currentCol.length > 0) {
-        cols.push(currentCol.slice());
-        currentCol.length = 0;
-        currentHeight = gap;
-      }
-
-      // Add the image (may be first in a new column)
-      currentCol.push(im);
-      currentHeight += meta.height + gap;
-    }
-  }
-
-  if (currentCol.length > 0) {
-    cols.push(currentCol);
-  }
-
-  return cols;
-};
-
-const computeColYOffset = async (col, canvasHeight, gap, vAlign) => {
-  // Calculate total row width
-  let totalHeight = gap * (col.length + 1);
-  for (const im of col) {
-    const meta = await im.metadata();
-    totalHeight += meta.height;
-  }
-
-  // Get x offset
-  if (vAlign === 'top' || vAlign === 'justified') {
-    return gap;
-  }
-  if (vAlign === 'bottom') {
-    return canvasHeight - totalHeight + gap;
-  }
-  if (vAlign === 'middle') {
-    const canvasGap = gap * 2;
-    return Math.floor((canvasHeight + canvasGap - totalHeight) / 2);
-  }
-};

package/lib/merges/merge-utils.js

@@ -1,176 +0,0 @@
-import sharp from 'sharp';
-
-export const calculateAvgHeight = async (images) => {
-  let totalHeight = 0;
-
-  for (const img of images) {
-    const meta = await img.metadata();
-    totalHeight += meta.height;
-  }
-
-  return Math.floor(totalHeight / images.length);
-};
-
-export const calculateAvgWidth = async (images) => {
-  let totalWidth = 0;
-
-  for (const img of images) {
-    const meta = await img.metadata();
-    totalWidth += meta.width;
-  }
-
-  return Math.floor(totalWidth / images.length);
-};
-
-export const scaleImages = async (images, { width = null, height = null }) => {
-  if (!width && !height) {
-    throw new Error('You must provide either width or height.');
-  }
-
-  const scaledImages = await Promise.all(
-    images.map(async (image) => {
-      const meta = await image.metadata();
-
-      let targetWidth, targetHeight;
-
-      if (width && height) {
-        targetWidth = width;
-        targetHeight = height;
-      } else if (width) {
-        const f = width / meta.width;
-        targetWidth = width;
-        targetHeight = Math.floor(meta.height * f);
-      } else {
-        const f = height / meta.height;
-        targetHeight = height;
-        targetWidth = Math.floor(meta.width * f);
-      }
-
-      const buffer = await image.resize(targetWidth, targetHeight).toBuffer();
-
-      return sharp(buffer);
-    })
-  );
-
-  return scaledImages;
-};
-
-export const getSmallestImageDimensions = async (images) => {
-  const metas = await Promise.all(images.map((img) => img.metadata()));
-
-  return metas.reduce(
-    (acc, meta) => ({
-      smallestWidth: Math.min(acc.smallestWidth, meta.width),
-      smallestHeight: Math.min(acc.smallestHeight, meta.height),
-    }),
-    { smallestWidth: Infinity, smallestHeight: Infinity }
-  );
-};
-
-export const getFontSize = async ({
-  text,
-  maxWidth,
-  maxHeight,
-  initialFontSize = 100,
-  minFontSize = 2,
-  fontFamily = 'sans-serif',
-}) => {
-  const THRESHOLD = 200;
-  const SMALL_CHANGE = 2;
-  const LARGE_CHANGE = 5;
-
-  let fontSize = initialFontSize;
-
-  while (fontSize >= minFontSize) {
-    // No width or viewport given so that the actual size can be determined after rasterization
-    const svg = `
-    <svg xmlns="http://www.w3.org/2000/svg">
-      <text
-        x="${maxWidth / 2}"
-        y="10"
-        font-size="${fontSize}"
-        font-family="${fontFamily}"
-        fill="#000000"
-        text-anchor="middle"
-        dominant-baseline="middle">
-        ${escapeXML(text)}
-      </text>
-    </svg>
-    `;
-
-    // Rasterize SVG: measure actual rendered size
-    const raster = await sharp(Buffer.from(svg)).png().toBuffer();
-    const meta = await sharp(raster).metadata();
-
-    if (meta.width <= maxWidth && meta.height <= maxHeight) {
-      return fontSize;
-    }
-
-    // If the difference is greater than the threshold, use large change
-    if (maxWidth - meta.width > THRESHOLD || maxHeight - meta.height) {
-      fontSize -= LARGE_CHANGE;
-    } else {
-      fontSize -= SMALL_CHANGE;
-    }
-  }
-
-  return minFontSize;
-};
-
-export const createSvgTextBuffer = ({ text, maxWidth, maxHeight, fontSize, fill = '#000000', fontFamily = 'sans-serif' }) => {
-  // Width and viewport are assigned to this svg
-  const svg = `
-    <svg xmlns="http://www.w3.org/2000/svg"
-         width="${maxWidth}" height="${maxHeight}"
-         viewBox="0 0 ${maxWidth} ${maxHeight}">
-      <text
-        x="${maxWidth / 2}"
-        y="${maxHeight / 2}"
-        font-size="${fontSize}"
-        font-family="${fontFamily}"
-        fill="${fill}"
-        text-anchor="middle"
-        dominant-baseline="middle">
-        ${escapeXML(text)}
-      </text>
-    </svg>
-    `;
-
-  return Buffer.from(svg);
-};
-
-const escapeXML = (str) => {
-  return str.replace(
-    /[<>&'"]/g,
-    (c) =>
-      ({
-        '<': '&lt;',
-        '>': '&gt;',
-        '&': '&amp;',
-        '"': '&quot;',
-        "'": '&apos;',
-      }[c])
-  );
-};
-
-export const roundImages = async (images, { width, height, cornerRadius }) => {
-  // Skip if the cornerRadius = zero
-  if (!cornerRadius) return images;
-
-  // Round images respectively
-  return await Promise.all(
-    images.map(async (image) => {
-      const mask = Buffer.from(`
-        <svg width="${width}" height="${height}">
-          <rect x="0" y="0" width="${width}" height="${height}" rx="${cornerRadius}" ry="${cornerRadius}" />
-          </svg>
-      `);
-
-      const buff = await image
-        .composite([{ input: mask, blend: 'dest-in' }])
-        .png()
-        .toBuffer();
-      return sharp(buff);
-    })
-  );
-};