webpackEmpezando con el webpack


Observaciones

Webpack es un paquete de módulos que lee módulos con dependencias y produce activos estáticos que representan esos módulos.

Cuenta con un sistema de cargador extensible que permite que los paquetes incluyan no solo los recursos de Javascript, sino también CSS, imágenes, HTML y mucho más.

Por ejemplo, usando el cargador de Javascript incorporado, css-loader y url-loader :

require("./code.js") // Load Javascript dependency
var css = require("./styles.css"); // Load CSS as a string
var base64Image = require("./image.png"); // Load an image as a base64 string

Se convertiría en un único archivo empaquetado:

// From code.js
console.log("Hello, World");
// From styles.css
var css = "body { margin: 0; padding: 0; } h1 { color: #FF0000; }";
// From image.png
var base64Image = "data:image/gif;base64,R0lGODlhPQBEAPeoAJosM//AwO/AwHVYZ/z595kzAP/s7P+goOXMv8+fhw/v739/f+8PD98fH/8mJl+fn/9ZWb8/PzWlwv///6wWGbImAPgTEMImIN9gUFCEm/gDALULDN8PAD6atYdCTX9gUNKlj8wZAKUsAOzZz+UMAOsJAP/Z2ccMDA8PD/95eX5NWvsJCOVNQPtfX/8zM8+QePLl38MGBr8JCP+zs9myn/8GBqwpAP/GxgwJCPny78lzYLgjAJ8vAP9fX...";

Las dependencias se pueden definir en cualquiera de los estilos de módulos más comunes (CommonJS y AMD).

Versiones

Versión Fecha de lanzamiento
3.0.0 2017-06-19
2.6.1 2017-05-25
2.6.0 2017-05-23
2.5.1 2017-05-07
2.5.0 2017-05-04
2.4.1 2017-04-14
2.4.0 2017-04-14
1.13 2016-04-17
1.12 2015-08-25
1.11 2015-08-06
1.10 2015-06-27
1.9 2015-05-10
1.8 2015-04-29
1.7 2015-03-11
1.6 2015-02-24
1.5 2015-01-21
1.4 2014-12-28
1.3 2014-08-25
1.2 2014-05-27
1.1 2014-05-17
1.0 2014-03-01
0.11 2013-12-31
0.10 2013-06-19
0.9 2013-03-19
0.8 2013-01-21

Ejemplo de Javascript + CSS + Fuentes + Imágenes

Módulos requeridos

npm install --save-dev webpack extract-text-webpack-plugin file-loader css-loader style-loader
 

Estructura de la carpeta

.
└── assets
    ├── css
    ├── images
    └── js
 

webpack.config.js

const webpack = require('webpack');
const ExtractTextPlugin = require('extract-text-webpack-plugin');
const path = require('path');
const glob = require('glob');

module.exports = {
  entry: {
    script: path.resolve(__dirname, './assets/js/app.js'),
    style: path.resolve(__dirname, './assets/css/app.css'),
    images: glob.sync(path.resolve(__dirname, './assets/images/**/*.*')),
  },
  context: __dirname,
  output: {
    path: path.resolve('./dist/assets'),
    publicPath: '/dist/assets',
    filename: '[name].js',
  },
  module: {
    loaders: [
      {
        test: /\.css$/,
        loader: ExtractTextPlugin.extract({
            fallback: 'style-loader',
            use: 'css-loader'
        }),
      },
      {
        test: /(\.woff2?|\.woff|\.ttf|\.eot|\.svg)(\?v=\d+\.\d+\.\d+)?$/,
        loader: 'file-loader?name=[name]-[hash:6].[ext]',
      },
      {
        test: /\.(png|jpe?g|gif|ico)$/,
        loader: 'file-loader?name=[name].[ext]',
      },
    ],
  },
  plugins: [
    new ExtractTextPlugin('app.css' /* optional: , { allChunks: true } */),
  ],
};
 

glob.sync('./assets/images/**/*.*') requerirá todos los archivos en la carpeta de imágenes como entrada.

ExtractTextPlugin tomará el resultado generado y creará un archivo css empaquetado.

Ejemplo de webpack.config.js con babel

Dependencias

npm i -D webpack babel-loader
 

webpack.config.js

const path = require('path');

module.exports = {
  entry: {
    app: ['babel-polyfill', './src/'],
  },
  output: {
    path: __dirname,
    filename: './dist/[name].js',
  },
  resolve: {
    extensions: ['', '.js'],
  },
  module: {
    loaders: [{
      test: /\.js$/, 
      loaders: ['babel-loader'],
      include: path.resolve(__dirname, 'src')
    }],
  }
};
 

Instalación

Requisitos previos:

NodeJS y npm

Hay dos formas de instalar Webpack: globalmente o por proyecto. Es mejor tener la dependencia instalada por proyecto, ya que esto le permitirá usar diferentes versiones de webpack para cada proyecto y no requiere que el usuario tenga instalado webpack globalmente.

Instalación por proyecto

Ejecute el siguiente comando desde la carpeta raíz de su proyecto:

npm install webpack --save-dev
 

A continuación, puede ejecutar el ejecutable webpack instalado en node_modules :

./node_modules/.bin/webpack
 

O cree un script NPM en su archivo package.json , donde puede omitir la parte node_modules : npm es lo suficientemente inteligente como para incluir esa carpeta en su PATH.

