pixeli 0.1.9 → 1.0.4

package/lib/merges/collage-merge/presets/instagramGrid.js

@@ -1,18 +0,0 @@
-export default {
-  canvas: {
-    width: 1200,
-    height: 1600,
-    columns: 3,
-    rows: 6,
-    gap: 12,
-    background: '#000',
-  },
-  slots: [
-    { col: 1, row: 1, colSpan: 2, rowSpan: 2 },
-    { col: 3, row: 1, colSpan: 1, rowSpan: 1 },
-    { col: 3, row: 2, colSpan: 1, rowSpan: 1 },
-    { col: 1, row: 3, colSpan: 1, rowSpan: 2 },
-    { col: 2, row: 3, colSpan: 2, rowSpan: 2 },
-    { col: 1, row: 5, colSpan: 3, rowSpan: 2 },
-  ],
-};

package/lib/merges/collage-merge/presets/verticalBookSpread.js

@@ -1,15 +0,0 @@
-export default {
-  canvas: {
-    width: 1400,
-    height: 2100,
-    columns: 2,
-    rows: 3,
-    gap: 20,
-    background: '#000',
-  },
-  slots: [
-    { col: 1, row: 1, colSpan: 2, rowSpan: 1 },
-    { col: 1, row: 2, colSpan: 1, rowSpan: 2 },
-    { col: 2, row: 2, colSpan: 1, rowSpan: 2 },
-  ],
-};

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

@@ -1,152 +0,0 @@
-import path from 'node:path';
-import sharp from 'sharp';
-import { getSmallestImageDimensions, getFontSize, createSvgTextBuffer, roundImages } from '../merge-utils.js';
-import { progressBar, WRITING_TO_FILE_PERCENTAGE } from '../../helpers/progressBar.js';
-
-export const gridMerge = async (files, images, validatedParams) => {
-  // Destructure params
-  const { aspectRatio, imageWidth, columns, gap, cornerRadius, canvasColor, caption, captionColor, maxCaptionSize } = validatedParams;
-
-  // Calculate width if needed, and height from aspect ratio
-  const width = imageWidth || (await getSmallestImageDimensions(images)).smallestWidth;
-  const height = Math.floor(width / aspectRatio);
-
-  // resize images to match width and height
-  const resizedImages = images.map((image) => {
-    return image.resize({
-      width,
-      height,
-      fit: 'cover',
-    });
-  });
-
-  // Round images if needed
-  const roundedImages = await roundImages(resizedImages, { width, height, cornerRadius });
-
-  // Get filenames if needed
-  let filenames = null;
-  if (caption) {
-    filenames = files.map((file) => path.basename(file));
-  }
-
-  // Lay images in a grid
-  const gridParams = {
-    images: roundedImages,
-    width,
-    height,
-    columns,
-    gap,
-    canvasColor,
-    filenames,
-    caption,
-    captionColor,
-    maxCaptionSize,
-  };
-
-  return await layImagesInGrid(gridParams);
-};
-
-const layImagesInGrid = async (opts) => {
-  // Destructure params
-  const { images, width, height, columns, gap, canvasColor, filenames, caption, captionColor, maxCaptionSize } = opts;
-
-  // 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',
-  });
-
-  // Set constant
-  const CAPTION_HEIGHT_TO_CANVAS_WIDTH_RATIO = 0.04;
-
-  // Calculate number of rows
-  const rows = Math.ceil(images.length / columns);
-
-  // Calculate canvas width and caption height
-  const canvasWidth = width * columns + (columns + 1) * gap;
-  const captionHeight = Math.floor(canvasWidth * CAPTION_HEIGHT_TO_CANVAS_WIDTH_RATIO);
-
-  // Calculate canvas height
-  const minimumCanvasHeight = height * rows + (rows + 1) * gap;
-  const canvasHeight = caption ? minimumCanvasHeight + rows * captionHeight : minimumCanvasHeight;
-
-  // Calculate font size if needed
-  let fontSize = null;
-  if (caption) {
-    const longestFilename = filenames.reduce((longest, current) => {
-      return current.length > longest.length ? current : longest;
-    });
-
-    fontSize = await getFontSize({
-      text: longestFilename,
-      maxWidth: width,
-      maxHeight: captionHeight,
-      initialFontSize: maxCaptionSize,
-    });
-  }
-
-  // Create canvas
-  const canvas = sharp({
-    limitInputPixels: false,
-    create: {
-      width: canvasWidth,
-      height: canvasHeight,
-      channels: 4,
-      background: canvasColor,
-    },
-  });
-
-  // Collect composites
-  const composites = [];
-
-  let x = gap;
-  let y = gap;
-
-  for (let row = 0; row < rows; row++) {
-    for (let col = 0; col < columns; col++) {
-      const index = row * columns + col;
-      if (index >= images.length) break;
-
-      const image = images[index];
-
-      composites.push({
-        input: await image.toBuffer(),
-        left: x,
-        top: y,
-      });
-
-      // Add caption if required
-      if (caption) {
-        // Create text
-        const svgBuffer = createSvgTextBuffer({
-          text: filenames[index],
-          maxWidth: width,
-          maxHeight: captionHeight,
-          fontSize,
-          fill: captionColor,
-        });
-
-        // Add text to composites
-        composites.push({
-          input: svgBuffer,
-          left: x,
-          top: y + height,
-        });
-      }
-
-      // Update coordinates
-      x += width + gap;
-
-      // Update progress bar
-      progressBar.increment();
-    }
-
-    // Update coordinates
-    y += caption ? height + gap + captionHeight : height + gap;
-    x = gap;
-  }
-
-  // Create final grid
-  canvas.composite(composites);
-  return canvas;
-};

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);
-  }
-};