Plugin Minificador 25.11

Abrir en ChatGPT

El Plugin Minificador de webforJ automáticamente minifica y optimiza los activos CSS y JavaScript durante el proceso de construcción. El plugin descubre activos referenciados a través de las anotaciones de activos de webforJ y los minifica en la salida de construcción, reduciendo el tamaño de los archivos y mejorando los tiempos de carga sin modificar tus archivos fuente originales.

Configuración

Si creaste tu proyecto utilizando startforJ o un arquetipo de webforJ, el plugin minificador ya está configurado y se ejecuta automáticamente cuando construyes con el perfil prod usando mvn package -Pprod.

Para la configuración manual, el minificador requiere dos configuraciones: un procesador de anotaciones para descubrir activos durante la compilación y un plugin para realizar la minificación.

Maven
Gradle

Agrega lo siguiente a tu pom.xml:

<build>
  <plugins>
    <!-- Configuración del Procesador de Anotaciones -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <annotationProcessorPaths>
          <path>
            <groupId>com.webforj</groupId>
            <artifactId>webforj-minify-foundation</artifactId>
            <version>${webforj.version}</version>
          </path>
        </annotationProcessorPaths>
      </configuration>
    </plugin>

    <!-- Configuración del Plugin Minificador -->
    <plugin>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-minify-maven-plugin</artifactId>
      <version>${webforj.version}</version>
      <executions>
        <execution>
          <goals>
            <goal>minify</goal>
          </goals>
        </execution>
      </executions>
      <dependencies>
        <!-- Minificación de CSS -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-phcss-css</artifactId>
          <version>${webforj.version}</version>
        </dependency>
        <!-- Minificación de JavaScript -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-closure-js</artifactId>
          <version>${webforj.version}</version>
        </dependency>
      </dependencies>
    </plugin>
  </plugins>
</build>

Agrega lo siguiente a tu build.gradle:

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath "com.webforj:webforj-minify-gradle-plugin:${webforjVersion}"
  }
}

plugins {
  id 'java'
}

apply plugin: 'com.webforj.minify'

dependencies {
  // Procesador de anotaciones para descubrir activos durante la compilación
  annotationProcessor "com.webforj:webforj-minify-foundation:${webforjVersion}"

  // Implementaciones del minificador
  add "webforjMinifier", "com.webforj:webforj-minify-phcss-css:${webforjVersion}"
  add "webforjMinifier", "com.webforj:webforj-minify-closure-js:${webforjVersion}"
}

La tarea minify se ejecuta automáticamente antes de las tareas jar o war. También puedes ejecutarla manualmente con ./gradlew minify.

Uso del plugin

Una vez configurado, el plugin funciona automáticamente. Simplemente utiliza las anotaciones de activos de webforJ en tu código:

package com.example;

import com.webforj.annotation.StyleSheet;
import com.webforj.annotation.JavaScript;

@StyleSheet("ws://css/app.css")
@JavaScript("ws://js/app.js")
public class MyApp extends App {
  // Tu código de aplicación
}

Cuando construyes tu proyecto, el plugin automáticamente:

Descubre los activos referenciados en las anotaciones durante la compilación
Minifica los archivos CSS y JavaScript descubiertos
Reporta la reducción de tamaño y el tiempo de procesamiento

Resolución del protocolo URL

El plugin entiende los protocolos URL de webforJ y los resuelve en rutas del sistema de archivos:

Protocolo	Resuelve a	Ejemplo
`ws://`	`src/main/resources/static/`	`ws://css/app.css` → `static/css/app.css`
`context://`	`src/main/resources/`	`context://styles/app.css` → `styles/app.css`

Las URL sin protocolo no son soportadas por el minificador y serán saltadas.

Minificadores incorporados

webforJ incluye dos minificadores listos para producción para CSS y JavaScript.

