pixeli 0.1.8 → 1.0.3

package/lib/helpers/templateValidator.js

@@ -1,139 +0,0 @@
-import Ajv from 'ajv';
-import { isValidHexadecimal } from './utils.js';
-
-// Define entire template schema
-const TEMPLATE_SCHEMA = {
-  type: 'object',
-  additionalProperties: false,
-  required: ['canvas', 'slots'],
-  properties: {
-    canvas: {
-      type: 'object',
-      additionalProperties: false,
-      required: ['width', 'height', 'columns', 'rows'],
-      properties: {
-        width: { type: 'number', minimum: 1, multipleOf: 1 },
-        height: { type: 'number', minimum: 1, multipleOf: 1 },
-        columns: { type: 'number', minimum: 1, multipleOf: 1 },
-        rows: { type: 'number', minimum: 1, multipleOf: 1 },
-        gap: { type: 'number', minimum: 0, multipleOf: 1 },
-        background: { type: 'string' },
-      },
-    },
-
-    slots: {
-      type: 'array',
-      items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['col', 'row', 'colSpan', 'rowSpan'],
-        properties: {
-          col: { type: 'number', minimum: 1, multipleOf: 1 },
-          row: { type: 'number', minimum: 1, multipleOf: 1 },
-          colSpan: { type: 'number', minimum: 1, multipleOf: 1 },
-          rowSpan: { type: 'number', minimum: 1, multipleOf: 1 },
-          borderRadius: { type: 'number', minimum: 0, multipleOf: 1 },
-        },
-      },
-    },
-  },
-};
-
-const ajv = new Ajv({ allErrors: true });
-
-const validate = ajv.compile(TEMPLATE_SCHEMA);
-
-export const validateTemplate = (json) => {
-  const valid = validate(json);
-
-  // Handle schema validation
-  if (!valid) {
-    const path = validate.errors[0].instancePath.slice(1).replaceAll('/', '.');
-    const message = validate.errors[0].message;
-    throw new Error(`${path} ${message}.`);
-  }
-
-  // Handle canvas background color
-  if (json.canvas.background !== 'transparent' && !isValidHexadecimal(json.canvas.background)) {
-    throw new Error(`Canvas color must be a valid hex value or "transparent".`);
-  }
-  json.canvas.background = json.canvas.background === 'transparent' ? { r: 0, g: 0, b: 0, alpha: 0 } : json.canvas.background;
-
-  // Ensure canvas is wide enough for at least a single 1px column
-  if (json.canvas.width <= json.canvas.gap * 2) {
-    throw new Error(`Canvas width must be greater than ${json.canvas.gap * 2}.`);
-  }
-
-  // Ensure canvas is long enough for at least a single 1px row
-  if (json.canvas.height <= json.canvas.gap * 2) {
-    throw new Error(`Canvas height must be greater than ${json.canvas.gap * 2}.`);
-  }
-
-  // Calculate column width and row height
-  const workableCanvasWidth = json.canvas.width - json.canvas.gap * (json.canvas.columns + 1);
-  const workableCanvasHeight = json.canvas.height - json.canvas.gap * (json.canvas.rows + 1);
-  const columnWidth = Math.floor(workableCanvasWidth / json.canvas.columns);
-  const rowHeight = Math.floor(workableCanvasHeight / json.canvas.rows);
-
-  // Ensure columns are thick enough
-  if (columnWidth <= 0) {
-    throw new Error(`Columns are too thin. Increase canvas width, reduce gap, or reduce number of columns.`);
-  }
-
-  // Ensure rows are thick enough
-  if (rowHeight <= 0) {
-    throw new Error(`Rows are too thin. Increase canvas height or reduce number of rows.`);
-  }
-
-  // For each slot...
-  for (let i = 0; i < json.slots.length; i++) {
-    const slot = json.slots[i];
-
-    // Ensure slot is placed inside given canvas columns
-    if (slot.col > json.canvas.columns) {
-      throw new Error(`json.slots[${i}].col must be between 1 and ${json.canvas.columns}.`);
-    }
-
-    // Ensure slot is placed inside given canvas rows
-    if (slot.row > json.canvas.rows) {
-      throw new Error(`json.slots[${i}].row must be between 1 and ${json.canvas.rows}.`);
-    }
-
-    // Ensure slot spans within given canvas columns
-    if (slot.col + slot.colSpan - 1 > json.canvas.columns) {
-      throw new Error(`json.slots[${i}] spans past the right edge of the grid (col + colSpan exceeds columns).`);
-    }
-
-    // Ensure slot spans within given canvas rows
-    if (slot.row + slot.rowSpan - 1 > json.canvas.rows) {
-      throw new Error(`json.slots[${i}] spans past the bottom edge of the grid (row + rowSpan exceeds rows).`);
-    }
-  }
-
-  // Ensure no slots overlap
-  validateSlotOverlaps(json.slots);
-
-  return json;
-};
-
-const validateSlotOverlaps = (slots) => {
-  for (let i = 0; i < slots.length; i++) {
-    const A = slots[i];
-
-    const A_right = A.col + A.colSpan - 1;
-    const A_bottom = A.row + A.rowSpan - 1;
-
-    for (let j = i + 1; j < slots.length; j++) {
-      const B = slots[j];
-
-      const B_right = B.col + B.colSpan - 1;
-      const B_bottom = B.row + B.rowSpan - 1;
-
-      const overlap = A.col <= B_right && A_right >= B.col && A.row <= B_bottom && A_bottom >= B.row;
-
-      if (overlap) {
-        throw new Error(`Slot ${i} overlaps with slot ${j}.`);
-      }
-    }
-  }
-};

