simple-photo-gallery 0.0.4 → 0.0.5

package/dist/tests/gallery.test.js

@@ -1,170 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, rmSync, readFileSync, readdirSync } from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { copySync } from 'fs-extra';
-import { GalleryDataSchema, MediaFileSchema, ThumbnailSchema } from '../src/types';
-const testDir = process.cwd();
-const tsxPath = path.resolve(testDir, '..', 'node_modules', '.bin', 'tsx');
-const cliPath = path.resolve(testDir, 'src', 'index.ts');
-const singleFixturePath = path.resolve(testDir, 'tests', 'fixtures', 'single');
-const singleTestPath = path.resolve(testDir, 'tests', 'fixtures', 'test', 'single');
-const multiFixturePath = path.resolve(testDir, 'tests', 'fixtures', 'multi');
-const multiTestPath = path.resolve(testDir, 'tests', 'fixtures', 'test', 'multi');
-const MediaFileWithThumbnailSchema = MediaFileSchema.extend({
-    thumbnail: ThumbnailSchema,
-});
-// Helper functions for gallery validation
-function validateGalleryStructure(galleryPath, expectedImageCount, expectedSubGalleryCount = 0) {
-    // Check that gallery.json exists
-    const galleryJsonPath = path.resolve(galleryPath, 'gallery.json');
-    expect(existsSync(galleryJsonPath)).toBe(true);
-    // Read and parse gallery.json
-    const galleryContent = readFileSync(galleryJsonPath, 'utf8');
-    const galleryData = JSON.parse(galleryContent);
-    // Validate with schema
-    expect(() => GalleryDataSchema.parse(galleryData)).not.toThrow();
-    const validatedData = GalleryDataSchema.parse(galleryData);
-    // Check image count
-    expect(validatedData.sections).toHaveLength(1);
-    expect(validatedData.sections[0].images).toHaveLength(expectedImageCount);
-    // Check subgallery count
-    expect(validatedData.subGalleries.galleries).toHaveLength(expectedSubGalleryCount);
-    return validatedData;
-}
-function validateThumbnails(galleryPath, expectedThumbnailCount) {
-    // Check that thumbnails directory exists
-    const thumbnailsPath = path.resolve(galleryPath, 'thumbnails');
-    expect(existsSync(thumbnailsPath)).toBe(true);
-    // Check thumbnail file count
-    const thumbnailFiles = readdirSync(thumbnailsPath);
-    expect(thumbnailFiles).toHaveLength(expectedThumbnailCount);
-    // Read and validate gallery.json with thumbnails
-    const galleryJsonPath = path.resolve(galleryPath, 'gallery.json');
-    const galleryContent = readFileSync(galleryJsonPath, 'utf8');
-    const galleryData = JSON.parse(galleryContent);
-    const validatedData = GalleryDataSchema.parse(galleryData);
-    // Validate all images have thumbnails
-    for (const image of validatedData.sections[0].images) {
-        expect(() => MediaFileWithThumbnailSchema.parse(image)).not.toThrow();
-    }
-    return validatedData;
-}
-function validateBuildOutput(testPath, galleryPath) {
-    // Check that index.html exists
-    const indexPath = path.resolve(testPath, 'index.html');
-    expect(existsSync(indexPath)).toBe(true);
-    // Check that gallery files still exist
-    const galleryJsonPath = path.resolve(galleryPath, 'gallery.json');
-    const galleryFiles = readdirSync(galleryPath);
-    expect(galleryFiles).toContain('thumbnails');
-    expect(galleryFiles).toContain('gallery.json');
-    // Validate gallery.json is still valid
-    const galleryContent = readFileSync(galleryJsonPath, 'utf8');
-    const galleryData = JSON.parse(galleryContent);
-    expect(() => GalleryDataSchema.parse(galleryData)).not.toThrow();
-}
-describe('Single-folder gallery', () => {
-    beforeAll(() => {
-        if (existsSync(singleTestPath)) {
-            rmSync(singleTestPath, { recursive: true, force: true });
-        }
-        copySync(singleFixturePath, singleTestPath);
-    });
-    afterAll(() => {
-        if (existsSync(singleTestPath)) {
-            rmSync(singleTestPath, { recursive: true, force: true });
-        }
-    });
-    describe('init command', () => {
-        test('should create gallery.json with correct structure and content', () => {
-            const galleryPath = path.resolve(singleTestPath, 'gallery');
-            // Run init command
-            execSync(`${tsxPath} ${cliPath} init --path ${singleTestPath}`);
-            // Validate gallery structure
-            validateGalleryStructure(galleryPath, 3, 0);
-        });
-    });
-    describe('thumbnails command', () => {
-        test('should create thumbnails for all images and update gallery.json', () => {
-            const galleryPath = path.resolve(singleTestPath, 'gallery');
-            // Run thumbnails command (init should have been run by previous test)
-            execSync(`${tsxPath} ${cliPath} thumbnails --path ${singleTestPath}`);
-            // Validate thumbnails using helper
-            validateThumbnails(galleryPath, 3);
-        });
-    });
-    describe('build command', () => {
-        test('should create static HTML files and gallery assets', () => {
-            const galleryPath = path.resolve(singleTestPath, 'gallery');
-            // Run build command (init and thumbnails should have been run by previous tests)
-            execSync(`${tsxPath} ${cliPath} build --path ${singleTestPath}`);
-            // Validate build output using helper
-            validateBuildOutput(singleTestPath, galleryPath);
-        });
-    });
-});
-describe('Multi-folder gallery', () => {
-    beforeAll(() => {
-        if (existsSync(multiTestPath)) {
-            rmSync(multiTestPath, { recursive: true, force: true });
-        }
-        copySync(multiFixturePath, multiTestPath);
-    });
-    afterAll(() => {
-        if (existsSync(multiTestPath)) {
-            rmSync(multiTestPath, { recursive: true, force: true });
-        }
-    });
-    describe('init command with recursive option', () => {
-        test('should create gallery.json files with subgalleries for multi-folder structure', () => {
-            // Run init command with recursive option
-            execSync(`${tsxPath} ${cliPath} init --path ${multiTestPath} -r`);
-            // Validate main gallery (3 root images + 2 subgalleries)
-            const mainGalleryPath = path.resolve(multiTestPath, 'gallery');
-            const mainValidatedData = validateGalleryStructure(mainGalleryPath, 3, 2);
-            // Check subgalleries metadata
-            expect(mainValidatedData.subGalleries.galleries).toHaveLength(2);
-            const subGalleryTitles = mainValidatedData.subGalleries.galleries.map((sg) => sg.title);
-            expect(subGalleryTitles).toContain('First');
-            expect(subGalleryTitles).toContain('Second');
-            // Validate first subgallery (2 images)
-            const firstGalleryPath = path.resolve(multiTestPath, 'first', 'gallery');
-            validateGalleryStructure(firstGalleryPath, 2, 0);
-            // Validate second subgallery (2 images)
-            const secondGalleryPath = path.resolve(multiTestPath, 'second', 'gallery');
-            validateGalleryStructure(secondGalleryPath, 2, 0);
-        });
-    });
-    describe('thumbnails command with recursive option', () => {
-        test('should create thumbnails for all galleries recursively', () => {
-            // Run thumbnails command with recursive option
-            execSync(`${tsxPath} ${cliPath} thumbnails --path ${multiTestPath} -r`);
-            // Validate thumbnails for main gallery
-            const mainGalleryPath = path.resolve(multiTestPath, 'gallery');
-            validateThumbnails(mainGalleryPath, 3);
-            // Validate thumbnails for first subgallery
-            const firstGalleryPath = path.resolve(multiTestPath, 'first', 'gallery');
-            validateThumbnails(firstGalleryPath, 2);
-            // Validate thumbnails for second subgallery
-            const secondGalleryPath = path.resolve(multiTestPath, 'second', 'gallery');
-            validateThumbnails(secondGalleryPath, 2);
-        });
-    });
-    describe('build command with recursive option', () => {
-        test('should build static files for all galleries recursively', () => {
-            // Run build command with recursive option
-            execSync(`${tsxPath} ${cliPath} build --path ${multiTestPath} -r`);
-            // Validate build output for main gallery
-            const mainGalleryPath = path.resolve(multiTestPath, 'gallery');
-            validateBuildOutput(multiTestPath, mainGalleryPath);
-            // Validate build output for subgalleries
-            const firstGalleryPath = path.resolve(multiTestPath, 'first', 'gallery');
-            const firstTestPath = path.resolve(multiTestPath, 'first');
-            validateBuildOutput(firstTestPath, firstGalleryPath);
-            const secondGalleryPath = path.resolve(multiTestPath, 'second', 'gallery');
-            const secondTestPath = path.resolve(multiTestPath, 'second');
-            validateBuildOutput(secondTestPath, secondGalleryPath);
-        });
-    });
-});

