Añadido el parametro tsgrouparray

main.go

@@ -16,12 +16,14 @@ import (
 )
 
 type Config struct {
-	dir        string
-	width      int
-	height     int
-	quality    int
-	typescript bool
-	tsgroup    bool
+	dir          string
+	width        int
+	height       int
+	quality      int
+	typescript   bool
+	tsgroup      bool
+	tsgrouparray bool
+	outputName   string
 }
 
 func main() {
@@ -46,6 +48,18 @@ func main() {
 		os.Exit(1)
 	}
 
+	// Validar que no se usen -ts y -tsgrouparray juntos
+	if cfg.typescript && cfg.tsgrouparray {
+		fmt.Println("Error: No puedes usar -ts y -tsgrouparray simultáneamente")
+		os.Exit(1)
+	}
+
+	// Validar que no se usen -tsgroup y -tsgrouparray juntos
+	if cfg.tsgroup && cfg.tsgrouparray {
+		fmt.Println("Error: No puedes usar -tsgroup y -tsgrouparray simultáneamente")
+		os.Exit(1)
+	}
+
 	// Leer archivos del directorio
 	entries, err := os.ReadDir(cfg.dir)
 	if err != nil {
@@ -53,12 +67,17 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Si es tsgroup, procesar todas las imágenes en un solo archivo
+	// Si es tsgroup o tsgrouparray, procesar todas las imágenes en un solo archivo
 	if cfg.tsgroup {
 		processTsGroup(entries, cfg)
 		return
 	}
 
+	if cfg.tsgrouparray {
+		processTsGroupArray(entries, cfg)
+		return
+	}
+
 	// Procesamiento individual
 	processed := 0
 	for _, entry := range entries {
@@ -104,6 +123,8 @@ func parseFlags() Config {
 	flag.IntVar(&cfg.quality, "quality", 80, "Calidad JPEG (1-100)")
 	flag.BoolVar(&cfg.typescript, "ts", false, "Generar archivos TypeScript individuales (.b64.ts)")
 	flag.BoolVar(&cfg.tsgroup, "tsgroup", false, "Generar un único archivo TypeScript con todas las imágenes")
+	flag.BoolVar(&cfg.tsgrouparray, "tsgrouparray", false, "Generar un único archivo TypeScript con Record<string, string>")
+	flag.StringVar(&cfg.outputName, "output", "", "Nombre del archivo de salida (solo para -tsgroup/-tsgrouparray)")
 
 	flag.Usage = func() {
 		fmt.Fprintf(os.Stderr, "\n╔════════════════════════════════════════════════════════════════════╗\n")
@@ -138,12 +159,24 @@ func parseFlags() Config {
 		fmt.Fprintf(os.Stderr, "  -ts\n")
 		fmt.Fprintf(os.Stderr, "        Generar archivos TypeScript individuales (.b64.ts)\n")
 		fmt.Fprintf(os.Stderr, "        Formato: export const nombre = \"data:image/jpeg;base64,...\"\n")
-		fmt.Fprintf(os.Stderr, "        No se puede usar junto con -tsgroup\n\n")
+		fmt.Fprintf(os.Stderr, "        No se puede usar con -tsgroup ni -tsgrouparray\n\n")
 
 		fmt.Fprintf(os.Stderr, "  -tsgroup\n")
-		fmt.Fprintf(os.Stderr, "        Generar un único archivo TypeScript con todas las imágenes\n")
+		fmt.Fprintf(os.Stderr, "        Generar un único archivo TypeScript con exports individuales\n")
 		fmt.Fprintf(os.Stderr, "        Archivo: nombre-directorio.b64.ts\n")
-		fmt.Fprintf(os.Stderr, "        No se puede usar junto con -ts\n\n")
+		fmt.Fprintf(os.Stderr, "        No se puede usar con -ts ni -tsgrouparray\n\n")
+
+		fmt.Fprintf(os.Stderr, "  -tsgrouparray\n")
+		fmt.Fprintf(os.Stderr, "        Generar un único archivo TypeScript con Record<string, string>\n")
+		fmt.Fprintf(os.Stderr, "        Archivo: nombre-directorio.b64.ts (o usar -output)\n")
+		fmt.Fprintf(os.Stderr, "        Formato: export const images: Record<string, string> = {...}\n")
+		fmt.Fprintf(os.Stderr, "        No se puede usar con -ts ni -tsgroup\n\n")
+
+		fmt.Fprintf(os.Stderr, "  -output string\n")
+		fmt.Fprintf(os.Stderr, "        Nombre personalizado para el archivo de salida\n")
+		fmt.Fprintf(os.Stderr, "        Solo válido con -tsgroup o -tsgrouparray\n")
+		fmt.Fprintf(os.Stderr, "        No incluir extensión .b64.ts (se añade automáticamente)\n")
+		fmt.Fprintf(os.Stderr, "        Ejemplo: -output miarchivo → genera miarchivo.b64.ts\n\n")
 
 		fmt.Fprintf(os.Stderr, "  -h, -help\n")
 		fmt.Fprintf(os.Stderr, "        Muestra esta ayuda\n\n")
@@ -161,9 +194,15 @@ func parseFlags() Config {
 		fmt.Fprintf(os.Stderr, "  # Generar archivos TypeScript individuales\n")
 		fmt.Fprintf(os.Stderr, "  %s -dir ./imagenes -width 800 -ts\n\n", os.Args[0])
 
-		fmt.Fprintf(os.Stderr, "  # Generar un único archivo TypeScript con todas las imágenes\n")
+		fmt.Fprintf(os.Stderr, "  # Generar un único archivo TypeScript con exports individuales\n")
 		fmt.Fprintf(os.Stderr, "  %s -dir ./imagenes -width 800 -tsgroup\n\n", os.Args[0])
 
+		fmt.Fprintf(os.Stderr, "  # Generar un único archivo TypeScript con Record\n")
+		fmt.Fprintf(os.Stderr, "  %s -dir ./imagenes -width 800 -tsgrouparray\n\n", os.Args[0])
+
+		fmt.Fprintf(os.Stderr, "  # Generar con nombre personalizado\n")
+		fmt.Fprintf(os.Stderr, "  %s -dir ./imagenes -tsgrouparray -output misImagenes\n\n", os.Args[0])
+
 		fmt.Fprintf(os.Stderr, "  # Dimensiones para visualización web\n")
 		fmt.Fprintf(os.Stderr, "  %s -dir ./imagenes -width 1240 -quality 85\n\n", os.Args[0])
 
@@ -179,12 +218,13 @@ func parseFlags() Config {
 		fmt.Fprintf(os.Stderr, "NOTAS:\n")
 		fmt.Fprintf(os.Stderr, "  • La relación de aspecto se mantiene automáticamente\n")
 		fmt.Fprintf(os.Stderr, "  • No puedes usar -width y -height simultáneamente\n")
-		fmt.Fprintf(os.Stderr, "  • No puedes usar -ts y -tsgroup simultáneamente\n")
+		fmt.Fprintf(os.Stderr, "  • Solo puedes usar una opción de TypeScript a la vez\n")
 		fmt.Fprintf(os.Stderr, "  • Las imágenes más pequeñas que el tamaño especificado no se agrandan\n")
 		fmt.Fprintf(os.Stderr, "  • Archivos generados:\n")
 		fmt.Fprintf(os.Stderr, "      - Sin flags: nombreoriginal.base64\n")
 		fmt.Fprintf(os.Stderr, "      - Con -ts: nombreoriginal.b64.ts (uno por imagen)\n")
-		fmt.Fprintf(os.Stderr, "      - Con -tsgroup: nombre-directorio.b64.ts (todas las imágenes)\n\n")
+		fmt.Fprintf(os.Stderr, "      - Con -tsgroup: nombre-directorio.b64.ts (exports individuales)\n")
+		fmt.Fprintf(os.Stderr, "      - Con -tsgrouparray: nombre-directorio.b64.ts (Record)\n\n")
 	}
 
 	flag.Parse()
@@ -204,6 +244,12 @@ func parseFlags() Config {
 		os.Exit(1)
 	}
 
+	// Validar que -output solo se use con -tsgroup o -tsgrouparray
+	if cfg.outputName != "" && !cfg.tsgroup && !cfg.tsgrouparray {
+		fmt.Println("Error: -output solo se puede usar con -tsgroup o -tsgrouparray")
+		os.Exit(1)
+	}
+
 	return cfg
 }
 
@@ -325,9 +371,14 @@ func generateVarName(filename string) string {
 }
 
 func processTsGroup(entries []os.DirEntry, cfg Config) {
-	// Obtener nombre del directorio
-	dirName := filepath.Base(cfg.dir)
-	outputPath := filepath.Join(cfg.dir, dirName+".b64.ts")
+	// Determinar nombre del archivo de salida
+	var outputName string
+	if cfg.outputName != "" {
+		outputName = cfg.outputName
+	} else {
+		outputName = filepath.Base(cfg.dir)
+	}
+	outputPath := filepath.Join(cfg.dir, outputName+".b64.ts")
 
 	var tsContent strings.Builder
 	tsContent.WriteString("// Imágenes generadas automáticamente\n\n")
@@ -415,3 +466,67 @@ func imageToBase64(inputPath string, cfg Config) (string, error) {
 	// Convertir a base64
 	return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
 }
+
+func processTsGroupArray(entries []os.DirEntry, cfg Config) {
+	// Determinar nombre del archivo de salida
+	var outputName string
+	if cfg.outputName != "" {
+		outputName = cfg.outputName
+	} else {
+		outputName = filepath.Base(cfg.dir)
+	}
+	outputPath := filepath.Join(cfg.dir, outputName+".b64.ts")
+
+	var tsContent strings.Builder
+	tsContent.WriteString("// Imágenes generadas automáticamente\n\n")
+	tsContent.WriteString("export const images: Record<string, string> = {\n")
+
+	processed := 0
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		// Verificar si es una imagen soportada
+		ext := strings.ToLower(filepath.Ext(entry.Name()))
+		if ext != ".jpg" && ext != ".jpeg" && ext != ".png" {
+			continue
+		}
+
+		inputPath := filepath.Join(cfg.dir, entry.Name())
+		fmt.Printf("Procesando: %s\n", entry.Name())
+
+		// Procesar imagen a base64
+		base64Str, err := imageToBase64(inputPath, cfg)
+		if err != nil {
+			fmt.Printf("  Error: %v\n", err)
+			continue
+		}
+
+		// Generar nombre de clave
+		keyName := generateVarName(entry.Name())
+
+		// Añadir al contenido TypeScript
+		tsContent.WriteString(fmt.Sprintf("  %s: \"data:image/jpeg;base64,%s\",\n", keyName, base64Str))
+
+		fmt.Printf("  ✓ Añadido: %s\n", keyName)
+		processed++
+	}
+
+	if processed == 0 {
+		fmt.Println("No se encontraron imágenes para procesar")
+		return
+	}
+
+	tsContent.WriteString("}\n")
+
+	// Guardar archivo
+	err := os.WriteFile(outputPath, []byte(tsContent.String()), 0644)
+	if err != nil {
+		fmt.Printf("Error al guardar archivo: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("\n✓ Archivo generado: %s\n", filepath.Base(outputPath))
+	fmt.Printf("%d imágenes procesadas correctamente\n", processed)
+}