pixeli 0.1.9 → 1.0.4

package/commands/merge/masonry.js

@@ -1,72 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import {
-  cliConfirm,
-  displayInfoMessage,
-  displaySuccessMessage,
-  displayWarningMessage,
-  handleError,
-  writeImage,
-} from '../../lib/helpers/utils.js';
-import { addSharedOptions } from './helpers/utils.js';
-import { validateMasonryOptions, validateSharedOptions } from './helpers/validations.js';
-import { loadImages } from '../../lib/helpers/loadImages.js';
-import { masonryMerge } from '../../lib/merges/masonry-merge/index.js';
-
-const masonryCommand = new Command('masonry');
-
-masonryCommand
-  .description("Use a ragged-grid layout, preserves images' aspect ratios")
-  .option('--rh, --row-height <px>', 'The height of each row, defaults to the smallest image height', null)
-  .option('--cw, --column-width <px>', 'The width of each column, defaults to the smallest image width', null)
-  .option('--cvw, --canvas-width <px>', 'The width of the canvas', null)
-  .option('--cvh, --canvas-height <px>', 'The height of the canvas', null)
-  .option('-f, --flow <horizontal|vertical>', 'The flow of the masonry layout', 'horizontal')
-  .option('--ha, --h-align <left|center|right|justified>', 'Horizontal alignment of the grid (for horizontal flows)', null)
-  .option('--va, --v-align <top|middle|bottom|justified>', 'Vertical alignment of the grid (for vertical flows)', null)
-  .action((files, opts) => {
-    main(files, opts);
-  });
-
-const main = async (files, opts) => {
-  try {
-    // Collect and validate parameters
-    const params = { files, ...opts };
-    const sharedOptions = await validateSharedOptions(params);
-    const masonryOptions = validateMasonryOptions(sharedOptions, opts);
-    const validatedParams = { ...sharedOptions, ...masonryOptions };
-
-    // Load images, create grid, and write grid on disk
-    generateAndSaveGrid(validatedParams);
-
-    // Output success message
-  } catch (e) {
-    handleError(e);
-  }
-};
-
-const generateAndSaveGrid = async (validatedParams) => {
-  const { images, ignoredFiles } = await loadImages(validatedParams);
-
-  // Display warnings if needed
-  if (ignoredFiles.length) {
-    displayWarningMessage('\nThese files will be ignored due to unsupported formats:');
-    for (const file of ignoredFiles) {
-      displayInfoMessage(file);
-    }
-
-    const confirmation = await cliConfirm('\nAre you sure you want to continue?');
-    if (!confirmation) return;
-  }
-
-  const grid = await masonryMerge(images, validatedParams);
-  const success = await writeImage(grid, validatedParams.output);
-
-  // Display success message
-  if (success) {
-    displaySuccessMessage(`\nImage has been created successfully: ${chalk.bold(validatedParams.output)}\n`);
-  }
-};
-
-addSharedOptions(masonryCommand);
-export default masonryCommand;

package/lib/helpers/loadImages.js

@@ -1,94 +0,0 @@
-import sharp from 'sharp';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { isSupportedInputImage, shuffleTogether } from './utils.js';
-
-const MAX_RECURSION_DEPTH = 10;
-
-export const loadImages = async ({ files, dir, recursive, shuffle, count }) => {
-  let ignoredFiles = [];
-  let filepaths = files;
-  let images = [];
-
-  if (files && files.length) {
-    // Load directly from provided file list
-    images = await loadFromFiles(files, count);
-  } else {
-    // Get all files from directory
-    const { skippedFiles, paths } = await getFilesFromDirectory(dir, recursive);
-    filepaths = paths;
-    ignoredFiles = skippedFiles;
-    images = await loadFromFiles(filepaths, count);
-  }
-
-  // Ensure filepaths and images match
-  if (images.length !== filepaths.length) {
-    filepaths = filepaths.slice(0, images.length);
-  }
-
-  // Optional: shuffle filepaths and images together
-  if (shuffle) {
-    [filepaths, images] = shuffleTogether(filepaths, images);
-  }
-
-  return { images, files: filepaths, ignoredFiles };
-};
-
-const loadFromFiles = async (files, count) => {
-  const images = [];
-  const total = count || files.length;
-  for (let i = 0; i < total; i++) {
-    // End the loop if count is higher than number of available files
-    if (i >= files.length) break;
-
-    // Load images
-    const filepath = files[i];
-    let image;
-
-    if (filepath.endsWith('.svg')) {
-      const svgBuffer = await fs.readFile(filepath);
-      image = sharp(svgBuffer);
-    } else {
-      image = sharp(filepath);
-    }
-
-    images.push(image);
-  }
-
-  return images;
-};
-
-const getFilesFromDirectory = async (dir, recursive, depth = 0) => {
-  // Use to collect warnings
-  const skippedFiles = [];
-
-  // Ensure recursiveness ends at the max recursion depth
-  if (depth >= MAX_RECURSION_DEPTH) return { paths: [], skippedFiles: [] };
-
-  // Get entries
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  const files = [];
-
-  for (const entry of entries) {
-    const file = path.join(entry.parentPath, entry.name);
-
-    // If the entry is a valid image file, add it to the list
-    if (entry.isFile() && isSupportedInputImage(entry.name)) {
-      files.push(file);
-    }
-    // If it is an invalid file format, add to skipped files
-    else if (entry.isFile() && !isSupportedInputImage(entry.name) && entry.name !== '.DS_Store') {
-      skippedFiles.push(entry.name);
-    }
-    // If it's a directory AND the recursive option is true,
-    // recursively get all the files
-    else if (recursive && entry.isDirectory() && !entry.isSymbolicLink()) {
-      const dirpath = path.join(entry.parentPath, entry.name);
-      const dirObj = await getFilesFromDirectory(dirpath, recursive, depth + 1);
-      files.push(...dirObj?.paths);
-      skippedFiles.push(...dirObj.skippedFiles);
-    }
-  }
-
-  return { paths: files, skippedFiles };
-};

package/lib/helpers/progressBar.js

@@ -1,20 +0,0 @@
-import { SingleBar } from 'cli-progress';
-import chalk from 'chalk';
-
-const title = chalk.gray('Creating Image:');
-const bar = chalk.blue('{bar}');
-const percentage = chalk.yellow('{percentage}%');
-const eta = chalk.blue('ETA: ') + chalk.yellow('{eta_formatted}');
-const stage = chalk.gray('{stage}...');
-const divider = chalk.blue('|');
-
-export const WRITING_TO_FILE_PERCENTAGE = 0.05;
-
-export const progressBar = new SingleBar({
-  format: `${title} ${divider}${bar}${divider} ${percentage} ${divider} ${eta} ${divider} ${stage} `,
-  barCompleteChar: '\u2588',
-  barIncompleteChar: '\u2591',
-  stopOnComplete: true,
-  barsize: 40,
-  etaBuffer: 50,
-});

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