package/src/index.ts

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-
-import process from 'node:process';
-
-import { Command } from 'commander';
-
-import { build } from './modules/build';
-import { init } from './modules/init';
-import { thumbnails } from './modules/thumbnails';
-
-const program = new Command();
-
-program.name('gallery').description('Simple Photo Gallery CLI').version('0.0.1');
-
-program
-  .command('init')
-  .description('Initialize a gallery by scaning a folder for images and videos')
-  .option(
-    '-p, --path <path>',
-    'Path where the gallery should be initialized. Default: current working directory',
-    process.cwd(),
-  )
-  .option('-o, --output <path>', 'Output directory for the gallery.json file', '')
-  .option('-r, --recursive', 'Scan subdirectories recursively', false)
-  .action(init);
-
-program
-  .command('thumbnails')
-  .description('Create thumbnails for all media files in the gallery')
-  .option(
-    '-p, --path <path>',
-    'Path to the folder containing the gallery.json file. Default: current working directory',
-    process.cwd(),
-  )
-  .option('-s, --size <size>', 'Thumbnail height in pixels', '200')
-  .option('-r, --recursive', 'Scan subdirectories recursively', false)
-  .action(thumbnails);
-
-program
-  .command('build')
-  .description('Build the HTML gallery in the specified directory')
-  .option(
-    '-p, --path <path>',
-    'Path to the folder containing the gallery.json file. Default: current working directory',
-    process.cwd(),
-  )
-  .option('-r, --recursive', 'Scan subdirectories recursively', false)
-  .action(build);
-
-program.parse();

