simple-photo-gallery 0.0.1

package/dist/src/modules/thumbnails/index.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createImageThumbnail, createVideoThumbnail } from './utils';
+import { GalleryDataSchema } from '../../types';
+import { findGalleries } from '../../utils';
+const processGallery = async (galleryDir, size) => {
+    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, galleryDir, thumbnailsPath, size) {
+    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;
+        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,
+            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) {
+    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/dist/src/modules/thumbnails/types/index.js

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

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

@@ -0,0 +1,127 @@
+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';
+// Check if ffmpeg is available
+async function checkFfmpegAvailability() {
+    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, outputPath, width, height) {
+    await image.resize(width, height, { withoutEnlargement: true }).jpeg({ quality: 90 }).toFile(outputPath);
+}
+export async function createImageThumbnail(inputPath, outputPath, height) {
+    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, outputPath, height) {
+    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) => {
+                // 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) => {
+                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) => {
+                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.message === 'string' &&
+            (error.message.includes('ffmpeg') ||
+                error.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/dist/src/types/index.js

@@ -0,0 +1,35 @@
+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) }),
+});

package/dist/src/utils/index.js

@@ -0,0 +1,34 @@
+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, recursive) => {
+    const galleryDirs = [];
+    // 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;
+};

package/dist/tests/cli.test.js

@@ -0,0 +1,170 @@
+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/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "simple-photo-gallery",
+  "version": "0.0.1",
+  "description": "Simple Photo Gallery CLI",
+  "license": "MIT",
+  "author": "Vladimir Haltakov, Tomasz Rusin",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SimplePhotoGallery/core"
+  },
+  "homepage": "https://simple.photo",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "bin": {
+    "gallery": "./dist/index.js"
+  },
+  "scripts": {
+    "gallery": "tsx src/index.ts",
+    "build": "tsc",
+    "check": "tsc --noEmit && eslint . && prettier --check .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:fix": "prettier --write .",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@simple-photo-gallery/theme-modern": "0.0.1",
+    "commander": "^12.0.0",
+    "exif-reader": "^2.0.1",
+    "node-ffprobe": "^3.0.0",
+    "sharp": "^0.33.0",
+    "zod": "^4.0.14"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.30.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "eslint": "^9.30.1",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-import-resolver-alias": "^1.1.2",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-prettier": "^5.5.1",
+    "eslint-plugin-unicorn": "^59.0.1",
+    "fs-extra": "^11.3.0",
+    "jest": "^30.0.5",
+    "prettier": "^3.4.2",
+    "ts-jest": "^29.4.1",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.38.0"
+  },
+  "type": "module"
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+#!/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

@@ -0,0 +1,68 @@
+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

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

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,5 @@
+// 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']);