simple-photo-gallery 0.0.4 → 0.0.5

package/src/modules/thumbnails/index.ts

@@ -1,121 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { createImageThumbnail, createVideoThumbnail } from './utils';
-
-import { GalleryDataSchema, type MediaFile } from '../../types';
-import { findGalleries } from '../../utils';
-
-import type { ThumbnailOptions } from './types';
-const processGallery = async (galleryDir: string, size: number): Promise<number> => {
-  const galleryJsonPath = path.join(galleryDir, 'gallery', 'gallery.json');
-  const thumbnailsPath = path.join(galleryDir, 'gallery', 'thumbnails');
-
-  console.log(`\nProcessing gallery in: ${galleryDir}`);
-
-  try {
-    // Ensure thumbnails directory exists
-    fs.mkdirSync(thumbnailsPath, { recursive: true });
-
-    // Read gallery.json
-    const galleryContent = fs.readFileSync(galleryJsonPath, 'utf8');
-    const galleryData = GalleryDataSchema.parse(JSON.parse(galleryContent));
-
-    // Process all sections and their images
-    let processedCount = 0;
-    for (const section of galleryData.sections) {
-      for (const [index, mediaFile] of section.images.entries()) {
-        section.images[index] = await processMediaFile(mediaFile, galleryDir, thumbnailsPath, size);
-      }
-
-      processedCount += section.images.length;
-    }
-
-    // Write updated gallery.json
-    fs.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
-
-    return processedCount;
-  } catch (error) {
-    console.error(`Error creating thumbnails for ${galleryDir}:`, error);
-    return 0;
-  }
-};
-
-async function processMediaFile(
-  mediaFile: MediaFile,
-  galleryDir: string,
-  thumbnailsPath: string,
-  size: number,
-): Promise<MediaFile> {
-  try {
-    // Resolve the path relative to the gallery.json file location, not the gallery directory
-    const galleryJsonDir = path.join(galleryDir, 'gallery');
-    const filePath = path.resolve(path.join(galleryJsonDir, mediaFile.path));
-
-    const fileName = path.basename(filePath);
-    const fileNameWithoutExt = path.parse(fileName).name;
-    const thumbnailFileName = `${fileNameWithoutExt}.jpg`;
-    const thumbnailPath = path.join(thumbnailsPath, thumbnailFileName);
-    const relativeThumbnailPath = path.relative(galleryJsonDir, thumbnailPath);
-
-    console.log(`Processing ${mediaFile.type}: ${fileName}`);
-
-    let thumbnailDimensions: { width: number; height: number };
-
-    if (mediaFile.type === 'image') {
-      thumbnailDimensions = await createImageThumbnail(filePath, thumbnailPath, size);
-    } else if (mediaFile.type === 'video') {
-      thumbnailDimensions = await createVideoThumbnail(filePath, thumbnailPath, size);
-    } else {
-      console.warn(`Unknown media type: ${mediaFile.type}, skipping...`);
-      return mediaFile;
-    }
-
-    // Update media file with thumbnail information
-    const updatedMediaFile: MediaFile = {
-      ...mediaFile,
-      thumbnail: {
-        path: relativeThumbnailPath,
-        width: thumbnailDimensions.width,
-        height: thumbnailDimensions.height,
-      },
-    };
-
-    return updatedMediaFile;
-  } catch (error) {
-    if (error instanceof Error && error.message === 'FFMPEG_NOT_AVAILABLE') {
-      console.warn(`⚠ Skipping video thumbnail (ffmpeg not available): ${path.basename(mediaFile.path)}`);
-    } else {
-      console.error(`Error processing ${mediaFile.path}:`, error);
-    }
-
-    return mediaFile;
-  }
-}
-
-export async function thumbnails(options: ThumbnailOptions): Promise<void> {
-  const size = Number.parseInt(options.size);
-
-  // Find all gallery directories
-  const galleryDirs = findGalleries(options.path, options.recursive);
-
-  // If no galleries are found, exit
-  if (galleryDirs.length === 0) {
-    console.log('No gallery/gallery.json files found.');
-    return;
-  }
-
-  // Process each gallery directory
-  let totalProcessed = 0;
-  for (const galleryDir of galleryDirs) {
-    const processed = await processGallery(galleryDir, size);
-    totalProcessed += processed;
-  }
-
-  // Log processing stats
-  if (options.recursive) {
-    console.log(`Completed processing ${totalProcessed} total media files across ${galleryDirs.length} galleries.`);
-  } else {
-    console.log(`Completed processing ${totalProcessed} media files.`);
-  }
-}