package/src/modules/build/index.ts

@@ -1,68 +0,0 @@
-import { execSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-
-import { findGalleries } from '../../utils';
-
-import type { BuildOptions } from './types';
-
-function buildGallery(galleryDir: string, templateDir: string) {
-  // Make sure the gallery.json file exists
-  const galleryJsonPath = path.join(galleryDir, 'gallery', 'gallery.json');
-  if (!fs.existsSync(galleryJsonPath)) {
-    console.log(`No gallery/gallery.json found in ${galleryDir}`);
-    return;
-  }
-
-  // Build the template
-  const originalEnv = { ...process.env };
-  try {
-    // Set the environment variable for the gallery.json path that will be used by the template
-    process.env.GALLERY_JSON_PATH = galleryJsonPath;
-    process.env.GALLERY_OUTPUT_DIR = path.join(galleryDir, 'gallery');
-
-    execSync('yarn build', { cwd: templateDir, stdio: 'inherit' });
-  } catch (error) {
-    console.error(error);
-    console.error(`Build failed for ${galleryDir}`);
-    return;
-  } finally {
-    // Restore original environment and gallery.json
-    process.env = originalEnv;
-  }
-
-  // Copy the build output to the output directory
-  const outputDir = path.join(galleryDir, 'gallery');
-  const buildDir = path.join(outputDir, '_build');
-  fs.cpSync(buildDir, outputDir, { recursive: true });
-
-  // Move the index.html to the gallery directory
-  fs.copyFileSync(path.join(outputDir, 'index.html'), path.join(galleryDir, 'index.html'));
-  fs.rmSync(path.join(outputDir, 'index.html'));
-
-  // Clean up the _build directory
-  console.log('Cleaning up build directory...');
-  fs.rmSync(buildDir, { recursive: true, force: true });
-}
-
-export async function build(options: BuildOptions): Promise<void> {
-  // Get the template directory
-  // Resolve the theme-modern package directory
-  const themePath = await import.meta.resolve('@simple-photo-gallery/theme-modern/package.json');
-  const themeDir = path.dirname(new URL(themePath).pathname);
-
-  // 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
-  for (const dir of galleryDirs) {
-    buildGallery(path.resolve(dir), themeDir);
-  }
-}

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

@@ -1,4 +0,0 @@
-export interface BuildOptions {
-  path: string;
-  recursive: boolean;
-}

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

@@ -1,9 +0,0 @@
-import path from 'node:path';
-
-// __dirname workaround for ESM modules
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
-
-// Helper function to resolve paths relative to current file
-export const resolveFromCurrentDir = (...segments: string[]): string => {
-  return path.resolve(__dirname, ...segments);
-};

package/src/modules/init/const/index.ts

@@ -1,5 +0,0 @@
-// Image extensions
-export const IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff', '.tif', '.svg']);
-
-// Video extensions
-export const VIDEO_EXTENSIONS = new Set(['.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm', '.mkv', '.m4v', '.3gp']);

package/src/modules/init/index.ts

@@ -1,193 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-import { capitalizeTitle, getImageMetadata, getVideoDimensions, isMediaFile } from './utils';
-
-import type { ProcessDirectoryResult, ScanOptions, SubGallery } from './types';
-import type { MediaFile } from '../../types';
-
-async function scanDirectory(dirPath: string): Promise<MediaFile[]> {
-  const mediaFiles: MediaFile[] = [];
-
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        const fullPath = path.join(dirPath, entry.name);
-        const mediaType = isMediaFile(entry.name);
-        if (mediaType) {
-          console.log(`Processing ${mediaType}: ${entry.name}`);
-
-          let metadata: { width: number; height: number; description?: string } = { width: 0, height: 0 };
-
-          try {
-            if (mediaType === 'image') {
-              metadata = await getImageMetadata(fullPath);
-            } else if (mediaType === 'video') {
-              try {
-                const videoDimensions = await getVideoDimensions(fullPath);
-                metadata = { ...videoDimensions };
-              } catch (videoError: unknown) {
-                if (
-                  typeof videoError === 'object' &&
-                  videoError !== null &&
-                  'message' in videoError &&
-                  typeof (videoError as { message: string }).message === 'string' &&
-                  ((videoError as { message: string }).message.includes('ffprobe') ||
-                    (videoError as { message: string }).message.includes('ffmpeg'))
-                ) {
-                  console.error(
-                    `Error: ffprobe (part of ffmpeg) is required to process videos. Please install ffmpeg and ensure it is available in your PATH. Skipping video: ${entry.name}`,
-                  );
-                } else {
-                  console.error(`Error processing video ${entry.name}:`, videoError);
-                }
-                continue; // Skip this file
-              }
-            }
-          } catch (mediaError) {
-            console.error(`Error processing file ${entry.name}:`, mediaError);
-            continue; // Skip this file
-          }
-
-          const mediaFile: MediaFile = {
-            type: mediaType,
-            path: fullPath,
-            width: metadata.width,
-            height: metadata.height,
-          };
-
-          if (metadata.description) {
-            mediaFile.alt = metadata.description;
-          }
-
-          mediaFiles.push(mediaFile);
-        }
-      }
-    }
-  } catch (error) {
-    console.error(`Error scanning directory ${dirPath}:`, error);
-  }
-
-  return mediaFiles;
-}
-
-async function createGalleryJson(
-  mediaFiles: MediaFile[],
-  galleryJsonPath: string,
-  subGalleries: SubGallery[] = [],
-): Promise<void> {
-  const galleryDir = path.dirname(galleryJsonPath);
-
-  // Convert media file paths to be relative to gallery.json
-  const relativeMediaFiles = mediaFiles.map((file) => ({
-    ...file,
-    path: path.relative(galleryDir, file.path),
-  }));
-
-  // Convert subGallery header image paths to be relative to gallery.json
-  const relativeSubGalleries = subGalleries.map((subGallery) => ({
-    ...subGallery,
-    headerImage: subGallery.headerImage ? path.relative(galleryDir, subGallery.headerImage) : '',
-  }));
-
-  const galleryData = {
-    title: 'My Gallery',
-    description: 'My gallery with fantastic photos.',
-    headerImage: relativeMediaFiles[0]?.path || '',
-    metadata: { ogUrl: '' },
-    sections: [
-      {
-        images: relativeMediaFiles,
-      },
-    ],
-    subGalleries: {
-      title: 'Sub Galleries',
-      galleries: relativeSubGalleries,
-    },
-  };
-
-  await fs.writeFile(galleryJsonPath, JSON.stringify(galleryData, null, 2));
-}
-
-async function processDirectory(dirPath: string, options: ScanOptions): Promise<ProcessDirectoryResult> {
-  let totalFiles = 0;
-  const subGalleries: SubGallery[] = [];
-
-  // Scan current directory for media files
-  const mediaFiles = await scanDirectory(dirPath);
-  totalFiles += mediaFiles.length;
-
-  // Process subdirectories only if recursive mode is enabled
-  if (options.recursive) {
-    try {
-      const entries = await fs.readdir(dirPath, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name !== 'gallery') {
-          const subDirPath = path.join(dirPath, entry.name);
-          const result = await processDirectory(subDirPath, options);
-          totalFiles += result.totalFiles;
-
-          // If the subdirectory had media files, add it as a subGallery
-          if (result.subGallery) {
-            subGalleries.push(result.subGallery);
-          }
-        }
-      }
-    } catch (error) {
-      console.error(`Error reading directory ${dirPath}:`, error);
-    }
-  }
-
-  // Create gallery.json if there are media files or subGalleries
-  if (mediaFiles.length > 0 || subGalleries.length > 0) {
-    const outputPath = options.output
-      ? path.resolve(options.output, path.relative(path.resolve(options.path), dirPath), 'gallery')
-      : path.join(dirPath, 'gallery');
-    const galleryJsonPath = path.join(outputPath, 'gallery.json');
-
-    // Create output directory
-    await fs.mkdir(outputPath, { recursive: true });
-
-    // Create gallery.json for this directory
-    await createGalleryJson(mediaFiles, galleryJsonPath, subGalleries);
-
-    console.log(
-      `Gallery JSON created at: ${galleryJsonPath} (${mediaFiles.length} files, ${subGalleries.length} subgalleries)`,
-    );
-  }
-
-  // Return result with suGgallery info if this directory has media files
-  const result: ProcessDirectoryResult = { totalFiles };
-
-  if (mediaFiles.length > 0 || subGalleries.length > 0) {
-    const dirName = path.basename(dirPath);
-    result.subGallery = {
-      title: capitalizeTitle(dirName),
-      headerImage: mediaFiles[0]?.path || '',
-      path: path.join('..', dirName),
-    };
-  }
-
-  return result;
-}
-
-export async function init(options: ScanOptions): Promise<void> {
-  const scanPath = path.resolve(options.path);
-
-  console.log(`Scanning directory: ${scanPath}`);
-  console.log(`Recursive: ${options.recursive}`);
-
-  try {
-    // Ensure scan path exists
-    await fs.access(scanPath);
-
-    // Process the directory tree with the specified recursion setting
-    const result = await processDirectory(scanPath, options);
-    console.log(`Total files processed: ${result.totalFiles}`);
-  } catch (error) {
-    throw new Error(`Error during scan: ${error}`);
-  }
-}

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

