simple-photo-gallery 0.0.8 → 2.0.1

package/dist/index.js

@@ -1,23 +1,97 @@
 #!/usr/bin/env node
-import process from 'process';
+import process2 from 'process';
 import { Command } from 'commander';
+import { LogLevels, createConsola } from 'consola';
 import { execSync, spawn } from 'child_process';
-import fs2, { promises } from 'fs';
+import fs4, { promises } from 'fs';
 import path4 from 'path';
+import { Buffer } from 'buffer';
+import sharp from 'sharp';
+import { z } from 'zod';
 import exifReader from 'exif-reader';
 import ffprobe from 'node-ffprobe';
-import sharp2 from 'sharp';
-import { z } from 'zod';
 
-var findGalleries = (basePath, recursive) => {
+path4.dirname(new URL(import.meta.url).pathname);
+async function createGallerySocialMediaCardImage(headerPhotoPath, title, ouputPath, ui) {
+  ui.start(`Creating social media card image`);
+  const resizedImageBuffer = await sharp(headerPhotoPath).resize(1200, 631, { fit: "cover" }).jpeg({ quality: 90 }).toBuffer();
+  const outputPath = ouputPath;
+  await sharp(resizedImageBuffer).toFile(outputPath);
+  const svgText = `
+    <svg width="1200" height="631" xmlns="http://www.w3.org/2000/svg">
+      <defs>
+        <style>
+          .title { font-family: Arial, sans-serif; font-size: 96px; font-weight: bold; fill: white; text-anchor: middle; }
+          .description { font-family: Arial, sans-serif; font-size: 48px; fill: white; text-anchor: middle; }
+        </style>
+      </defs>
+      <text x="600" y="250" class="title">${title}</text>
+    </svg>
+  `;
+  const finalImageBuffer = await sharp(resizedImageBuffer).composite([{ input: Buffer.from(svgText), top: 0, left: 0 }]).jpeg({ quality: 90 }).toBuffer();
+  await sharp(finalImageBuffer).toFile(outputPath);
+  ui.success(`Created social media card image successfully`);
+}
+var ThumbnailSchema = z.object({
+  path: z.string(),
+  pathRetina: z.string(),
+  width: z.number(),
+  height: z.number()
+});
+var MediaFileSchema = z.object({
+  type: z.enum(["image", "video"]),
+  path: z.string(),
+  alt: z.string().optional(),
+  width: z.number(),
+  height: z.number(),
+  thumbnail: ThumbnailSchema.optional(),
+  lastMediaTimestamp: z.string().optional()
+});
+var GallerySectionSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  images: z.array(MediaFileSchema)
+});
+var SubGallerySchema = z.object({
+  title: z.string(),
+  headerImage: z.string(),
+  path: z.string()
+});
+var GalleryDataSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  url: z.string().optional(),
+  headerImage: z.string(),
+  thumbnailSize: z.number().optional(),
+  metadata: z.object({
+    image: z.string().optional(),
+    imageWidth: z.number().optional(),
+    imageHeight: z.number().optional(),
+    ogUrl: z.string().optional(),
+    ogType: z.string().optional(),
+    ogSiteName: z.string().optional(),
+    twitterSite: z.string().optional(),
+    twitterCreator: z.string().optional(),
+    author: z.string().optional(),
+    keywords: z.string().optional(),
+    canonicalUrl: z.string().optional(),
+    language: z.string().optional(),
+    robots: z.string().optional()
+  }),
+  galleryOutputPath: z.string().optional(),
+  mediaBaseUrl: z.string().optional(),
+  sections: z.array(GallerySectionSchema),
+  subGalleries: z.object({ title: z.string(), galleries: z.array(SubGallerySchema) })
+});
+function findGalleries(basePath, recursive) {
   const galleryDirs = [];
   const galleryJsonPath = path4.join(basePath, "gallery", "gallery.json");
-  if (fs2.existsSync(galleryJsonPath)) {
+  if (fs4.existsSync(galleryJsonPath)) {
     galleryDirs.push(basePath);
   }
   if (recursive) {
     try {
-      const entries = fs2.readdirSync(basePath, { withFileTypes: true });
+      const entries = fs4.readdirSync(basePath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && entry.name !== "gallery") {
           const subPath = path4.join(basePath, entry.name);
@@ -29,95 +103,408 @@ var findGalleries = (basePath, recursive) => {
     }
   }
   return galleryDirs;
-};
+}
+function handleFileProcessingError(error, filename, ui) {
+  if (error instanceof Error && (error.message.includes("ffprobe") || error.message.includes("ffmpeg"))) {
+    ui.warn(
+      `Error processing ${filename}: ffprobe (part of ffmpeg) is required to process videos. Please install ffmpeg and ensure it is available in your PATH`
+    );
+  } else if (error instanceof Error && error.message.includes("unsupported image format")) {
+    ui.warn(`Error processing ${filename}: unsupported image format`);
+  } else {
+    ui.warn(`Error processing ${filename}`);
+  }
+  ui.debug(error);
+}
+async function getFileMtime(filePath) {
+  const stats = await promises.stat(filePath);
+  return stats.mtime;
+}
+async function resizeAndSaveThumbnail(image, outputPath, width, height) {
+  await image.resize(width, height, { withoutEnlargement: true }).jpeg({ quality: 90 }).toFile(outputPath);
+}
+async function getImageDescription(metadata) {
+  let description;
+  if (metadata.exif) {
+    try {
+      const exifData = exifReader(metadata.exif);
+      if (exifData.Image?.ImageDescription) {
+        description = exifData.Image.ImageDescription.toString();
+      } else if (exifData.Image?.Description) {
+        description = exifData.Image.Description.toString();
+      }
+    } catch {
+    }
+  }
+  return description;
+}
+async function createImageThumbnails(image, metadata, outputPath, outputPathRetina, height) {
+  const originalWidth = metadata.width || 0;
+  const originalHeight = metadata.height || 0;
+  if (originalWidth === 0 || originalHeight === 0) {
+    throw new Error("Invalid image dimensions");
+  }
+  const aspectRatio = originalWidth / originalHeight;
+  const width = Math.round(height * aspectRatio);
+  await resizeAndSaveThumbnail(image, outputPath, width, height);
+  await resizeAndSaveThumbnail(image, outputPathRetina, width * 2, height * 2);
+  return { width, height };
+}
+async function getVideoDimensions(filePath) {
+  const data = await ffprobe(filePath);
+  const videoStream = data.streams.find((stream) => stream.codec_type === "video");
+  if (!videoStream) {
+    throw new Error("No video stream found");
+  }
+  const dimensions = {
+    width: videoStream.width || 0,
+    height: videoStream.height || 0
+  };
+  if (dimensions.width === 0 || dimensions.height === 0) {
+    throw new Error("Invalid video dimensions");
+  }
+  return dimensions;
+}
+async function createVideoThumbnails(inputPath, videoDimensions, outputPath, outputPathRetina, height, verbose = false) {
+  const aspectRatio = videoDimensions.width / videoDimensions.height;
+  const width = Math.round(height * aspectRatio);
+  const tempFramePath = `${outputPath}.temp.png`;
+  return new Promise((resolve, reject) => {
+    const ffmpeg = spawn("ffmpeg", [
+      "-i",
+      inputPath,
+      "-vframes",
+      "1",
+      "-y",
+      "-loglevel",
+      verbose ? "error" : "quiet",
+      tempFramePath
+    ]);
+    ffmpeg.stderr.on("data", (data) => {
+      console.log(`ffmpeg: ${data.toString()}`);
+    });
+    ffmpeg.on("close", async (code) => {
+      if (code === 0) {
+        try {
+          const frameImage = sharp(tempFramePath);
+          await resizeAndSaveThumbnail(frameImage, outputPath, width, height);
+          await resizeAndSaveThumbnail(frameImage, outputPathRetina, width * 2, height * 2);
+          try {
+            await promises.unlink(tempFramePath);
+          } catch {
+          }
+          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}`));
+    });
+  });
+}
 
-// src/modules/build/index.ts
-function buildGallery(galleryDir, templateDir) {
-  const galleryJsonPath = path4.join(galleryDir, "gallery", "gallery.json");
-  if (!fs2.existsSync(galleryJsonPath)) {
-    console.log(`No gallery/gallery.json found in ${galleryDir}`);
-    return;
+// src/config/index.ts
+var DEFAULT_THUMBNAIL_SIZE = 300;
+
+// src/modules/thumbnails/index.ts
+async function processImage(imagePath, thumbnailPath, thumbnailPathRetina, thumbnailSize, lastMediaTimestamp) {
+  const fileMtime = await getFileMtime(imagePath);
+  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs4.existsSync(thumbnailPath)) {
+    return void 0;
+  }
+  const image = sharp(imagePath);
+  const metadata = await image.metadata();
+  const imageDimensions = {
+    width: metadata.width || 0,
+    height: metadata.height || 0
+  };
+  if (imageDimensions.width === 0 || imageDimensions.height === 0) {
+    throw new Error("Invalid image dimensions");
   }
-  const originalEnv = { ...process.env };
+  const description = await getImageDescription(metadata);
+  const thumbnailDimensions = await createImageThumbnails(
+    image,
+    metadata,
+    thumbnailPath,
+    thumbnailPathRetina,
+    thumbnailSize
+  );
+  return {
+    type: "image",
+    path: imagePath,
+    alt: description,
+    width: imageDimensions.width,
+    height: imageDimensions.height,
+    thumbnail: {
+      path: thumbnailPath,
+      pathRetina: thumbnailPathRetina,
+      width: thumbnailDimensions.width,
+      height: thumbnailDimensions.height
+    },
+    lastMediaTimestamp: fileMtime.toISOString()
+  };
+}
+async function processVideo(videoPath, thumbnailPath, thumbnailPathRetina, thumbnailSize, verbose, lastMediaTimestamp) {
+  const fileMtime = await getFileMtime(videoPath);
+  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs4.existsSync(thumbnailPath)) {
+    return void 0;
+  }
+  const videoDimensions = await getVideoDimensions(videoPath);
+  const thumbnailDimensions = await createVideoThumbnails(
+    videoPath,
+    videoDimensions,
+    thumbnailPath,
+    thumbnailPathRetina,
+    thumbnailSize,
+    verbose
+  );
+  return {
+    type: "video",
+    path: videoPath,
+    alt: void 0,
+    width: videoDimensions.width,
+    height: videoDimensions.height,
+    thumbnail: {
+      path: thumbnailPath,
+      pathRetina: thumbnailPathRetina,
+      width: thumbnailDimensions.width,
+      height: thumbnailDimensions.height
+    },
+    lastMediaTimestamp: fileMtime.toISOString()
+  };
+}
+async function processMediaFile(mediaFile, galleryDir, thumbnailsPath, thumbnailSize, ui) {
   try {
-    process.env.GALLERY_JSON_PATH = galleryJsonPath;
-    process.env.GALLERY_OUTPUT_DIR = path4.join(galleryDir, "gallery");
-    execSync("npx astro build", { cwd: templateDir, stdio: "inherit" });
+    const galleryJsonDir = path4.join(galleryDir, "gallery");
+    const filePath = path4.resolve(path4.join(galleryJsonDir, mediaFile.path));
+    const fileName = path4.basename(filePath);
+    const fileNameWithoutExt = path4.parse(fileName).name;
+    const thumbnailFileName = `${fileNameWithoutExt}.jpg`;
+    const thumbnailPath = path4.join(thumbnailsPath, thumbnailFileName);
+    const thumbnailPathRetina = thumbnailPath.replace(".jpg", "@2x.jpg");
+    const relativeThumbnailPath = path4.relative(galleryJsonDir, thumbnailPath);
+    const relativeThumbnailRetinaPath = path4.relative(galleryJsonDir, thumbnailPathRetina);
+    const lastMediaTimestamp = mediaFile.lastMediaTimestamp ? new Date(mediaFile.lastMediaTimestamp) : void 0;
+    const verbose = ui.level === LogLevels.debug;
+    ui.debug(`  Processing ${mediaFile.type}: ${fileName}`);
+    const updatedMediaFile = await (mediaFile.type === "image" ? processImage(filePath, thumbnailPath, thumbnailPathRetina, thumbnailSize, lastMediaTimestamp) : processVideo(filePath, thumbnailPath, thumbnailPathRetina, thumbnailSize, verbose, lastMediaTimestamp));
+    if (!updatedMediaFile) {
+      ui.debug(`  Skipping ${fileName} because it has already been processed`);
+      return mediaFile;
+    }
+    updatedMediaFile.path = mediaFile.path;
+    if (updatedMediaFile.thumbnail) {
+      updatedMediaFile.thumbnail.path = relativeThumbnailPath;
+      updatedMediaFile.thumbnail.pathRetina = relativeThumbnailRetinaPath;
+    }
+    return updatedMediaFile;
   } catch (error) {
-    console.error(error);
-    console.error(`Build failed for ${galleryDir}`);
-    return;
-  } finally {
-    process.env = originalEnv;
+    handleFileProcessingError(error, path4.basename(mediaFile.path), ui);
+    return mediaFile;
   }
-  const outputDir = path4.join(galleryDir, "gallery");
-  const buildDir = path4.join(outputDir, "_build");
-  fs2.cpSync(buildDir, outputDir, { recursive: true });
-  fs2.copyFileSync(path4.join(outputDir, "index.html"), path4.join(galleryDir, "index.html"));
-  fs2.rmSync(path4.join(outputDir, "index.html"));
-  console.log("Cleaning up build directory...");
-  fs2.rmSync(buildDir, { recursive: true, force: true });
 }
-async function build(options) {
-  const themePath = await import.meta.resolve("@simple-photo-gallery/theme-modern/package.json");
-  const themeDir = path4.dirname(new URL(themePath).pathname);
-  const galleryDirs = findGalleries(options.path, options.recursive);
-  if (galleryDirs.length === 0) {
-    console.log("No gallery/gallery.json files found.");
-    return;
+async function processGalleryThumbnails(galleryDir, ui) {
+  const galleryJsonPath = path4.join(galleryDir, "gallery", "gallery.json");
+  const thumbnailsPath = path4.join(galleryDir, "gallery", "thumbnails");
+  ui.start(`Creating thumbnails: ${galleryDir}`);
+  try {
+    fs4.mkdirSync(thumbnailsPath, { recursive: true });
+    const galleryContent = fs4.readFileSync(galleryJsonPath, "utf8");
+    const galleryData = GalleryDataSchema.parse(JSON.parse(galleryContent));
+    const thumbnailSize = galleryData.thumbnailSize || DEFAULT_THUMBNAIL_SIZE;
+    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, thumbnailSize, ui);
+      }
+      processedCount += section.images.length;
+    }
+    fs4.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+    ui.success(`Created thumbnails for ${processedCount} media files`);
+    return processedCount;
+  } catch (error) {
+    ui.error(`Error creating thumbnails for ${galleryDir}`);
+    throw error;
   }
-  for (const dir of galleryDirs) {
-    buildGallery(path4.resolve(dir), themeDir);
+}
+async function thumbnails(options, ui) {
+  try {
+    const galleryDirs = findGalleries(options.gallery, options.recursive);
+    if (galleryDirs.length === 0) {
+      ui.error("No galleries found.");
+      return;
+    }
+    let totalGalleries = 0;
+    let totalProcessed = 0;
+    for (const galleryDir of galleryDirs) {
+      const processed = await processGalleryThumbnails(galleryDir, ui);
+      if (processed > 0) {
+        ++totalGalleries;
+        totalProcessed += processed;
+      }
+    }
+    ui.box(
+      `Created thumbnails for ${totalGalleries} ${totalGalleries === 1 ? "gallery" : "galleries"} with ${totalProcessed} media ${totalProcessed === 1 ? "file" : "files"}`
+    );
+  } catch (error) {
+    ui.error("Error creating thumbnails");
+    throw error;
   }
 }
 
-// src/modules/init/const/index.ts
-var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tiff", ".tif", ".svg"]);
-var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mkv", ".m4v", ".3gp"]);
-
-// src/modules/init/utils/index.ts
-async function getImageMetadata(filePath) {
-  try {
-    const metadata = await sharp2(filePath).metadata();
-    let description;
-    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 {
+// src/modules/build/index.ts
+function checkFileIsOneFolderUp(filePath) {
+  const normalizedPath = path4.normalize(filePath);
+  const pathParts = normalizedPath.split(path4.sep);
+  return pathParts.length === 2 && pathParts[0] === "..";
+}
+function copyPhotos(galleryData, galleryDir, ui) {
+  for (const section of galleryData.sections) {
+    for (const image of section.images) {
+      if (!checkFileIsOneFolderUp(image.path)) {
+        const sourcePath = path4.join(galleryDir, "gallery", image.path);
+        const fileName = path4.basename(image.path);
+        const destPath = path4.join(galleryDir, fileName);
+        ui.debug(`Copying photo to ${destPath}`);
+        fs4.copyFileSync(sourcePath, destPath);
       }
     }
-    return {
-      width: metadata.width || 0,
-      height: metadata.height || 0,
-      description
-    };
+  }
+}
+async function buildGallery(galleryDir, templateDir, ui, baseUrl) {
+  ui.start(`Building gallery ${galleryDir}`);
+  await processGalleryThumbnails(galleryDir, ui);
+  const galleryJsonPath = path4.join(galleryDir, "gallery", "gallery.json");
+  const galleryContent = fs4.readFileSync(galleryJsonPath, "utf8");
+  const galleryData = GalleryDataSchema.parse(JSON.parse(galleryContent));
+  const socialMediaCardImagePath = path4.join(galleryDir, "gallery", "thumbnails", "social-media-card.jpg");
+  await createGallerySocialMediaCardImage(
+    path4.resolve(path4.join(galleryDir, "gallery"), galleryData.headerImage),
+    galleryData.title,
+    socialMediaCardImagePath,
+    ui
+  );
+  galleryData.metadata.image = galleryData.metadata.image || `${galleryData.url || ""}/${path4.relative(galleryDir, socialMediaCardImagePath)}`;
+  fs4.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  if (!baseUrl) {
+    const shouldCopyPhotos = galleryData.sections.some(
+      (section) => section.images.some((image) => !checkFileIsOneFolderUp(image.path))
+    );
+    if (shouldCopyPhotos && await ui.prompt("All photos need to be copied. Are you sure you want to continue?", { type: "confirm" })) {
+      ui.debug("Copying photos");
+      copyPhotos(galleryData, galleryDir, ui);
+    }
+  }
+  if (baseUrl) {
+    ui.debug("Updating gallery.json with baseUrl");
+    galleryData.mediaBaseUrl = baseUrl;
+    fs4.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  }
+  ui.debug("Building gallery form template");
+  try {
+    process2.env.GALLERY_JSON_PATH = galleryJsonPath;
+    process2.env.GALLERY_OUTPUT_DIR = path4.join(galleryDir, "gallery");
+    execSync("npx astro build", { cwd: templateDir, stdio: ui.level === LogLevels.debug ? "inherit" : "ignore" });
   } catch (error) {
-    console.warn(`Warning: Could not get metadata for image ${filePath}:`, error);
-    return { width: 0, height: 0 };
+    ui.error(`Build failed for ${galleryDir}`);
+    throw error;
   }
+  const outputDir = path4.join(galleryDir, "gallery");
+  const buildDir = path4.join(outputDir, "_build");
+  ui.debug(`Copying build output to ${outputDir}`);
+  fs4.cpSync(buildDir, outputDir, { recursive: true });
+  ui.debug("Moving index.html to gallery directory");
+  fs4.copyFileSync(path4.join(outputDir, "index.html"), path4.join(galleryDir, "index.html"));
+  fs4.rmSync(path4.join(outputDir, "index.html"));
+  ui.debug("Cleaning up build directory");
+  fs4.rmSync(buildDir, { recursive: true, force: true });
+  ui.success(`Gallery built successfully`);
 }
-async function getVideoDimensions(filePath) {
+async function build(options, ui) {
+  try {
+    const galleryDirs = findGalleries(options.gallery, options.recursive);
+    if (galleryDirs.length === 0) {
+      ui.error("No galleries found.");
+      return;
+    }
+    const themePath = await import.meta.resolve("@simple-photo-gallery/theme-modern/package.json");
+    const themeDir = path4.dirname(new URL(themePath).pathname);
+    let totalGalleries = 0;
+    for (const dir of galleryDirs) {
+      const baseUrl = options.baseUrl ? `${options.baseUrl}${path4.relative(options.gallery, dir)}` : void 0;
+      await buildGallery(path4.resolve(dir), themeDir, ui, baseUrl);
+      ++totalGalleries;
+    }
+    ui.box(`Built ${totalGalleries} ${totalGalleries === 1 ? "gallery" : "galleries"} successfully`);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find package")) {
+      ui.error("Theme package not found: @simple-photo-gallery/theme-modern/package.json");
+    } else {
+      ui.error("Error building gallery");
+    }
+    throw error;
+  }
+}
+async function cleanGallery(galleryDir, ui) {
+  let filesRemoved = 0;
+  const indexHtmlPath = path4.join(galleryDir, "index.html");
+  if (fs4.existsSync(indexHtmlPath)) {
+    try {
+      fs4.rmSync(indexHtmlPath);
+      ui.debug(`Removed: ${indexHtmlPath}`);
+      filesRemoved++;
+    } catch (error) {
+      ui.warn(`Failed to remove index.html: ${error}`);
+    }
+  }
+  const galleryPath = path4.join(galleryDir, "gallery");
+  if (fs4.existsSync(galleryPath)) {
+    try {
+      fs4.rmSync(galleryPath, { recursive: true, force: true });
+      ui.debug(`Removed directory: ${galleryPath}`);
+      filesRemoved++;
+    } catch (error) {
+      ui.warn(`Failed to remove gallery directory: ${error}`);
+    }
+  }
+  if (filesRemoved > 0) {
+    ui.success(`Cleaned gallery at: ${galleryDir}`);
+  } else {
+    ui.info(`No gallery files found at: ${galleryDir}`);
+  }
+}
+async function clean(options, ui) {
   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
-      };
+    const basePath = path4.resolve(options.gallery);
+    if (!fs4.existsSync(basePath)) {
+      ui.error(`Directory does not exist: ${basePath}`);
+      return;
+    }
+    const galleryDirs = findGalleries(basePath, options.recursive);
+    if (galleryDirs.length === 0) {
+      ui.info("No galleries found to clean.");
+      return;
     }
-    return { width: 0, height: 0 };
+    for (const dir of galleryDirs) {
+      await cleanGallery(dir, ui);
+    }
+    ui.box(`Successfully cleaned ${galleryDirs.length} ${galleryDirs.length === 1 ? "gallery" : "galleries"}`);
   } catch (error) {
-    console.warn(`Warning: Could not get dimensions for video ${filePath}:`, error);
-    return { width: 0, height: 0 };
+    ui.error("Error cleaning galleries");
+    throw error;
   }
 }
-function isMediaFile(fileName) {
+
+// src/modules/init/const/index.ts
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tiff", ".tif", ".svg"]);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mkv", ".m4v", ".3gp"]);
+
+// src/modules/init/utils/index.ts
+function getMediaFileType(fileName) {
   const ext = path4.extname(fileName).toLowerCase();
   if (IMAGE_EXTENSIONS.has(ext)) return "image";
   if (VIDEO_EXTENSIONS.has(ext)) return "video";
@@ -128,58 +515,62 @@ function capitalizeTitle(folderName) {
 }
 
 // src/modules/init/index.ts
-async function scanDirectory(dirPath) {
+async function scanDirectory(dirPath, ui) {
   const mediaFiles = [];
+  const subGalleryDirectories = [];
   try {
     const entries = await promises.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile()) {
         const fullPath = path4.join(dirPath, entry.name);
-        const mediaType = isMediaFile(entry.name);
+        const mediaType = getMediaFileType(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;
-              }
-            }
-          } catch (mediaError) {
-            console.error(`Error processing file ${entry.name}:`, mediaError);
-            continue;
-          }
           const mediaFile = {
             type: mediaType,
             path: fullPath,
-            width: metadata.width,
-            height: metadata.height
+            width: 0,
+            height: 0
           };
-          if (metadata.description) {
-            mediaFile.alt = metadata.description;
-          }
           mediaFiles.push(mediaFile);
         }
+      } else if (entry.isDirectory() && entry.name !== "gallery") {
+        subGalleryDirectories.push(path4.join(dirPath, entry.name));
       }
     }
   } catch (error) {
-    console.error(`Error scanning directory ${dirPath}:`, error);
+    if (error instanceof Error && error.message.includes("ENOENT")) {
+      ui.error(`Directory does not exist: ${dirPath}`);
+    } else if (error instanceof Error && error.message.includes("ENOTDIR")) {
+      ui.error(`Path is not a directory: ${dirPath}`);
+    } else {
+      ui.error(`Error scanning directory ${dirPath}:`, error);
+    }
+    throw error;
   }
-  return mediaFiles;
+  return { mediaFiles, subGalleryDirectories };
+}
+async function getGallerySettingsFromUser(galleryName, defaultImage, ui) {
+  ui.info(`Enter gallery settings for the gallery in folder "${galleryName}"`);
+  const title = await ui.prompt("Enter gallery title", { type: "text", default: "My Gallery", placeholder: "My Gallery" });
+  const description = await ui.prompt("Enter gallery description", {
+    type: "text",
+    default: "My gallery with fantastic photos.",
+    placeholder: "My gallery with fantastic photos."
+  });
+  const url = await ui.prompt("Enter the URL where the gallery will be hosted (important for social media image)", {
+    type: "text",
+    default: "",
+    placeholder: ""
+  });
+  const headerImageName = await ui.prompt("Enter the name of the header image", {
+    type: "text",
+    default: defaultImage,
+    placeholder: defaultImage
+  });
+  const headerImage = path4.join("..", headerImageName);
+  return { title, description, url, headerImage };
 }
-async function createGalleryJson(mediaFiles, galleryJsonPath, subGalleries = []) {
+async function createGalleryJson(mediaFiles, galleryJsonPath, subGalleries = [], useDefaultSettings, ui) {
   const galleryDir = path4.dirname(galleryJsonPath);
   const relativeMediaFiles = mediaFiles.map((file) => ({
     ...file,
@@ -189,11 +580,11 @@ async function createGalleryJson(mediaFiles, galleryJsonPath, subGalleries = [])
     ...subGallery,
     headerImage: subGallery.headerImage ? path4.relative(galleryDir, subGallery.headerImage) : ""
   }));
-  const galleryData = {
+  let galleryData = {
     title: "My Gallery",
     description: "My gallery with fantastic photos.",
     headerImage: relativeMediaFiles[0]?.path || "",
-    metadata: { ogUrl: "" },
+    metadata: {},
     sections: [
       {
         images: relativeMediaFiles
@@ -204,42 +595,58 @@ async function createGalleryJson(mediaFiles, galleryJsonPath, subGalleries = [])
       galleries: relativeSubGalleries
     }
   };
+  if (!useDefaultSettings) {
+    galleryData = {
+      ...galleryData,
+      ...await getGallerySettingsFromUser(
+        path4.basename(path4.join(galleryDir, "..")),
+        path4.basename(mediaFiles[0]?.path || ""),
+        ui
+      )
+    };
+  }
   await promises.writeFile(galleryJsonPath, JSON.stringify(galleryData, null, 2));
 }
-async function processDirectory(dirPath, options) {
+async function processDirectory(scanPath, outputPath, recursive, useDefaultSettings, ui) {
+  ui.start(`Scanning ${scanPath}`);
   let totalFiles = 0;
+  let totalGalleries = 1;
   const subGalleries = [];
-  const mediaFiles = await scanDirectory(dirPath);
+  const { mediaFiles, subGalleryDirectories } = await scanDirectory(scanPath, ui);
   totalFiles += mediaFiles.length;
-  if (options.recursive) {
-    try {
-      const entries = await promises.readdir(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name !== "gallery") {
-          const subDirPath = path4.join(dirPath, entry.name);
-          const result2 = await processDirectory(subDirPath, options);
-          totalFiles += result2.totalFiles;
-          if (result2.subGallery) {
-            subGalleries.push(result2.subGallery);
-          }
-        }
+  if (recursive) {
+    for (const subGalleryDir of subGalleryDirectories) {
+      const result2 = await processDirectory(
+        subGalleryDir,
+        path4.join(outputPath, path4.basename(subGalleryDir)),
+        recursive,
+        useDefaultSettings,
+        ui
+      );
+      totalFiles += result2.totalFiles;
+      totalGalleries += result2.totalGalleries;
+      if (result2.subGallery) {
+        subGalleries.push(result2.subGallery);
       }
-    } catch (error) {
-      console.error(`Error reading directory ${dirPath}:`, error);
     }
   }
   if (mediaFiles.length > 0 || subGalleries.length > 0) {
-    const outputPath = options.output ? path4.resolve(options.output, path4.relative(path4.resolve(options.path), dirPath), "gallery") : path4.join(dirPath, "gallery");
-    const galleryJsonPath = path4.join(outputPath, "gallery.json");
-    await promises.mkdir(outputPath, { recursive: true });
-    await createGalleryJson(mediaFiles, galleryJsonPath, subGalleries);
-    console.log(
-      `Gallery JSON created at: ${galleryJsonPath} (${mediaFiles.length} files, ${subGalleries.length} subgalleries)`
-    );
+    const galleryPath = path4.join(outputPath, "gallery");
+    const galleryJsonPath = path4.join(galleryPath, "gallery.json");
+    try {
+      await promises.mkdir(galleryPath, { recursive: true });
+      await createGalleryJson(mediaFiles, galleryJsonPath, subGalleries, useDefaultSettings, ui);
+      ui.success(
+        `Create gallery with ${mediaFiles.length} files and ${subGalleries.length} subgalleries at: ${galleryJsonPath}`
+      );
+    } catch (error) {
+      ui.error(`Error creating gallery.json at ${galleryJsonPath}`);
+      throw error;
+    }
   }
-  const result = { totalFiles };
+  const result = { totalFiles, totalGalleries };
   if (mediaFiles.length > 0 || subGalleries.length > 0) {
-    const dirName = path4.basename(dirPath);
+    const dirName = path4.basename(scanPath);
     result.subGallery = {
       title: capitalizeTitle(dirName),
       headerImage: mediaFiles[0]?.path || "",
@@ -248,250 +655,56 @@ async function processDirectory(dirPath, options) {
   }
   return result;
 }
-async function init(options) {
-  const scanPath = path4.resolve(options.path);
-  console.log(`Scanning directory: ${scanPath}`);
-  console.log(`Recursive: ${options.recursive}`);
-  try {
-    await promises.access(scanPath);
-    const result = await processDirectory(scanPath, options);
-    console.log(`Total files processed: ${result.totalFiles}`);
-  } catch (error) {
-    throw new Error(`Error during scan: ${error}`);
-  }
-}
-async function checkFfmpegAvailability() {
-  return new Promise((resolve) => {
-    const ffmpeg = spawn("ffmpeg", ["-version"]);
-    ffmpeg.on("close", (code) => {
-      resolve(code === 0);
-    });
-    ffmpeg.on("error", () => {
-      resolve(false);
-    });
-  });
-}
-async function resizeAndSaveThumbnail(image, outputPath, width, height) {
-  await image.resize(width, height, { withoutEnlargement: true }).jpeg({ quality: 90 }).toFile(outputPath);
-}
-async function createImageThumbnail(inputPath, outputPath, height) {
-  try {
-    await promises.access(inputPath);
-    const image = sharp2(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");
-    }
-    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}`);
-  }
-}
-async function createVideoThumbnail(inputPath, outputPath, height) {
+async function init(options, ui) {
   try {
-    await promises.access(inputPath);
-    const ffmpegAvailable = await checkFfmpegAvailability();
-    if (!ffmpegAvailable) {
-      console.warn(`Warning: ffmpeg is not available. Skipping thumbnail creation for video: ${path4.basename(inputPath)}`);
-      throw new Error("FFMPEG_NOT_AVAILABLE");
-    }
-    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");
-    }
-    const aspectRatio = originalWidth / originalHeight;
-    const width = Math.round(height * aspectRatio);
-    const tempFramePath = `${outputPath}.temp.png`;
-    return new Promise((resolve, reject) => {
-      const ffmpeg = spawn("ffmpeg", [
-        "-i",
-        inputPath,
-        "-vframes",
-        "1",
-        "-y",
-        // Overwrite output file
-        tempFramePath
-      ]);
-      ffmpeg.stderr.on("data", (data) => {
-        console.debug(`ffmpeg: ${data.toString()}`);
-      });
-      ffmpeg.on("close", async (code) => {
-        if (code === 0) {
-          try {
-            const frameImage = sharp2(tempFramePath);
-            await resizeAndSaveThumbnail(frameImage, outputPath, width, height);
-            try {
-              await promises.unlink(tempFramePath);
-            } catch {
-            }
-            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}`));
-      });
-    });
+    const scanPath = path4.resolve(options.photos);
+    const outputPath = options.gallery ? path4.resolve(options.gallery) : scanPath;
+    const result = await processDirectory(scanPath, outputPath, options.recursive, options.default, ui);
+    ui.box(
+      `Created ${result.totalGalleries} ${result.totalGalleries === 1 ? "gallery" : "galleries"} with ${result.totalFiles} media ${result.totalFiles === 1 ? "file" : "files"}`
+    );
   } catch (error) {
-    if (error instanceof Error && error.message === "FFMPEG_NOT_AVAILABLE") {
-      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: ${path4.basename(inputPath)}`
-      );
-    }
-    throw new Error(`Failed to create video thumbnail for ${inputPath}: ${error}`);
+    ui.error("Error initializing gallery");
+    throw error;
   }
 }
-var ThumbnailSchema = z.object({
-  path: z.string(),
-  width: z.number(),
-  height: z.number()
-});
-var MediaFileSchema = z.object({
-  type: z.enum(["image", "video"]),
-  path: z.string(),
-  alt: z.string().optional(),
-  width: z.number(),
-  height: z.number(),
-  thumbnail: ThumbnailSchema.optional()
-});
-var GallerySectionSchema = z.object({
-  title: z.string().optional(),
-  description: z.string().optional(),
-  images: z.array(MediaFileSchema)
-});
-var SubGallerySchema = z.object({
-  title: z.string(),
-  headerImage: z.string(),
-  path: z.string()
-});
-var 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) })
-});
 
-// src/modules/thumbnails/index.ts
-var processGallery = async (galleryDir, size) => {
-  const galleryJsonPath = path4.join(galleryDir, "gallery", "gallery.json");
-  const thumbnailsPath = path4.join(galleryDir, "gallery", "thumbnails");
-  console.log(`
-Processing gallery in: ${galleryDir}`);
-  try {
-    fs2.mkdirSync(thumbnailsPath, { recursive: true });
-    const galleryContent = fs2.readFileSync(galleryJsonPath, "utf8");
-    const galleryData = GalleryDataSchema.parse(JSON.parse(galleryContent));
-    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;
-    }
-    fs2.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 {
-    const galleryJsonDir = path4.join(galleryDir, "gallery");
-    const filePath = path4.resolve(path4.join(galleryJsonDir, mediaFile.path));
-    const fileName = path4.basename(filePath);
-    const fileNameWithoutExt = path4.parse(fileName).name;
-    const thumbnailFileName = `${fileNameWithoutExt}.jpg`;
-    const thumbnailPath = path4.join(thumbnailsPath, thumbnailFileName);
-    const relativeThumbnailPath = path4.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;
-    }
-    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(`\u26A0 Skipping video thumbnail (ffmpeg not available): ${path4.basename(mediaFile.path)}`);
-    } else {
-      console.error(`Error processing ${mediaFile.path}:`, error);
-    }
-    return mediaFile;
+// src/index.ts
+var program = new Command();
+program.name("gallery").description("Simple Photo Gallery CLI").version("0.0.1").option("-v, --verbose", "Verbose output (debug level)", false).option("-q, --quiet", "Minimal output (only warnings/errors)", false).showHelpAfterError(true);
+function createConsolaUI(globalOpts) {
+  let level = LogLevels.info;
+  if (globalOpts.quiet) {
+    level = LogLevels.warn;
+  } else if (globalOpts.verbose) {
+    level = LogLevels.debug;
   }
+  return createConsola({
+    level
+  }).withTag("simple-photo-gallery");
 }
-async function thumbnails(options) {
-  const size = Number.parseInt(options.size);
-  const galleryDirs = findGalleries(options.path, options.recursive);
-  if (galleryDirs.length === 0) {
-    console.log("No gallery/gallery.json files found.");
-    return;
-  }
-  let totalProcessed = 0;
-  for (const galleryDir of galleryDirs) {
-    const processed = await processGallery(galleryDir, size);
-    totalProcessed += processed;
-  }
-  if (options.recursive) {
-    console.log(`Completed processing ${totalProcessed} total media files across ${galleryDirs.length} galleries.`);
-  } else {
-    console.log(`Completed processing ${totalProcessed} media files.`);
-  }
+function withConsolaUI(handler) {
+  return async (opts) => {
+    const ui = createConsolaUI(program.opts());
+    try {
+      await handler(opts, ui);
+    } catch (error) {
+      ui.debug(error);
+      process2.exitCode = 1;
+    }
+  };
 }
-
-// src/index.ts
-var 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);
+  "-p, --photos <path>",
+  "Path to the folder where the photos are stored. Default: current working directory",
+  process2.cwd()
+).option(
+  "-g, --gallery <path>",
+  "Path to the directory where the gallery will be initialized. Default: same directory as the photos folder"
+).option("-r, --recursive", "Recursively create galleries from all photos subdirectories", false).option("-d, --default", "Use default gallery settings instead of asking the user", false).action(withConsolaUI(init));
+program.command("thumbnails").description("Create thumbnails for all media files in the gallery").option("-g, --gallery <path>", "Path to the directory of the gallery. Default: current working directory", process2.cwd()).option("-r, --recursive", "Scan subdirectories recursively", false).action(withConsolaUI(thumbnails));
+program.command("build").description("Build the HTML gallery in the specified directory").option("-g, --gallery <path>", "Path to the directory of the gallery. Default: current working directory", process2.cwd()).option("-r, --recursive", "Scan subdirectories recursively", false).option("-b, --base-url <url>", "Base URL where the photos are hosted").action(withConsolaUI(build));
+program.command("clean").description("Remove all gallery files and folders (index.html, gallery/)").option("-g, --gallery <path>", "Path to the directory of the gallery. Default: current working directory", process2.cwd()).option("-r, --recursive", "Clean subdirectories recursively", false).action(withConsolaUI(clean));
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map