// in package.json:
{
  ...
  "scripts": {
    "start": "webpack"
  },
  ...
}

// from terminal:
npm start
 

Instalando globalmente

Ejecute el siguiente comando cuando se le solicite:

npm install webpack -g
 

Configuración de webpack simple con Node.js

Estructura de la carpeta

.
├── lib
├── modules
|   ├── misc.js
|   ├── someFunctions.js
├── app.js
├── index.html
├── package.json
├── webpack.config.js
└── webserver.js   
 

paquete.json

{
  "name": "webpack-example-with-nodejs",
  "version": "1.0.0",
  "description": "Example using webpack code-splitting with some Node.js to support the example",
  "main": "webserver.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "@Gun",
  "license": "ISC",
  "devDependencies": {
    "body-parser": "^1.17.1",
    "express": "^4.15.2",
    "http": "0.0.0",
    "morgan": "^1.8.1",
    "multer": "^1.3.0",
    "webpack": "^2.4.1"
  }
}
 

webpack.config.js

var path = require('path'); // used to get context

module.exports = {
    context: path.join(__dirname, 'app'), // resolves entry below, must be absolute path
    entry: './app.js', // entry point or loader for the application
    output: {
        path: path.join(__dirname, 'app/lib'), // express static folder is at /app/lib
        filename: '[name].bundle.js', // the file name of the bundle to create.  [name] is replaced by the name of the chunk (code-splitting)
        publicPath: 'static' // example uses express as the webserver
    }
};
 

servidor web.js

var express = require('express'),
    path = require('path'),
    bodyParser = require('body-parser'),
    multer = require('multer')()
    logger = require('morgan'),
    fs = require('fs'),
    http = require('http');

var app = express();
var port = 31416;

app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(logger('short'));
app.use('/jsBundles',express.static('lib'));
app.get('/', function(request, response){
    response.sendFile(__dirname + '/index.html');
});

var server = http.createServer(app).listen(port, function(){
    console.log("I feel a disturbance in the port:" + port);
});
 

index.html

<!DOCTYPE html>
<html>
    <body>
        <div id="someValue"><label for="num">Enter a number:</label><input id="num" /></div>
        <div class="buttonList">
            <ul>
                <li><button id="doubleIt">double it</button></li>
                <li><button id="tripleIt">triple it</button></li>
            </ul>
        </div>
        <div id="someOtherValue">
            And the count shall be: <span id="theCount"></span>
        </div>
        <script src="/jsBundles/main.bundle.js"></script>        
    </body>
</html>
 

app.js

require(['./modules/someFunctions'],function(){
        window.onload = function(){
                var someFunctions  = require('./modules/someFunctions');             
                document.getElementById('doubleIt').onclick = function(){
                        var num = document.getElementById('num').value;
                        document.getElementById('theCount').innerHTML = someFunctions.Double(num);
                };

                document.getElementById('tripleIt').onclick = function(){
                        var num = document.getElementById('num').value;
                        document.getElementById('theCount').innerHTML = someFunctions.Triple(num);
                };
        };
});
 

misc.js

var self = {};
self.isNumber = function(value){
    // http://stackoverflow.com/questions/9716468/is-there-any-function-like-isnumeric-in-javascript-to-validate-numbers
    return !isNaN(parseFloat(value)) && isFinite(value);
};
module.exports = self;
 

someFunctions.js

require(['./misc'], function(){
    var misc= require('./misc');

    var self = {};
    self.Double = function(value){
        if(!misc.isNumber(value)){
            return 0;
        };
        return value*2;
    }

    self.Triple = function(value){
        if(!misc.isNumber(value)){
            return 0;
        };
        return value*3;
    }

    module.exports = self;
});
 

NOTA

ejecute npm i --save-dev para instalar dependencias

ejecutar el nodo. \ node_modules \ webpack \ bin \ webpack.js una vez que las dependencias estén instaladas

ejecute el nodo webserver.js para iniciar el servidor

Ejemplo simple de webpack

El mínimo requerido para usar Webpack es el siguiente comando:

webpack ./src/index.js ./dist/bundle.js

// this is equivalent to:

webpack source-file destination-file
 

El paquete web tomará el archivo de origen, compilará el destino de salida y resolverá las dependencias en los archivos de origen.

Webpack, React JSX, Babel, ES6, configuración simple

Asegúrese de instalar las dependencias npm correctas (babel decidió dividirse en un montón de paquetes, algo que ver con las "dependencias de pares"):

npm install webpack webpack-node-externals babel-core babel-loader babel-preset-react babel-preset-latest --save

webpack.config.js :

module.exports = {
    context: __dirname, // sets the relative dot (optional)
    entry: "./index.jsx",
    output: {
        filename: "./index-transpiled.js"
    },
    module: {
        loaders: [{
            test: /\.jsx$/,
            loader: "babel?presets[]=react,presets[]=latest" // avoid .babelrc
        }]
    }, // may need libraryTarget: umd if exporting as a module
    externals: [require("webpack-node-externals")()], // probably not required
    devtool: "inline-source-map"
};
 

webpack-node-externals es una función que escanea sus node_modules y garantiza que no se compilen y agrupen junto con su código de front-end, aunque asegura que el paquete conserva la referencia a ellos. Esto ayuda a una transpilación más rápida, ya que no está recodificando bibliotecas.