package/lib/helpers/utils.js

@@ -1,208 +0,0 @@
-import readline from 'node:readline';
-import path from 'node:path';
-import chalk from 'chalk';
-import { progressBar } from './progressBar.js';
-
-export const SUPPORTED_INPUT_FORMATS = ['.webp', '.gif', '.jpeg', '.jpg', '.png', '.tiff', '.avif', '.svg'];
-export const SUPPORTED_OUTPUT_FORMATS = ['.webp', '.gif', '.jpeg', '.jpg', '.png', '.tiff', '.avif'];
-
-// Message class used for logging
-export class Message {
-  constructor(text, type) {
-    this.text = text;
-    this.type = type;
-
-    switch (this.type) {
-      case 'error':
-        this.message = chalk.bold.red('Error: ') + chalk.red(this.text);
-        break;
-      case 'warning':
-        this.message = chalk.yellow(this.text);
-        break;
-      case 'success':
-        this.message = chalk.blue(this.text);
-        break;
-      case 'neutral':
-        this.message = chalk.gray(this.text);
-        break;
-      default:
-        this.message = chalk.gray(this.text);
-        break;
-    }
-  }
-}
-
-export const isValidHexadecimal = (str) => {
-  const hexRegex = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
-  return hexRegex.test(str);
-};
-
-export const parseAspectRatio = (input) => {
-  // return ratio straight away if its just a number
-  const ratio = Number(input);
-  if (ratio) {
-    return ratio;
-  }
-
-  const ratioRegex = /^\s*(\d+)\s*(\/|:|x)\s*(\d+)\s*$/i;
-  const match = input.match(ratioRegex);
-
-  // not parsable
-  if (!match) {
-    return null;
-  }
-
-  const width = parseInt(match[1], 10);
-  const height = parseInt(match[3], 10);
-
-  return width / height;
-};
-
-export const handleError = (error) => {
-  const m = new Message(error.message, 'error');
-  console.log(m.message);
-};
-
-export const configureCommandErrors = (cmd) => {
-  // Configure error message for the current command
-  cmd.configureOutput({
-    writeErr: (str) => {
-      if (str.includes('error:')) {
-        const err = new Message(str.replace('error: ', ''), 'error');
-        return process.stderr.write(err.message);
-      }
-
-      process.stderr.write(str);
-    },
-  });
-
-  // Recursively configure error messages for all subcommands
-  for (const subCmd of cmd.commands) {
-    configureCommandErrors(subCmd);
-  }
-};
-
-export const displayInfoMessage = (message) => {
-  const m = new Message(message, 'neutral');
-  console.log(m.message);
-};
-
-export const displayWarningMessage = (message) => {
-  const m = new Message(message, 'warning');
-  console.log(m.message);
-};
-
-export const displaySuccessMessage = (message) => {
-  const m = new Message(message, 'success');
-  console.log(m.message);
-};
-
-export const cliConfirm = (message) => {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  return new Promise((resolve) => {
-    rl.question(chalk.yellow(`${message} (Y/n) `), (value) => {
-      const cleanedValue = value.toLowerCase().trim();
-      if (cleanedValue === 'y' || !cleanedValue.length) resolve(true);
-      else resolve(false);
-
-      console.log();
-      rl.close();
-    });
-  });
-};
-
-export const isSupportedInputImage = (filename) => {
-  for (const supportedFormat of SUPPORTED_INPUT_FORMATS) {
-    if (filename.endsWith(supportedFormat)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-export const isSupportedOutputImage = (filename) => {
-  for (const supportedFormat of SUPPORTED_OUTPUT_FORMATS) {
-    if (filename.endsWith(supportedFormat)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-export const writeImage = async (image, output) => {
-  // Define file size limits
-  const LIMITS = {
-    png: 2_147_483_647,
-    jpg: 65_535,
-    jpeg: 65_535,
-    avif: 65_535,
-    webp: 16_383,
-  };
-
-  // Update progress bar stage
-  progressBar.update({ stage: 'Writing to file' });
-
-  try {
-    // Get image width and height
-    const { width, height } = await image.metadata();
-    const format = path.extname(output).replaceAll('.', '');
-
-    // Ensure image can be encoded in the respective format
-    const formatLimit = LIMITS[format];
-    if (width > formatLimit || height > formatLimit) {
-      throw new Error(`image is too large for ${format} format.`);
-    }
-
-    // Write to file
-    await image.toFile(output);
-  } catch (e) {
-    // Complete the progress bar
-    progressBar.update(progressBar.getTotal());
-
-    // Handle any errors
-    const m = new Message('Failed to write image on disk: ' + e.message, 'error');
-    console.log('\n' + m.message);
-
-    return false;
-  }
-
-  // Complete the progress bar
-  progressBar.update(progressBar.getTotal());
-
-  return true;
-};
-
-export const shuffleArray = (array) => {
-  let currentIndex = array.length;
-  let randomIndex;
-
-  // While there remain elements to shuffle.
-  while (currentIndex !== 0) {
-    // Pick a remaining element.
-    randomIndex = Math.floor(Math.random() * currentIndex);
-    currentIndex--;
-
-    // And swap it with the current element.
-    [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
-  }
-
-  return array;
-};
-
-export const shuffleTogether = (a, b) => {
-  // 1. Build array of indices
-  const indices = [...a.keys()];
-
-  // 2. Shuffle the indices using your Fisher-Yates
-  shuffleArray(indices);
-
-  // 3. Apply same permutation to both arrays
-  const aShuffled = indices.map((i) => a[i]);
-  const bShuffled = indices.map((i) => b[i]);
-
-  return [aShuffled, bShuffled];
-};

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

@@ -1,110 +0,0 @@
-import sharp from 'sharp';
-import { progressBar, WRITING_TO_FILE_PERCENTAGE } from '../../helpers/progressBar.js';
-import { roundImages } from '../merge-utils.js';
-
-export const collageMerge = async (images, validatedParams) => {
-  const { template, cornerRadius } = validatedParams;
-
-  // Set up progress bar
-  const total = Math.min(images.length, template.slots.length) * 2;
-  const totalFileWrite = Math.ceil(total * WRITING_TO_FILE_PERCENTAGE);
-  progressBar.start(total + totalFileWrite, 0, {
-    stage: 'Calculating dimensions',
-  });
-
-  // Calculate each column's width and height
-  const workableCanvasWidth = template.canvas.width - template.canvas.gap * (template.canvas.columns + 1);
-  const workableCanvasHeight = template.canvas.height - template.canvas.gap * (template.canvas.rows + 1);
-  const columnWidth = workableCanvasWidth / template.canvas.columns;
-  const rowHeight = workableCanvasHeight / template.canvas.rows;
-
-  // Each block has its resized image with its respective slot coordinates
-  progressBar.update({ stage: 'Resizing images' });
-  const blocks = await getBlocks({
-    slots: template.slots,
-    images,
-    gap: template.canvas.gap,
-    columnWidth,
-    rowHeight,
-    cornerRadius,
-  });
-
-  // Lay blocks
-  progressBar.update({ stage: 'Merging images' });
-  const collage = layBlocks({
-    canvasOptions: template.canvas,
-    blocks,
-    columnWidth,
-    rowHeight,
-  });
-
-  return collage;
-};
-
-const getBlocks = async ({ slots, images, gap, columnWidth, rowHeight, cornerRadius }) => {
-  const blocks = [];
-
-  for (let i = 0; i < slots.length && i < images.length; i++) {
-    const slot = slots[i];
-    const image = images[i];
-    let imageBuffer;
-
-    // Calculate image width and height
-    const width = slot.colSpan * columnWidth + (slot.colSpan - 1) * gap;
-    const height = slot.rowSpan * rowHeight + (slot.rowSpan - 1) * gap;
-
-    // Resize image respectively
-    const resizedImage = image.resize({ width: Math.floor(width), height: Math.floor(height) });
-
-    // Round corners of images if needed
-    if (cornerRadius > 0) {
-      const roundingOptions = {
-        width: Math.floor(width),
-        height: Math.floor(height),
-        cornerRadius,
-      };
-
-      const roundedImage = (await roundImages([resizedImage], roundingOptions))[0];
-      imageBuffer = await roundedImage.toBuffer();
-    } else {
-      imageBuffer = await resizedImage.toBuffer();
-    }
-
-    blocks.push({ imageBuffer, col: slot.col, row: slot.row });
-    progressBar.increment();
-  }
-
-  return blocks;
-};
-
-const layBlocks = ({ canvasOptions, blocks, columnWidth, rowHeight }) => {
-  // Create canvas
-  const canvas = sharp({
-    limitInputPixels: false,
-    create: {
-      background: canvasOptions.background,
-      channels: 4,
-      width: canvasOptions.width,
-      height: canvasOptions.height,
-    },
-  });
-
-  const composites = [];
-
-  // Collect composites
-  for (const block of blocks) {
-    const x = (block.col - 1) * columnWidth + block.col * canvasOptions.gap;
-    const y = (block.row - 1) * rowHeight + block.row * canvasOptions.gap;
-
-    composites.push({
-      input: block.imageBuffer,
-      left: Math.floor(x),
-      top: Math.floor(y),
-    });
-
-    progressBar.increment();
-  }
-
-  canvas.composite(composites);
-  return canvas;
-};

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

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

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

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

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

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

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