14 megs seems way too much. And 60 components shouldn't generate so much
output. I mean, look for example angular or material or similar, it
doesn't go nowhere close to that.
Yet without seeing your code, one could only speculate. Is your code available online somewhere?
Now, some ideas for how to tackle this. Ranging from regular to... Not regular :) There should be examples online for most of the suggestions, or ask a more specific question if one of the ideas here looks promising to you.
First things first, did you run webpack bundle analyzer to see what takes so much?
For
one, you have a lot of deps. Some of them seem to be big and might
contribute to the problem. If yes, maybe you can find a smaller
replacement. Also, I think there might be some suboptimal
coupling in your modules. I mean, if you have lazy routes, you would
ideally be able to render a minimal app shell, or even a bigger chunk of
an app with a lot less, and later load the heavy dependencies.
Additionally, you might be importing some things that really aren't necessary. E.g. you ave node-sass listed as dep, AFAIK you only use that if you wanna build some sass files, and I assume you don't do that lazily, on the client. But you might have an invalid webpack config that pulls this in.
If
nothing else , that's how you could identify better candidates for lazy
routes. Then in addition to that, push the lazy chunks through with
http2, if you can, you might gain a second or more on preparsing such
big bundles.
Additionally, your tree shaking might be a problem,
e.g. you could be importing the entirety of one of your deps where a
more direct import would do better. Two things might help you there. One
is to try to optimize with rollup. That might remove some of the extra
code. It might not pick up everything, but it could be just enough to
make the app startup time bearable.
Or a bit more on the edge there, you could, as Sander suggests, upgrade to Angular 6. It has some of this tree-shaking built in, but if it's really a problem, try enabling the (still pretty experimental) Angular Ivy compiler and see what happens. Of course, test heavily for bugs, but I think the bundles should go really small.
And by far the most "out there" suggestion I have is, maybe you can offload some of the heavy libs and compile them to Wasm, and only have an angular wrapper for the functionality. That helps in a few ways, splitting up what might be a thick part of the bundle, but also, Wasm has noticably better startup times than regular JavaScript (which is what your bundles are now), and with parsing 14 megs of code, skipping preparsing and other stages in here would definitely be noticable.
Of course, some of these ideas might depend on your target browsers and your skill level and similar. That's why I tried to range them from what I think would be the simplest and most efficient to the silliest that I would love to have to sort out simply because of the challenge :)
Good luck, and let us know how you are progressing!