package/src/modules/thumbnails/types/index.ts

@@ -1,5 +0,0 @@
-export interface ThumbnailOptions {
-  path: string;
-  size: string;
-  recursive: boolean;
-}

package/src/modules/thumbnails/utils/index.ts

@@ -1,162 +0,0 @@
-import { spawn } from 'node:child_process';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-import ffprobe from 'node-ffprobe';
-import sharp from 'sharp';
-
-import type { Buffer } from 'node:buffer';
-
-// Check if ffmpeg is available
-async function checkFfmpegAvailability(): Promise<boolean> {
-  return new Promise((resolve) => {
-    const ffmpeg = spawn('ffmpeg', ['-version']);
-
-    ffmpeg.on('close', (code) => {
-      resolve(code === 0);
-    });
-
-    ffmpeg.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-// Utility function to resize and save thumbnail
-async function resizeAndSaveThumbnail(image: sharp.Sharp, outputPath: string, width: number, height: number): Promise<void> {
-  await image.resize(width, height, { withoutEnlargement: true }).jpeg({ quality: 90 }).toFile(outputPath);
-}
-
-export async function createImageThumbnail(
-  inputPath: string,
-  outputPath: string,
-  height: number,
-): Promise<{ width: number; height: number }> {
-  try {
-    // Check if input file exists
-    await fs.access(inputPath);
-
-    // Create thumbnail using sharp
-    const image = sharp(inputPath);
-    const metadata = await image.metadata();
-
-    const originalWidth = metadata.width || 0;
-    const originalHeight = metadata.height || 0;
-
-    if (originalWidth === 0 || originalHeight === 0) {
-      throw new Error('Invalid image dimensions');
-    }
-
-    // Calculate width maintaining aspect ratio
-    const aspectRatio = originalWidth / originalHeight;
-    const width = Math.round(height * aspectRatio);
-
-    await resizeAndSaveThumbnail(image, outputPath, width, height);
-
-    return { width, height };
-  } catch (error) {
-    throw new Error(`Failed to create image thumbnail for ${inputPath}: ${error}`);
-  }
-}
-
-export async function createVideoThumbnail(
-  inputPath: string,
-  outputPath: string,
-  height: number,
-): Promise<{ width: number; height: number }> {
-  try {
-    // Check if input file exists
-    await fs.access(inputPath);
-
-    // Check if ffmpeg is available
-    const ffmpegAvailable = await checkFfmpegAvailability();
-    if (!ffmpegAvailable) {
-      console.warn(`Warning: ffmpeg is not available. Skipping thumbnail creation for video: ${path.basename(inputPath)}`);
-      throw new Error('FFMPEG_NOT_AVAILABLE');
-    }
-
-    // Get video metadata using ffprobe
-    const videoData = await ffprobe(inputPath);
-    const videoStream = videoData.streams.find((stream) => stream.codec_type === 'video');
-
-    if (!videoStream) {
-      throw new Error('No video stream found');
-    }
-
-    const originalWidth = videoStream.width || 0;
-    const originalHeight = videoStream.height || 0;
-
-    if (originalWidth === 0 || originalHeight === 0) {
-      throw new Error('Invalid video dimensions');
-    }
-
-    // Calculate width maintaining aspect ratio
-    const aspectRatio = originalWidth / originalHeight;
-    const width = Math.round(height * aspectRatio);
-
-    // Use ffmpeg to extract first frame as a temporary file, then process with sharp
-    const tempFramePath = `${outputPath}.temp.png`;
-
-    return new Promise((resolve, reject) => {
-      // Extract first frame using ffmpeg
-      const ffmpeg = spawn('ffmpeg', [
-        '-i',
-        inputPath,
-        '-vframes',
-        '1',
-        '-y', // Overwrite output file
-        tempFramePath,
-      ]);
-
-      ffmpeg.stderr.on('data', (data: Buffer) => {
-        // FFmpeg writes normal output to stderr, so we don't treat this as an error
-        console.debug(`ffmpeg: ${data.toString()}`);
-      });
-
-      ffmpeg.on('close', async (code: number) => {
-        if (code === 0) {
-          try {
-            // Process the extracted frame with sharp
-            const frameImage = sharp(tempFramePath);
-            await resizeAndSaveThumbnail(frameImage, outputPath, width, height);
-
-            // Clean up temporary file
-            try {
-              await fs.unlink(tempFramePath);
-            } catch {
-              // Ignore cleanup errors
-            }
-
-            resolve({ width, height });
-          } catch (sharpError) {
-            reject(new Error(`Failed to process extracted frame: ${sharpError}`));
-          }
-        } else {
-          reject(new Error(`ffmpeg exited with code ${code}`));
-        }
-      });
-
-      ffmpeg.on('error', (error: Error) => {
-        reject(new Error(`Failed to start ffmpeg: ${error.message}`));
-      });
-    });
-  } catch (error) {
-    if (error instanceof Error && error.message === 'FFMPEG_NOT_AVAILABLE') {
-      // Re-throw the specific error for graceful handling upstream
-      throw error;
-    }
-    if (
-      typeof error === 'object' &&
-      error !== null &&
-      'message' in error &&
-      typeof (error as { message: string }).message === 'string' &&
-      ((error as { message: string }).message.includes('ffmpeg') ||
-        (error as { message: string }).message.includes('ffprobe'))
-    ) {
-      throw new Error(
-        `Error: ffmpeg is required to process videos. Please install ffmpeg and ensure it is available in your PATH. Failed to process: ${path.basename(inputPath)}`,
-      );
-    }
-    throw new Error(`Failed to create video thumbnail for ${inputPath}: ${error}`);
-  }
-}

package/src/types/index.ts

@@ -1,46 +0,0 @@
-import { z } from 'zod';
-
-export const ThumbnailSchema = z.object({
-  path: z.string(),
-  width: z.number(),
-  height: z.number(),
-});
-
-export const MediaFileSchema = z.object({
-  type: z.enum(['image', 'video']),
-  path: z.string(),
-  alt: z.string().optional(),
-  width: z.number(),
-  height: z.number(),
-  thumbnail: ThumbnailSchema.optional(),
-});
-
-export const GallerySectionSchema = z.object({
-  title: z.string().optional(),
-  description: z.string().optional(),
-  images: z.array(MediaFileSchema),
-});
-
-export const SubGallerySchema = z.object({
-  title: z.string(),
-  headerImage: z.string(),
-  path: z.string(),
-});
-
-export const GalleryDataSchema = z.object({
-  title: z.string(),
-  description: z.string(),
-  headerImage: z.string(),
-  metadata: z.object({
-    ogUrl: z.string(),
-  }),
-  galleryOutputPath: z.string().optional(),
-  sections: z.array(GallerySectionSchema),
-  subGalleries: z.object({ title: z.string(), galleries: z.array(SubGallerySchema) }),
-});
-
-export type Thumbnail = z.infer<typeof ThumbnailSchema>;
-export type MediaFile = z.infer<typeof MediaFileSchema>;
-export type GallerySection = z.infer<typeof GallerySectionSchema>;
-export type SubGallery = z.infer<typeof SubGallerySchema>;
-export type GalleryData = z.infer<typeof GalleryDataSchema>;

package/src/utils/index.ts

@@ -1,37 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-/**
- * Finds all gallery directories that contain a gallery/gallery.json file.
- *
- * @param basePath - The base directory to search from
- * @param recursive - Whether to search subdirectories recursively
- * @returns Array of paths to directories containing gallery/gallery.json files
- */
-export const findGalleries = (basePath: string, recursive: boolean): string[] => {
-  const galleryDirs: string[] = [];
-
-  // Check basePath itself
-  const galleryJsonPath = path.join(basePath, 'gallery', 'gallery.json');
-  if (fs.existsSync(galleryJsonPath)) {
-    galleryDirs.push(basePath);
-  }
-
-  // If recursive, search all subdirectories
-  if (recursive) {
-    try {
-      const entries = fs.readdirSync(basePath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name !== 'gallery') {
-          const subPath = path.join(basePath, entry.name);
-          const subResults = findGalleries(subPath, recursive);
-          galleryDirs.push(...subResults);
-        }
-      }
-    } catch {
-      // Silently ignore errors when reading directories
-    }
-  }
-
-  return galleryDirs;
-};