@webdiscus/pug-loader
Advanced tools
Pug loader renders Pug files into HTML or compiles them into a template function.
The Pug Loader renders Pug templates into HTML or compiles it into a template function.
:escape :code :highlight :markdown with highlighting of code blocksWarning
Until today, 2024, only this Pug loader is maintained. Please support this project by giving it a star ā.
All other Pug loaders are dead and have not been maintained for a long time:
- pug-loader - last update 2018 (6 years ago)
- pug-html-loader - last update 2016 (8 years ago)
- pug-plain-loader - last update 2020 (4 years ago)
- simple-pug-loader - last update 2021 (3 years ago)
Note
Instead of
html-webpack-pluginrecommended to use pug-plugin or html-bundler-webpack-plugin .The Pug Plugin allow to use a template as an entrypoint and generates static HTML or template function from Pug template containing source files of scripts, styles, images, fonts and other resources, similar to how it works in Vite.
Please see usage examples and the demo app Hello World.
Choose your way:
The pug-plugin contains already the pug and pug-loader packages. For details and examples please see the pug-plugin site.
Install the pug-plugin:
npm install pug-plugin --save-dev
Install additional packages for styles:
npm install css-loader sass-loader sass --save-dev
Start with a Pug template. Add the link and script tags.
You can include asset source files such as SCSS, JS, images, and other media files directly in a Pug template.
The plugin resolves script(src="...") link(href="...") and img(src="..." srcset="...") that references your script, style and image source files.
For example, there is the template ./src/views/home.pug:
html
head
//- variable from Webpack config
title= title
//- relative path to favicon source file
link(href="./favicon.ico" rel="icon")
//- relative path to SCSS source file
link(href="./style.scss" rel="stylesheet")
//- relative path to JS source file -->
script(src="./main.js" defer="defer")
body
h1 Hello World!
//- relative path to image source file
img(src="./picture.png")
All source filenames should be relative to the entrypoint template, or you can use Webpack alias. The references are rewritten in the generated HTML so that they link to the correct output files.
The generated HTML contains URLs of the output filenames:
<html>
<head>
<title>Homepage</title>
<link href="img/favicon.3bd858b4.ico" rel="icon" />
<link href="css/style.05e4dd86.css" rel="stylesheet" />
<script src="js/main.f4b855d8.js" defer="defer"></script>
</head>
<body>
<h1>Hello World!</h1>
<img src="img/picture.58b43bd8.png" />
</body>
</html>
If the entry plugin option is a path, the plugin finds all templates automatically
and keep the same directory structure in the output directory.
If the entry plugin option is an object, the key is an output filename without .html extension and the value is a template file.
Very simple and clear webpack.config.js, all relevant settings are in one place, in plugin options:
const path = require('path');
const PugPlugin = require('pug-plugin');
module.exports = {
output: {
path: path.join(__dirname, 'dist/'),
},
plugins: [
new PugPlugin({
// automatically processing all templates in the path
entry: 'src/views/',
// - OR - define many pages manually (key is output filename w/o `.html`)
entry: {
// simple page config w/o variables
index: 'src/views/home.pug', // => dist/index.html
// advanced page config with variables
'news/sport': { // => dist/news/sport.html
import: 'src/views/news/sport/index.pug', // template file
data: { title: 'Sport news' }, // pass variables into template
},
},
data: {...}, // pass global data into all templates
js: {
// JS output filename, used if `inline` option is false (defaults)
filename: 'js/[name].[contenthash:8].js',
//inline: true, // inlines JS into HTML
},
css: {
// CSS output filename, used if `inline` option is false (defaults)
filename: 'css/[name].[contenthash:8].css',
//inline: true, // inlines CSS into HTML
},
})
],
module: {
rules: [
{
test: /\.(s?css|sass)$/,
use: ['css-loader', 'sass-loader']
},
{
test: /\.(ico|png|jp?g|webp|svg)$/,
type: 'asset/resource',
generator: {
filename: 'img/[name].[hash:8][ext][query]',
},
},
],
},
};
Note
No additional plugins or loader required.
Warning
This way is not recommended!
Install the pug-loader only if you use the html-webpack-plugin.
npm install @webdiscus/pug-loader html-webpack-plugin --save-dev
Install additional plugin to extract CSS:
npm install mini-css-extract-plugin --save-dev
Using the html-webpack-plugin you should require a source asset file in the Pug template.
For example, there is the template ./src/views/home.pug:
html
head
//- variable from plugin options, very ugly access
title= htmlWebpackPlugin.options.data.title
//- relative path to favicon source file
link(href=require("./favicon.ico") rel="icon")
//- JS and CSS will be injected into HTML automatically, anywhere here
//- Note: you have no control over the position or order of injected files
body
h1 Home
//- relative path to image source file
img(src=require("./picture.png"))
Very complex, terrible and ugly webpack.config.js, enjoy:
const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const MiniCssExtractPlugin = require("mini-css-extract-plugin");
module.exports = {
output: {
path: path.join(__dirname, 'dist/'),
// JS output filename must be defined only here
filename: 'js/[name].[contenthash:8].js',
},
entry: {
// Source files of styles and scripts must be defined here, separately from their templates.
// How to bind each generated bundle to the HTML page?
// Answer: using the `chunks` option hell!
index: ['./src/views/home/main.js', './src/views/home/style.scss'],
'news/sport': ['./src/views/news/sport/main.js', './src/views/news/sportstyle.scss'],
},
plugins: [
// For one page must be initialized the plugin instance.
new HtmlWebpackPlugin({
template: path.join(__dirname, 'src/views/home/index.pug'),
// HTML output filename
filename: 'index.html',
// bind the generated JS and CSS files to this template via chunks,
// this is a very terrible "crutch"
chunks: ['index'],
// pass variables into template,
// access in template is very ugly: `htmlWebpackPlugin.options.data.title`
data: { title: 'Home' }
}),
// For other page must be initialized yet one plugin instance.
// It's very very bad practice and ugly syntax!
new HtmlWebpackPlugin({
template: path.join(__dirname, 'src/views/news/sport/index.pug'),
// HTML output filename
filename: 'news/sport.html',
// bind the generated JS and CSS files to this template via chunks option,
// you're not confused yet in chunks?
chunks: ['news/sport'],
// pass variables into template,
// access in template is very ugly: `htmlWebpackPlugin.options.data.title`
data: { title: 'Sport news' }
}),
// ... Do you have the joy of adding yet one page using the HtmlWebpackPlugin?
// No? Then try to use the `pug-plugin`!
// Yet one plugin to extract CSS and inject one into HTML.
new MiniCssExtractPlugin({
// CSS output filename defined in another place, here
filename: 'css/[name].[contenthash:8].css',
}),
],
module: {
rules: [
// requires to define the pug loader
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
},
{
test: /\.(s?css|sass)$/,
// requires additional MiniCssExtractPlugin loader
use: [MiniCssExtractPlugin.loader, 'css-loader', 'sass-loader'],
},
{
test: /\.(png|jpe?g|ico)/,
type: 'asset/resource',
generator: {
filename: 'img/[name].[hash:8][ext]',
},
},
],
},
};
A Pug template can be used in JavaScript code as template function with custom data.
Install the pug-loader.
npm install @webdiscus/pug-loader --save-dev
Change your webpack.config.js according to the following minimal configuration:
const path = require('path');
module.exports = {
output: {
path: path.join(__dirname, 'public/'),
publicPath: '/', // must be defined any path, `auto` is not supported yet
},
entry: {
index: './src/index.js', // load a Pug template in JS
},
module: {
rules: [
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
},
],
},
};
Load a Pug template in JavaScript. Optional you can pass any data into generated template function.
./src/index.js
const tmpl = require('template.pug');
const html = tmpl({
myVar: 'value',
});
See original description of options
basedirType: string Default: /
The root directory of all absolute inclusion.
doctypeType: string Default: html
Specifies the type of document. See available doctypes.
selfType: boolean Default: false
Use the self as namespace for the local variables in template. It will speed up the compilation, but for access to variable, e.g. myVariable, you must write self.myVariable.
globalsType: Array<string> Default: []
Add a list of global names to make accessible in templates.
filtersType: object Default: undefined
Filters let to use other languages in Pug templates.
You can add your own custom filters to Pug.
See the build-in filters.
pluginsType: Array<Object> Default: []
Plugins allow to manipulate Pug tags, template content in compile process.
How it works see in source of pug.
compileDebugType: boolean Default: false
Includes the function source in the compiled template to improve error reporting.
prettyType: boolean Default: false
This option is deprecated by pugjs and always is false. Don't use it.
modeWarning
Since the version
2.11.0, themethodoption name is renamed intomode.
Themethodoption is DEPRECATED.The
methodvalues are renamed:
pug-compile=>compilepug-render=>renderThe
methodoption name and old values can be used until the next major version.
Type: string Default: compile
Values:
compile the Pug template compiles into a template function and in JavaScript can be called with variables to render into HTML at runtime. ?compile. Can be used if the mode is render. render the Pug template renders into HTML at compile time and exported as a string.
All required resource will be processed by the webpack and separately included as added strings wrapped to a function. ?render. Can be used if the mode is compile or is not defined in options. html the template renders into a pure HTML string at compile time. The mode need an addition loader to handles the HTML. html-loader see usageAsset resources such as
img(src=require('./image.jpeg'))are handled at compile time by the webpack using asset/resource.
esModuleType: Boolean Default: false
Enable / disable ESM syntax in generated JS modules.
Values:
true The pug-loader generates JS modules with the ESM syntax. import html from 'template.pug';. false defaults. The pug-loader generates JS modules with the CommonJS modules syntax. const html = require('template.pug'). false for compatibility with the JS modules that is generated by the original pug-loader.Note: The option
esModuleis irrelevant for thehtmlmode, because it returns a pure HTML string.
š” For generates smaller and faster template function, it is recommended to use following options:
{
mode: 'render',
esModule: true,
}
dataType: Object Default: {}
The custom data will be passed in all Pug templates, it can be useful by pass global data.
ā ļø Limitation with the
compilemode.
A string representing the source code of the function is limited by thefunction.toString(), see examples.
For native work of the function passed via thedataloader option, use therendermode.
embedFiltersType: Object Default: undefined
Enable embedded Pug filters.
To enable a filter, add the following to the pug-loader options:
{
embedFilters: {
<FILTER_NAME> : <FILTER_OPTIONS> | <TRUE>,
}
}
Where <FILTER_NAME> is the name of a built-in filter, the available filters see below.
The filter can have options <FILTER_OPTIONS> as an object.
If the filter has no options, use true as an option to enable the filter.
See the complete information on the pug filter site and in the sources.
watchFilesType: Array<RegExp|string> Default: [ /\.(pug|jade|js.{0,2}|.?js|ts.?|md|txt)$/i ]
This option allows you to configure watching of individual resolved dependencies.
The default value enables watching of Pug, scripts, markdown, etc.
and ignores images, styles to avoid double processing via Webpack and via Pug's ist own compiler.
In some cases, you may want to use one SCSS file for styling
and include another SCSS file with a Pug filter for code syntax highlighting.
The first SCSS file is watched via Webpack, but changes in the second will be ignored.
For example, we want to watch for changes in all source examples such as main.c, colors.scss, etc. from the /code-samples/ folder,
to do this, add to the watchFiles option:
{
watchFiles: [
/\\/code-samples\\/.+$/,
]
}
For watching of a file, add full path, for example:
{
watchFiles: [
path.join(__dirname, './src/config.yml'),
]
}
Note: Default value of
watchFileswill be extends, not overridden.
compile modeThis mode is used by default.
In JavaScript the required template will be compiled into template function.
In webpack config add to module.rules:
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
options: {
mode: 'compile' // default mode `compile` can be omitted
}
}
In JavaScript, the result of require() is a template function. Call the template function with some variables to render it to HTML.
const tmpl = require('template.pug');
const html = tmpl({ key: 'value' }); // the HTML string
To render the Pug direct into HTML, use the query parameter ?render.
// compile into template function, because loader option 'mode' defaults is 'compile'
const tmpl = require('template.pug');
const html = tmpl({ key: 'value' });
// render the Pug file into HTML, using the parameter 'render'
const html2 = require('template2.pug?render');
Note: If the query parameter
renderis set, then will be used rendering for this template, independent of the loader optionmode. Variables passed in template with moderenderwill be used at compile time.
render modeThis mode will render the Pug into HTML at compile time.
In webpack config add to module.rules:
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
options: {
mode: 'render',
},
}
In JavaScript the result of require() is an HTML string.
const html = require('template.pug'); // the HTML string
To generate a template function for passing the data in Pug at realtime, use the query parameter ?compile.
// render into HTML, because loader option 'mode' is 'render'
const html = require('template.pug');
// compile into template function, using the parameter 'compile'
const tmpl2 = require('template2.pug?compile');
const html2 = tmpl2({ ... });
html modeThis mode will render the Pug to pure HTML and should be used with an additional loader to handle HTML.
In webpack config add to module.rules:
{
test: /\.pug$/,
use: [
{
loader: 'html-loader',
options: {
esModule: false, // allow to use the require() for load a template in JavaScript
},
},
{
loader: '@webdiscus/pug-loader',
options: {
mode: 'html',
},
},
],
}
In JavaScript the result of require() is an HTML string:
const html = require('template.pug'); // the HTML string
The goal of built-in filters is to use most useful lightweight filters without installation.
The built-in filters are custom filters that are collected in one place.
These filters can be simply enabled via an option.
See the complete information on the pug filter site and in the sources.
Defaults all built-in filters are disabled. Enable only filters used in your Pug templates.
:escapeThe filter replaces reserved HTML characters with their corresponding HTML entities to display these characters as text.
Filter options: none.
Enable the filter:
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
options: {
// enable built-in filters
embedFilters: {
escape: true, // enable the :escape filter
},
},
},
Using the :escape filter in pug:
pre: code.language-html
:escape
<h1>Header</h1>
Generated HTML:
<pre>
<code class="language-html">
<h1>Header</h1>
</code>
</pre>
Inline syntax:
p.
The #[:escape <html>] element is the root element.<br>
Inside the #[:escape <html>] element there is a #[:escape <body>] element.
Generated HTML:
<p>The <html> element is the root element.<br>
Inside the <html> element there is a <body> element.</p>
For more information and examples, see the :escape site.
:codeThe filter wraps a content with the <code> tag.
Filter options:
className {string} The class name of the code tag. For example, the prismjs use the language-* as class name in <code> for styling this tag.Enable the filter:
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
options: {
// enable built-in filters
embedFilters: {
// enable the :code filter
code: {
className: 'language-', // class name of `<code>` tag, needed for `prismjs` theme
},
},
},
},
Usage examples:
Pug: #[:code function() { return true }]
Display: function() { return true }
Pug: #[:code:escape <div>]
Display: <div>
Pug: #[:code:highlight(html) <div class="container">content</div>]
Display highlighted code: <div class="container">content</div>
For more information and examples, see the :code site.
:highlightThe filter highlights code syntax.
Filter options:
verbose {boolean} Enable output process info in console.use {string} The name of a highlighting npm module. The module must be installed. Currently, is supported the prismjs only.Enable the filter:
{
embedFilters: {
highlight: {
verbose: true,
use: 'prismjs',
},
},
}
Usage example:
pre.language-: code
:highlight(html)
<!-- Comment -->
<h1>Header</h1>
<p>Text</p>
For more information and examples, see the :highlight site.
:markdownThe filter transform markdown to HTML and highlights code syntax.
The :markdown filter require the markdown-it and prismjs modules:
npm install -D markdown-it prismjs
Enable the filter:
{
test: /.pug$/,
loader: '@webdiscus/pug-loader',
options: {
// enable built-in filters
embedFilters: {
// enable :markdown filter
markdown: {
// enable highlighting in markdown
highlight: {
verbose: true,
use: 'prismjs',
},
},
},
},
},
The highlight options:
verbose {boolean} Enable output process info in console. Use it in development mode only. Defaults is false.use {string} The name of a highlighting npm module. The module must be installed. Currently, is supported the prismjs only.Usage example:
:markdown
_HTML_
```html
<!-- Comment -->
<div class="container">
<p>Paragraph</p>
</div>
```
_JavaScript_
```js
const arr = [1, 2, 'banana'];
```
Display highlighted code blocks:
HTML
<!-- Comment --> <div class="container"> <p>Paragraph</p> </div>JavaScript
const arr = [1, 2, 'banana'];
For more information and examples, see the :markdown site.
By default, the Pug file is compiled as template function, into which can be passed an object with template variables.
const tmpl = require('template.pug');
const html = tmpl({
myVar: 'value',
foo: 'bar'
});
But how pass variables in template which is rendered into HTML?
Variables can be passed with query parameters.
const html = require('template.pug?myVar=value&foo=bar');
or as a JSON object:
const html = require('template.pug?' + JSON.stringify({ myVar: 'value', foo: 'bar' }));
Use variables myVar and foo in Pug template.
div The value of "myVar": #{myVar}
div The value of "foo": #{foo}
Usage of query parameters is legal and official documented feature of webpack loader.
Pass myData object via query.
entry: {
about: './src/pages/about.pug?myData=' + JSON.stringify({ title: 'About', options: { uuid: 'abc123' } })
}
Use the object myData in Pug template.
html
head
title= myData.title
body
div UUID: #{myData.options.uuid}
To pass global data to all Pug templates, add the loader options data as any object.
module.exports = {
module: {
rules: [
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
options: {
data: {
htmlLang: 'en-EN',
getKeywords: () => {
const keywords = ['webpack', 'pug', 'loader'];
return keywords.join(',');
}
}
}
},
],
},
};
Use the custom data and function in pug.
html(lang=htmlLang)
head
meta(name="keywords" content=getKeywords())
body
The user data can be passed into Pug template with two ways:
module.exports = {
plugins: [
new HtmlWebpackPlugin({
title: 'The some page', // avaliable in Pug as `htmlWebpackPlugin.options.title`
template: path.join(__dirname, 'src/index.pug?' + JSON.stringify({ myVar: 'value' })), // avaliable as `myVar`
filename: 'index.html',
}),
],
module: {
rules: [
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
},
],
},
};
Use the passed variables htmlWebpackPlugin.options and myVar in Pug template:
html
head
title= htmlWebpackPlugin.options.title
body
div= myVar
You can load data directly in pug.
data.json
[
{ "id": 1, "name": "abc" },
{ "id": 2, "name": "xyz" }
]
Require the JSON file in pug.
- var myData = require('./data.json')
each item in myData
div #{item.id} #{item.name}
To handle resources in Pug use the require() function:
img(src=require('./path/to/images/logo.png'))
For images, add the following rule to the webpack module:
module.exports = {
module: {
rules: [
{
test: /\.(png|jpg|jpeg|svg|ico)/,
type: 'asset/resource',
generator: {
filename: 'assets/images/[name].[hash:8][ext]',
},
},
]
},
};
For fonts, add the following rule to the webpack module:
module.exports = {
module: {
rules: [
{
test: /\.(woff2|woff|ttf|svg|eot)/,
type: 'asset/resource',
generator: {
filename: 'assets/fonts/[name][ext]',
},
},
]
},
};
More information about asset-modules see here.
Example of dynamic interpolation of image src in pug:
- files = ['image1.jpeg', 'image2.jpeg', 'image3.jpeg']
each file in files
img(src=require(`./path/to/${file})`)
Recommended to use the Webpack alias to avoid relative paths in Pug.
For example, use the alias Images as path to images:
module.exports = {
resolve: {
alias: {
Images: path.join(__dirname, 'src/assets/images/'),
},
}
};
The alias may be used with prefixes ~ or @.
For example, all following aliases resolves the same path:
img(src=require('Images/logo.png'))
img(src=require('~Images/logo.png'))
img(src=require('@Images/logo.png'))
Using TypeScript you can define an alias in tsconfig.json.
But for performance is recommended to use the Webpack alias.
For example, add to tsconfig.json an alias to the paths option:
tsconfig.json
{
"compilerOptions": {
"paths": {
"Images/*": ["assets/images/*"]
}
}
}
Warning
The
compilemode can resolve the filename as a string only and the filename can't be interpolated.img(src=require('Images/logo.png')) // It works. - const file = 'logo.png' img(src=require('Images/' + file)) // ERROR: Can't be resolved with 'compile' mode.
You can use the Webpack context for a short path in Pug.
Define in Webpack config the context as path to sources:
module.exports = {
context: path.resolve(__dirname, 'src'),
};
For example, your images are under the path PROJECT_PATH/src/assets/images/,
then using the context you can use the root path (relative by context) anywhere:
img(src=require('/assets/images/logo.png'))
Note
You can use the
basediroption of pug-loader for same effect:module.exports = { module: { rules: [ { test: /\.pug$/, loader: '@webdiscus/pug-loader', options: { basedir: path.resolve(__dirname, 'src') }, }, ], }, };
The file in the current- or subdirectory MUST start with ./:
img(src=require('./path/to/logo.png'))
The file in the parent directory MUST start with ../:
img(src=require('../images/logo.png'))
Warning
Following relative path will be resolved with
renderandhtmlmodes, butNOTwithcompilemode:img(src=require('../../images/logo.png'))This is an interpolation limitation in Webpack.
You can use the filename as a variable.
Usage examples work with all modes:
- const file = 'logo.png'
img(src=require('./images/' + file))
img(src=require(`./images/${file}`))
img(src=require('../images/' + file))
img(src=require('Images/' + file)) // 'Images' is webpack alias
img(src=require(`Images/${file}`)
Warning
Limitation using the
compilemode:
the variableMUST NOTcontain a path, only a filename, because is interpolated at compile time.
For example, the 'compile' mode can't resolve following:- var file = '../images/logo.png' img(src=require(file))
Using a variable with render or html mode, the variable MAY contain a path, because is resolved at runtime.
Following example work only with render or html mode:
- const file = '../relative/path/to/logo.png'
img(src=require(file))
img(src=require('Images/' + file))
In current directory, the filename MUST start with ./:
- const file = './logo.png'
img(src=require(file))
Install:
npm i --save-dev @webdiscus/pug-loader pug-plugin-ng
In pug-loader can be used the optional pug-plugin-ng to allow unquoted syntax of Angular:
[(bananabox)]="val"
Create the file webpack.config.js in root directory of angular project:
module.exports = {
module: {
rules: [
{
test: /\.pug$/,
loader: '@webdiscus/pug-loader',
options: {
mode: 'render',
doctype: 'html',
plugins: [require('pug-plugin-ng')],
},
},
],
},
};
Bind the file webpack.config.js in the Angular config angular.json:
{
// ...
"projects": {
// ...
"architect": {
"build": {
// replace architect.build.builder with this value:
"builder": "@angular-builders/custom-webpack:browser",
// add the options:
"options": {
"aot": true,
"customWebpackConfig": {
"path": "./webpack.config.js" // the path to webpack.config.js
},
// ...
},
// ...
},
"serve": {
// replace architect.serve.builder with this value:
"builder": "@angular-builders/custom-webpack:dev-server",
"options": {
"browserTarget": "<app-name>:build"
},
// ...
},
// ...
},
},
},
In a component file, e.g. ./src/app/app.component.ts set the templateUrl with Pug file:
import { Component } from '@angular/core';
// the variable `description` will be passed into Pug template via resource query
const templateVars = '{"description": "Use Pug template with Angular."}';
@Component({
selector: 'app-root',
styleUrls: ['./app.component.css'],
templateUrl: './app.component.pug?' + templateVars,
})
export class AppComponent {
title = 'ng-app';
}
Create a Pug template, e.g. ./src/app/app.component.pug:
h1 Hello Pug!
p Description: #{description}
See the complete source of the example.
Install:
npm i --save-dev @webdiscus/pug-loader
Change your vue.config.js according to the following minimal configuration:
const { defineConfig } = require('@vue/cli-service');
// additional pug-loader options,
// e.g. to enable pug filters such as `:highlight`, `:markdown`, etc.
// see https://github.com/webdiscus/pug-loader#options
const pugLoaderOptions = {
};
module.exports = defineConfig({
transpileDependencies: true,
chainWebpack: (config) => {
// clear all existing pug loaders
const pugRule = config.module.rule('pug');
pugRule.uses.clear();
pugRule.oneOfs.clear();
// exclude `pug-loader` from the witchery of the baggy `thread-loader` that is used in production mode
const jsRule = config.module.rule('js');
jsRule.exclude.add(/pug-loader/);
},
configureWebpack: {
module: {
rules: [
{
test: /\.pug$/,
oneOf: [
// allow <template lang="pug"> in Vue components
{
resourceQuery: /^\?vue/u,
loader: '@webdiscus/pug-loader',
options: {
mode: 'html', // render Pug into pure HTML string
...pugLoaderOptions,
},
},
// allow import of Pug in JavaScript
{
loader: '@webdiscus/pug-loader',
options: {
mode: 'compile', // compile Pug into template function
...pugLoaderOptions,
},
},
],
},
],
},
},
});
For additional information see please the discussion: How to configure the plugin for both Vue and non-Vue usage?
Using Pug in Vue template
<template lang='pug'>
h1 Hello Pug!
p Use the '@webdiscus/pug-loader'
</template>
Note
You can use an indent for Pug code in Vue template.
Using Pug in JavaScript
App.vue
<template>
<div v-html='demo'></div>
</template>
<script>
// import Pug as template function
import demoTmpl from './views/demo.pug';
// define custom data used in Pug template
const locals = { colors: ['red', 'green', 'blue'] };
// pass custom data in Pug template
const demoHtml = demoTmpl(locals);
export default {
name: 'App',
data() {
return {
demo: demoHtml
}
}
}
</script>
demo.pug
each color in colors
div(style=`color: ${color}`) #{color}
Note: The
colorsis external variable passed from App.vue.
srcset in img tagimg(srcset=`${require('./image1.jpeg')} 320w, ${require('./image2.jpeg')} 640w` src=require('./image.jpeg'))
output
<img srcset="/assets/image1.f78b30f4.jpeg 320w, /assets/image2.f78b30f4.jpeg 640w" src="/assets/image.f78b30f4.jpeg">
Use the require() for CommonJS files in Pug templates.
The JS module say-hello.js
module.exports = function(name) {
return `Hello ${name}!`;
}
Use the module sayHello in Pug template.
- var sayHello = require('./say-hello')
h1 #{sayHello('pug')}
npm run test will run the unit and integration tests.
npm run test:coverage will run the tests with coverage.
2.11.0 (2024-02-16)
14.x of the markdown-it in filtersmode option. Use it instead of the DEPRECATED method option name.method option is renamed into mode.
The method option can be used until the next major version.mode option: compile, render, html.pug-compile, pug-render, pug-html method/mode names are deprecated!
This method/mode names can be used until the next major version.partial.pug?render&text=Hello%20World%21
will be parsed the text parameter as Hello World!.pug loader is used with html-webpack-plugin,
for reasons of humanity the support of the html-webpack-plugin still stay.FAQs
Pug loader renders Pug files into HTML or compiles them into a template function.
The npm package @webdiscus/pug-loader receives a total of 3,274 weekly downloads. As such, @webdiscus/pug-loader popularity was classified as popular.
We found that @webdiscus/pug-loader demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago.Ā It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
Security News
Research
A supply chain attack on Rspack's npm packages injected cryptomining malware, potentially impacting thousands of developers.
Research
Security News
Socket researchers discovered a malware campaign on npm delivering the Skuld infostealer via typosquatted packages, exposing sensitive data.