@@ -1,16 +0,0 @@
-export interface ScanOptions {
-  path: string;
-  output: string;
-  recursive: boolean;
-}
-
-export interface SubGallery {
-  title: string;
-  headerImage: string;
-  path: string;
-}
-
-export interface ProcessDirectoryResult {
-  totalFiles: number;
-  subGallery?: SubGallery;
-}

package/src/modules/init/types/node-ffprobe.d.ts

@@ -1,17 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-declare module 'node-ffprobe' {
-  export interface Stream {
-    codec_type: string;
-    width?: number;
-    height?: number;
-    [key: string]: any;
-  }
-
-  export interface ProbeResult {
-    streams: Stream[];
-    format: any;
-  }
-
-  export default function ffprobe(filePath: string): Promise<ProbeResult>;
-}

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

@@ -1,98 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-import exifReader from 'exif-reader';
-import ffprobe from 'node-ffprobe';
-import sharp from 'sharp';
-
-import { IMAGE_EXTENSIONS, VIDEO_EXTENSIONS } from '../const';
-
-export async function getImageMetadata(filePath: string): Promise<{ width: number; height: number; description?: string }> {
-  try {
-    const metadata = await sharp(filePath).metadata();
-    let description: string | undefined;
-
-    // Extract description from EXIF data
-    if (metadata.exif) {
-      try {
-        const exifData = exifReader(metadata.exif);
-        if (exifData.Image?.ImageDescription) {
-          description = exifData.Image.ImageDescription;
-        } else if (exifData.Image?.Description) {
-          description = exifData.Image.Description.toString();
-        }
-      } catch {
-        // EXIF parsing failed, but that's OK
-      }
-    }
-
-    return {
-      width: metadata.width || 0,
-      height: metadata.height || 0,
-      description,
-    };
-  } catch (error) {
-    console.warn(`Warning: Could not get metadata for image ${filePath}:`, error);
-    return { width: 0, height: 0 };
-  }
-}
-
-export async function getVideoDimensions(filePath: string): Promise<{ width: number; height: number }> {
-  try {
-    const data = await ffprobe(filePath);
-    const videoStream = data.streams.find((stream) => stream.codec_type === 'video');
-    if (videoStream) {
-      return {
-        width: videoStream.width || 0,
-        height: videoStream.height || 0,
-      };
-    }
-    return { width: 0, height: 0 };
-  } catch (error) {
-    console.warn(`Warning: Could not get dimensions for video ${filePath}:`, error);
-    return { width: 0, height: 0 };
-  }
-}
-
-export function isMediaFile(fileName: string): 'image' | 'video' | null {
-  const ext = path.extname(fileName).toLowerCase();
-  if (IMAGE_EXTENSIONS.has(ext)) return 'image';
-  if (VIDEO_EXTENSIONS.has(ext)) return 'video';
-  return null;
-}
-
-export function capitalizeTitle(folderName: string): string {
-  return folderName
-    .replace('-', ' ')
-    .replace('_', ' ')
-    .split(' ')
-    .map((word: string) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(' ');
-}
-
-export async function hasMediaFiles(dirPath: string): Promise<boolean> {
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-
-    // Check for media files in current directory
-    for (const entry of entries) {
-      if (entry.isFile() && isMediaFile(entry.name)) {
-        return true;
-      }
-    }
-
-    // Check subdirectories recursively
-    for (const entry of entries) {
-      if (entry.isDirectory() && entry.name !== 'gallery') {
-        const subDirPath = path.join(dirPath, entry.name);
-        if (await hasMediaFiles(subDirPath)) {
-          return true;
-        }
-      }
-    }
-  } catch (error) {
-    console.error(`Error checking for media files in ${dirPath}:`, error);
-  }
-
-  return false;
-}