Minificador	Características	Omite
CSS	Elimina espacios en blanco, comentarios, y optimiza valores de propiedad	`.min.css`
JavaScript	Renombramiento de variables, eliminación de código muerto, optimización de sintaxis	`.min.js`, `.min.mjs`

Opciones de configuración

El plugin proporciona opciones para deshabilitar la minificación, personalizar la optimización de JavaScript y procesar archivos adicionales.

Deshabilitar la minificación

Puedes querer desactivar la minificación durante el desarrollo o para fines de depuración.

Maven
Gradle

A través de la línea de comandos:

mvn package -Dwebforj.minify.skip=true

A través de la configuración del plugin:

<plugin>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-minify-maven-plugin</artifactId>
  <configuration>
    <skip>true</skip>
  </configuration>
</plugin>

A través de la configuración de construcción:

webforjMinify {
  skip = true
}

Opciones del minificador de JavaScript

El minificador de JavaScript ofrece varias opciones de configuración para controlar el comportamiento de optimización.

Soporte Gradle

A partir de la v25.12, el plugin de Gradle admite pasar opciones del minificador de JavaScript.

Opción	Predeterminado	Descripción
`compilationLevel`	`SIMPLE_OPTIMIZATIONS`	`WHITESPACE_ONLY` - elimina solo espacios en blanco y comentarios `SIMPLE_OPTIMIZATIONS` - renombramiento de variables y eliminación de código muerto `ADVANCED_OPTIMIZATIONS` - optimización agresiva con renombramiento de funciones/propiedades
`languageIn`	`ECMASCRIPT_NEXT`	Versión de JavaScript de entrada: `ECMASCRIPT3`, `ECMASCRIPT5`, `ECMASCRIPT_2015` a `ECMASCRIPT_2021`, `ECMASCRIPT_NEXT`
`languageOut`	`ECMASCRIPT5`	Versión de JavaScript de salida: la misma que `languageIn`, más `NO_TRANSPILE`
`prettyPrint`	`false`	Establecer en `true` para preservar el formato para depuración

Configura estas opciones en la sección de configuración:

Maven
Gradle

<plugin>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-minify-maven-plugin</artifactId>
  <version>${webforj.version}</version>
  <configuration>
    <minifierConfigurations>
      <closureJs>
        <compilationLevel>SIMPLE_OPTIMIZATIONS</compilationLevel>
        <languageIn>ECMASCRIPT_2020</languageIn>
        <languageOut>ECMASCRIPT5</languageOut>
        <prettyPrint>false</prettyPrint>
      </closureJs>
    </minifierConfigurations>
  </configuration>
  <executions>
    <execution>
      <goals>
        <goal>minify</goal>
      </goals>
    </execution>
  </executions>
  <dependencies>
    <dependency>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-minify-closure-js</artifactId>
      <version>${webforj.version}</version>
    </dependency>
  </dependencies>
</plugin>

webforjMinify {
    skip = false  // Establecer en true para omitir la minificación
    minifierConfigurations.put("closureJs", [
      compilationLevel: "SIMPLE_OPTIMIZATIONS",
      languageIn: "ECMASCRIPT_NEXT",
      languageOut: "ECMASCRIPT5"
    ])
}

Minificando archivos adicionales

Para minificar archivos no descubiertos a través de anotaciones, crea un archivo de configuración que especifique patrones glob:

src/main/resources/META-INF/webforj-minify.txt
# Patrones de inclusión
**/*.css
**/*.js

# Patrones de exclusión (prefijar con !)
!**/*.min.css
!**/*.min.js

Minificadores personalizados

El plugin admite minificadores personalizados a través de la interfaz de proveedor de servicios (SPI) de Java, lo que te permite agregar soporte para tipos de archivos adicionales o bibliotecas de minificación alternativas.

Creando un minificador personalizado

Implementa la interfaz AssetMinifier para crear tu propio minificador. El siguiente ejemplo muestra un minificador JSON que utiliza Gson para eliminar espacios en blanco:

