Webpack docs state that output.publicPath is:
The output.path from the view of the JavaScript.
Could you please elaborate on what this actually means?
I use output.path and output.filename to specify where Webpack should output the result, but I’m not sure what to put in output.publicPath and whether it is required.
module.exports = {
output: {
path: path.resolve("./examples/dist"),
filename: "app.js",
publicPath: "What should I put here?"
}
}
output.path
Local disk directory to store all your output files (Absolute path).
Example: path.join(__dirname, "build/")
Webpack will output everything into localdisk/path-to-your-project/build/
output.publicPath
Where you uploaded your bundled files. (absolute path, or relative to main HTML file)
Example: /assets/
Assumed you deployed the app at server root http://server/.
By using /assets/, the app will find webpack assets at: http://server/assets/. Under the hood, every urls that webpack encounters will be re-written to begin with "/assets/".
src="picture.jpg" Re-writes ➡ src="/assets/picture.jpg"
Accessed by: (http://server/assets/picture.jpg)
src="/img/picture.jpg" Re-writes ➡ src="/assets/img/picture.jpg"
Accessed by: (http://server/assets/img/picture.jpg)
When executed in the browser, webpack needs to know where you'll host the generated bundle. Thus it is able to request additional chunks (when using code splitting) or referenced files loaded via the file-loader or url-loader respectively.
For example: If you configure your http server to host the generated bundle under /assets/ you should write: publicPath: "/assets/"
the publicPath is just used for dev purpose, I was confused at first time I saw this config property, but it makes sense now that I've used webpack for a while
suppose you put all your js source file under src folder, and you config your webpack to build the source file to dist folder with output.path.
But you want to serve your static assets under a more meaningful location like webroot/public/assets, this time you can use out.publicPath='/webroot/public/assets', so that in your html, you can reference your js with <script src="/webroot/public/assets/bundle.js"></script>.
when you request webroot/public/assets/bundle.js the webpack-dev-server will find the js under the dist folder
Update:
thanks for Charlie Martin to correct my answer
original: the publicPath is just used for dev purpose, this is not just for dev purpose
No, this option is useful in the dev server, but its intention is for asynchronously loading script bundles in production. Say you have a very large single page application (for example Facebook). Facebook wouldn't want to serve all of its javascript every time you load the homepage, so it serves only whats needed on the homepage. Then, when you go to your profile, it loads some more javascript for that page with ajax. This option tells it where on your server to load that bundle from
filename specifies the name of file into which all your bundled code is going to get accumulated after going through build step.
path specifies the output directory where the app.js(filename) is going to get saved in the disk. If there is no output directory, webpack is going to create that directory for you.
for example:
module.exports = {
output: {
path: path.resolve("./examples/dist"),
filename: "app.js"
}
}
This will create a directory myproject/examples/dist and under that directory it creates app.js, /myproject/examples/dist/app.js. After building, you can browse to myproject/examples/dist/app.js to see the bundled code
publicPath: "What should I put here?"
publicPath specifies the virtual directory in web server from where bundled file, app.js is going to get served up from. Keep in mind, the word server when using publicPath can be either webpack-dev-server or express server or other server that you can use with webpack.
for example
module.exports = {
output: {
path: path.resolve("./examples/dist"),
filename: "app.js",
publicPath: path.resolve("/public/assets/js")
}
}
this configuration tells webpack to bundle all your js files into examples/dist/app.js and write into that file.
publicPath tells webpack-dev-server or express server to serve this bundled file ie examples/dist/app.js from specified virtual location in server ie /public/assets/js. So in your html file, you have to reference this file as
<script src="public/assets/js/app.js"></script>
So in summary, publicPath is like mapping between virtual directory in your server and output directory specified by output.path configuration, Whenever request for file public/assets/js/app.js comes, /examples/dist/app.js file will be served
You can use publicPath to point to the location where you want webpack-dev-server to serve its "virtual" files. The publicPath option will be the same location of the content-build option for webpack-dev-server. webpack-dev-server creates virtual files that it will use when you start it. These virtual files resemble the actual bundled files webpack creates. Basically you will want the --content-base option to point to the directory your index.html is in. Here is an example setup:
//application directory structure
/app/
/build/
/build/index.html
/webpack.config.js
//webpack.config.js
var path = require("path");
module.exports = {
...
output: {
path: path.resolve(__dirname, "build"),
publicPath: "/assets/",
filename: "bundle.js"
}
};
//index.html
<!DOCTYPE>
<html>
...
<script src="assets/bundle.js"></script>
</html>
//starting a webpack-dev-server from the command line
$ webpack-dev-server --content-base build
webpack-dev-server has created a virtual assets folder along with a virtual bundle.js file that it refers to. You can test this by going to localhost:8080/assets/bundle.js then check in your application for these files. They are only generated when you run the webpack-dev-server.
in my case,
i have a cdn,and i am going to place all my processed static files (js,imgs,fonts...) into my cdn,suppose the url is http://my.cdn.com/
so if there is a js file which is the orginal refer url in html is './js/my.js'
it should became http://my.cdn.com/js/my.js in production environment
in that case,what i need to do is just set publicpath equals http://my.cdn.com/
and webpack will automatic add that prefix
There are lots of good answers here, so I'll focus on output.publicPath: 'auto'.
Say when you build your project you get the next folder structure:
dist/blog/index.html
dist/app.js
dist/app.css
dist/index.html
In this case, both our index.html files have to have a correct path to our app.js and app.css (next - assets). Let's consider the next scenarios:
publicPath: '' or publicPath: '/':
When hosted on a server both point to the root of the website (ex. https://localhost:8080/), so everything works fine.
But should you try to open them locally, blog/index.html won't have a correct path to the assets. In case of publicPath: '' assets will be searched in the blog/ folder since that's where the relative path is pointing to. index.html still has the correct path to assets.
And in case of publicPath: '/', / points to the root of the filesystem, so neither of our index.html files will have a correct path to assets.
publicPath: 'auto':
In this case, both our index.html files will have relative paths to the assets. So, blog/index.html will be pointing to ../app.css, and index.html will be pointing to app.css.
The webpack2 documentation explains this in a much cleaner way:
https://webpack.js.org/guides/public-path/#use-cases
webpack has a highly useful configuration that let you specify the base path for all the assets on your application. It's called publicPath.
publicPath is used by webpack for the replacing relative path defined in your css for refering image and font file.
Related
I am trying to migrate to TypeScript, where I did not write any .ts files yet. The generated code in the dist folder does not include non-js files like .xml, .json, etc. The problem is now that when running the application and tying to have access to those files, __dirname has the path to the dist foler.
the code is something like this
const file= fs.readFileSync(path.join(__dirname, '../../folder', 'file.sql')).toString();
Is this the expected behavior? How should I handle this?
It is the expected behaviour as the __dirname points to where you are. The solution for this would be to either copy the files or assume that you are going to have a dist folder.
I've stumbled upon several pages about importing external files into a Nuxt project, but what I'm trying to do is the opposite.
I have two sites or apps: Site A and Site B. Site A is the main one built using Nuxt. Site B is a simple site with static pages, not using Nuxt or Vue.
Site A has a JavaScript file, let's say its path is /lib/common.js. I use it extensively on Site A. And I also want to use it on Site B.
However, when I do yarn generate on Site A, all my JS files, including common.js, get bundled into a JavaScript chunk files, and each file is named with a hash of the content of the file. For example, /lib/common.js, /lib/util.js get bundled up as /dist/_nuxt/05443d2eb25fc282bbea.js while /lib/user.js is bundled as /dist/_nuxt/1326d0fc90870f9f4ca4.js.
That means:
the file I want to use is actually bundled with other files into the same package, so if I load that file, I have to load extra code with it and,
I can't really predict the name of that file.
Is there a way for me to tell Nuxt, or most likely Webpack, to single out /lib/common.js into its own bundle and then save it as /dist/_nuxt/lib/common.js instead of a hash, so the filename is more predictable?
You would need to create a separate webpack configuration for that single file to achieve the desired result as only one output configuration per configuration file is supported[0].
[0] https://github.com/webpack/docs/wiki/configuration#output
Example common library configuration common.lib.config.js
var path = require('path');
module.exports = {
entry: './lib/common.js',
output: {
path: path.resolve(__dirname, 'dist/_nuxt/lib'),
filename: 'common.js'
}
};
And build it with webpack --config common.lib.config.js
I'm using Webpack 2's automatic code splitting to divide up my application into multiple output files. My webpack.config.js file is:
const path = require('path');
module.exports = {
entry: './app.js',
output: {
filename: '[name].js',
path: path.join(__dirname, 'build'),
}
}
This correctly builds my app.js file into the build folder along with the other module files. The build directory has the following files:
main.js
0.js
My issue is that when main.js requests 0.js, it does so at the root of my application, rather than relative to its current location. So it's basically trying to load localhost:8000/0.js when it should be loading localhost:8000/build/0.js. How can I configure my project so that my project correctly loads split modules relative to my main entry point's path?
By default Webpack will load modules from the root directory. You can configure what folder Webpack will load from by declaring the __webpack_public_path__ variable in your entry point. So, for this scenario, you could use:
__webpack_public_path__ = 'build/';
Webpack will then load modules from the build folder. However this is still relative to the root. In order to tell Webpack to load scripts relative to the entry point, you can dynamically configure __webpack_public_path__ to the directory of your entry point script with:
const scriptURL = document.currentScript.src;
__webpack_public_path__ = scriptURL.slice(0, scriptURL.lastIndexOf('/') + 1);
document.currentScript is well supported in evergreen browsers, but is not supported in Internet Explorer.
Assuming I want to (my boss is making me) use webpack, and I have a file structure like:
Wherein builds is where webpack outputs the result of bundling/compiling the src folder, how do I then have index.html point to bundle.js if it is present on a server, i.e. which folder do I expose via express.static()? What is the correct "webpack" way to do this with i.e. a simple webpack.config like below? Am I missing something fundamental about how this works? Ideally I'd like to do something like the following in my index.html
<html>
<script src='bundle.js'></script>
<!-- bundle.js spits a bunch of CSS into the html, dynamically builds elements, etc -->
</html>
Or is that not how things are done in webpack?
webpack.config.js
module.exports = {
entry: './src/index.js',
output: {
path: 'builds',
filename: 'bundle.js',
},
module: {
loaders: [
{ test: /\.css$/,
loader: "style!css"
}
]
}
};
I have tried to figure this out via the docs and this oft-linked article.
Since its a good practice to not expose any of your directory structure to end users as it creates a chance for web exploitation, nodejs with express has a mechanism to handle that. What you can do is expose this way your webpack
app.use('/buidscript', express.static(__dirname + '/builds/'));
Then, any browser requests from /buidscript/bundle.js will automatically be fetched from your builds directory.
<script src='/buidscript/bundle.js'></script>
Now you can gather your thoughts around this to make it in whatever way you would like.
For your ideal case which you are looking for
app.use(express.static(__dirname + '/builds'));
Now you can use
<script src='bundle.js'></script>
as any request bundle.js will be searched in exposed static builds directory
Add it to package.json's script
“scripts”: {
“start”: “webpack-dev-server --content-base build/ --inline --hot”,
...
}
// Use it by running
$ npm start
Now this will build your bundle.js before running index.html in development mode.
--content-base build/
will server the static files in your build folder. so then you can make use of bundle.js directly. It will look for any file changes and recompile bundle.js
I'm doing the React tutorial (http://www.tutorialspoint.com/reactjs/reactjs_components.htm) and I'm confused as to what webpack entry and output filename do exactly?
In the example they have created a file index.html and App.jsx. However, in the HTML they have "". But no index.js file has been created. Although, the output filename in the webpack.config file is index.js
What I believe is happening, is the entry point is where the server tells client to start out at and the output filename (index.js) is where the server is writing out all of the necessary data that will be sent to the the client... is this right?
Yes that is basically correct you have an entry file where webpack starts to require and compile all other files from and it will export the output/ bundled file to where every you want it to go. Most of the time this compiled and minified depending on which loaders you are using.
entry: 'index.js',
output: {
filename: 'bundle.js',
path: './app/assets'
},