simple-photo-gallery 0.0.1

package/README.md

@@ -0,0 +1,349 @@
+# Simple Photo Gallery CLI
+
+A command-line tool for creating beautiful photo galleries from your image and video collections. This CLI helps you scan directories, generate thumbnails, and set up Astro-based gallery websites.
+
+## Features
+
+- 📸 **Media Scanning**: Automatically scan directories for images and videos
+- 🖼️ **Thumbnail Generation**: Create optimized thumbnails for fast loading
+- 🎥 **Video Support**: Handle video files with ffmpeg integration
+- 📱 **Responsive Design**: Generate galleries that work on all devices
+- ⚡ **Fast Performance**: Optimized thumbnails and lazy loading
+- 🔧 **Astro Integration**: Seamless setup with Astro static site generator
+
+## Installation
+
+### Prerequisites
+
+- Node.js 18+
+- npm or yarn
+- ffmpeg (for video processing)
+
+### Install ffmpeg
+
+**macOS:**
+
+```bash
+brew install ffmpeg
+```
+
+**Ubuntu/Debian:**
+
+```bash
+sudo apt update
+sudo apt install ffmpeg
+```
+
+**Windows:**
+Download from [ffmpeg.org](https://ffmpeg.org/download.html)
+
+### Install the CLI
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd simple-photo-gallery-public/cli
+
+# Install dependencies
+npm install
+
+# Build the CLI
+npm run build
+
+# Link globally (optional)
+npm link
+```
+
+## Commands
+
+### `gallery init`
+
+Scan a directory for images and videos to create a `gallery.json` file.
+
+```bash
+gallery init [options]
+```
+
+**Options:**
+
+- `-p, --path <path>` - Path to scan for media files (default: current directory)
+- `-o, --output <path>` - Output directory for gallery.json
+- `-r, --recursive` - Scan subdirectories recursively
+
+**Examples:**
+
+```bash
+# Scan current directory
+gallery init
+
+# Scan specific directory
+gallery init --path /path/to/photos
+
+# Scan recursively
+gallery init --path /path/to/photos --recursive
+
+# Specify output directory
+gallery init --path /path/to/photos --output /path/to/output
+```
+
+### `gallery thumbnails`
+
+Generate thumbnails for all media files in the gallery.
+
+```bash
+gallery thumbnails [options]
+```
+
+**Options:**
+
+- `-p, --path <path>` - Path containing .simple-photo-gallery folder (default: current directory)
+- `-s, --size <size>` - Thumbnail height in pixels (default: 200)
+
+**Examples:**
+
+```bash
+# Generate thumbnails with default size
+gallery thumbnails
+
+# Generate thumbnails with custom size
+gallery thumbnails --size 300
+
+# Specify gallery path
+gallery thumbnails --path /path/to/gallery
+```
+
+### `gallery build`
+
+Configure Astro template to work with external image directories and build galleries.
+
+```bash
+gallery build [options]
+```
+
+**Options:**
+
+- `-i, --images-path <path>` - Path to images directory (required)
+- `-r, --recursive` - Scan subdirectories recursively for gallery/gallery.json files
+
+**Examples:**
+
+```bash
+# Setup template for a single gallery directory
+gallery build --images-path ../my-photos
+
+# Setup template recursively for multiple gallery directories
+gallery build --images-path ../my-photos --recursive
+```
+
+## Complete Workflow Examples
+
+### Basic Gallery Creation
+
+1. **Prepare your photos directory:**
+
+```bash
+mkdir my-photos
+# Copy your photos and videos to my-photos/
+```
+
+2. **Scan for media files:**
+
+```bash
+cd my-photos
+gallery init
+```
+
+3. **Generate thumbnails:**
+
+```bash
+gallery thumbnails --size 250
+```
+
+4. **Set up Astro template:**
+
+```bash
+cd ../template
+gallery build
+```
+
+5. **Build and serve:**
+
+```bash
+npm run dev
+```
+
+### Advanced Workflow with Multiple Sections
+
+1. **Organize photos in subdirectories:**
+
+```
+my-photos/
+├── vacation/
+│   ├── beach.jpg
+│   ├── mountains.jpg
+│   └── sunset.mp4
+├── family/
+│   ├── birthday.jpg
+│   └── christmas.jpg
+└── events/
+    ├── wedding.jpg
+    └── graduation.jpg
+```
+
+2. **Scan with recursive option:**
+
+```bash
+cd my-photos
+gallery init --recursive
+```
+
+3. **Edit gallery.json to create sections:**
+
+```json
+{
+  "title": "My Photo Collection",
+  "description": "A collection of my favorite moments",
+  "headerImage": "vacation/beach.jpg",
+  "metadata": { "ogUrl": "" },
+  "sections": [
+    {
+      "title": "Vacation Memories",
+      "description": "Amazing trips and adventures",
+      "images": [
+        // vacation images will be here
+      ]
+    },
+    {
+      "title": "Family Moments",
+      "description": "Precious family memories",
+      "images": [
+        // family images will be here
+      ]
+    },
+    {
+      "title": "Special Events",
+      "description": "Important life events",
+      "images": [
+        // events images will be here
+      ]
+    }
+  ]
+}
+```
+
+4. **Generate thumbnails:**
+
+```bash
+gallery thumbnails --size 300 --recursive
+```
+
+5. **Set up and build:**
+
+```bash
+cd ../template
+gallery build --recursive
+```
+
+## File Structure
+
+After running the CLI, your project will have this structure:
+
+```
+my-photos/
+├── .simple-photo-gallery/
+│   ├── gallery.json          # Gallery metadata and file list
+│   └── thumbnails/           # Generated thumbnails
+│       ├── image1.jpg
+│       ├── image2.jpg
+│       └── video1.jpg
+├── photo1.jpg
+├── photo2.jpg
+└── video1.mp4
+
+template/
+├── astro.config.ts           # Modified Astro config
+├── gallery.json              # Copied gallery data
+└── ... (other Astro files)
+```
+
+## Supported Media Formats
+
+**Images:**
+
+- JPEG (.jpg, .jpeg)
+- PNG (.png)
+- WebP (.webp)
+- GIF (.gif)
+- TIFF (.tiff, .tif)
+
+**Videos:**
+
+- MP4 (.mp4)
+- MOV (.mov)
+- AVI (.avi)
+- WebM (.webm)
+- MKV (.mkv)
+
+_Note: Video processing requires ffmpeg to be installed and available in your PATH._
+
+## Troubleshooting
+
+### Common Issues
+
+**"ffprobe not found" error:**
+
+- Install ffmpeg: `brew install ffmpeg` (macOS) or `sudo apt install ffmpeg` (Ubuntu)
+- Ensure ffmpeg is in your PATH
+
+**"Gallery not found" error:**
+
+- Run `gallery init` first to create the gallery.json file
+- Check that the path to .simple-photo-gallery folder is correct
+
+**Thumbnail generation fails:**
+
+- Check file permissions
+- Ensure sufficient disk space
+- Verify media files are not corrupted
+
+### Getting Help
+
+- Check that all required dependencies are installed
+- Verify file paths are correct and accessible
+- Ensure ffmpeg is properly installed for video processing
+- Review the generated gallery.json file for any issues
+
+## Development
+
+### Building from Source
+
+```bash
+# Install dependencies
+npm install
+
+# Build the CLI
+npm run build
+
+# Run in development mode
+npm run gallery
+```
+
+### Code Quality
+
+```bash
+# Check TypeScript
+npm run check
+
+# Lint code
+npm run lint
+
+# Fix linting issues
+npm run lint:fix
+
+# Format code
+npm run format
+```
+
+## License
+
+MIT License - see LICENSE file for details.

package/dist/src/index.js

@@ -0,0 +1,29 @@
+#!/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/dist/src/modules/build/index.js

@@ -0,0 +1,56 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { resolveFromCurrentDir } from './utils';
+import { findGalleries } from '../../utils';
+function buildGallery(galleryDir, templateDir) {
+    // 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('npm run 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) {
+    // Get the template directory
+    const templateDir = path.join(resolveFromCurrentDir('../../../../../'), 'template');
+    // 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(dir, templateDir);
+    }
+}

package/dist/src/modules/build/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/build/utils/index.js

@@ -0,0 +1,7 @@
+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) => {
+    return path.resolve(__dirname, ...segments);
+};

package/dist/src/modules/init/const/index.js

@@ -0,0 +1,4 @@
+// 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/dist/src/modules/init/index.js

@@ -0,0 +1,156 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { capitalizeTitle, getImageMetadata, getVideoDimensions, isMediaFile } from './utils';
+async function scanDirectory(dirPath) {
+    const mediaFiles = [];
+    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: 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) {
+                                if (typeof videoError === 'object' &&
+                                    videoError !== null &&
+                                    'message' in videoError &&
+                                    typeof videoError.message === 'string' &&
+                                    (videoError.message.includes('ffprobe') ||
+                                        videoError.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 = {
+                        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, galleryJsonPath, subGalleries = []) {
+    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, options) {
+    let totalFiles = 0;
+    const subGalleries = [];
+    // 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 = { 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) {
+    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/dist/src/modules/init/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/init/utils/index.js

@@ -0,0 +1,93 @@
+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) {
+    try {
+        const metadata = await sharp(filePath).metadata();
+        let description;
+        // 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) {
+    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) {
+    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) {
+    return folderName
+        .replace('-', ' ')
+        .replace('_', ' ')
+        .split(' ')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+export async function hasMediaFiles(dirPath) {
+    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;
+}