src/main/java/com/example/minifier/JsonMinifier.java
package com.example.minifier;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonSyntaxException;
import com.webforj.minify.common.AssetMinifier;
import com.webforj.minify.common.MinificationException;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;

public class JsonMinifier implements AssetMinifier {

  private static final Logger logger = Logger.getLogger(JsonMinifier.class.getName());
  private final Gson gson = new GsonBuilder().create();

  @Override
  public String minify(String content, Path sourceFile) throws MinificationException {
    try {
      JsonElement element = gson.fromJson(content, JsonElement.class);
      return gson.toJson(element);
    } catch (JsonSyntaxException e) {
      logger.warning("JSON mal formado en " + sourceFile + ", omitiendo: " + e.getMessage());
      return content;
    } catch (Exception e) {
      throw new MinificationException("Error al minificar el archivo JSON: " + sourceFile, e);
    }
  }

  @Override
  public Set<String> getSupportedExtensions() {
    return Set.of("json");
  }

  @Override
  public boolean shouldMinify(Path filePath) {
    String filename = filePath.getFileName().toString();
    // Omitir archivos de configuración y archivos ya minificados
    if (filename.equals("package.json") || filename.equals("tsconfig.json")) {
      return false;
    }
    if (filename.endsWith("-lock.json") || filename.endsWith(".min.json")) {
      return false;
    }
    return true;
  }

  @Override
  public void configure(Map<String, Object> options) {
    // Opciones de configuración si es necesario
  }
}

Registrando tu minificador

Crea un archivo de configuración del proveedor de servicios:

src/main/resources/META-INF/services/com.webforj.minify.common.AssetMinifier
com.example.minifier.JsonMinifier

Usando tu minificador personalizado

Empaqueta tu minificador como un JAR separado y agrégalo como dependencia del plugin:

<plugin>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-minify-maven-plugin</artifactId>
  <dependencies>
    <dependency>
      <groupId>com.example</groupId>
      <artifactId>json-minifier</artifactId>
      <version>1.0.0</version>
    </dependency>
    <!-- Minificadores estándar (opcional) -->
    <dependency>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-minify-phcss-css</artifactId>
      <version>${webforj.version}</version>
    </dependency>
  </dependencies>
</plugin>

Problemas comunes

No se registraron minificadores

[WARN] No se registraron minificadores a través de SPI. Omitiendo la minificación.
[WARN] Asegúrate de que ph-css y/o closure-compiler estén en el classpath.

Agrega las dependencias del módulo minificador a la configuración del plugin. Para CSS, agrega webforj-minify-phcss-css. Para JavaScript, agrega webforj-minify-closure-js.

No se procesaron archivos

Si el plugin reporta Processed 0 files, verifica que:

El procesador de anotaciones esté configurado en maven-compiler-plugin con webforj-minify-foundation en annotationProcessorPaths
Existan anotaciones de activos de webforJ en tu código fuente
target/classes/META-INF/webforj-resources.json exista después de la compilación

Archivo no encontrado

[WARN] Archivo no encontrado: /path/to/static/css/app.css (referenciado como 'ws://css/app.css')

Verifica que el archivo exista en la ruta correcta bajo src/main/resources/static y que el protocolo URL coincida con la estructura del directorio.

Errores de minificación

[WARN] Error al minificar el archivo /path/to/app.css: error de análisis en la línea 42

El plugin advierte pero continúa sin fallar la construcción. El contenido original se preserva cuando falla la minificación. Para corregir errores de sintaxis, valida CSS o JavaScript con un linter.

Configuración​

Uso del plugin​

Resolución del protocolo URL​

Minificadores incorporados​

Opciones de configuración​

Deshabilitar la minificación​

Opciones del minificador de JavaScript​

Minificando archivos adicionales​

Minificadores personalizados​

Creando un minificador personalizado​

Registrando tu minificador​

Usando tu minificador personalizado​

Problemas comunes​