modulex | A module registration and load library for browser | Server Side Rendering library

I realized that

You can use exec or eval to do that. So it would go roughly this way (for exec):

In an OOP world I would just use dependency injection retrieving classes implementing a specific interface, but in JS/TS I'm not sure it is viable.

Why not?

More than this, with JS/TS you are not restricted to use classes implementing a specific interface: you just need to define the interface (i.e. the module.exports) of your modules and respecting it in the libraries entries (vue build lib).

EDIT: reading comments probably I understood the request.

Each module should respect following interface (in the file which is the entry of the vue library)

The syntax of joins allows two uses: first, referencing a relation defined on the left-hand model by its (symbolic) name, or second, raw SQL. Neither method is actually impacted at all by the use of modules, because neither references the class of the model you're joining onto.

In your case, you probably want to set up a relation between orders and order types, like:

One way is building common.o prior building the modules by making common.o a prerequisite to the modules as both modules will consider common.o up to date, though there is still a race condition if building with --always-make since the modules won't check dates then. You can prevent it from happening by making common read-only during module build, failing any attempt of --always-make (assuming module makefile doesn't override permissions, which would be a weird thing to do). You do have to keep track of common contents used by modules though. Simple solution, best performance.

If you're feeling lazy you could make a bogus dependency between modules, e.g. all modules depend on moduleA. All modules will be built multithreaded, but the module all depend on won't be built at the same time as all the others. There is build performance degradation, true, but I'd expect it to be insignificant in most cases. For better performance you could experiment depending on modules with short build time or efficient internal multithreading. Simplest solution, good performance. Doesn't work with --always-make, resort to mentioned read-only strategy.

I've had some success building in separate source trees by copying modules and common to separate (build) folders and then build from there, but it complicates other things, and build performance could be degraded is modules contain lots of files. If you decide to do it, remember to copy as hard links: cp -lr. Least simple solution (of which I mention). Notable is that modules may want to build common with different build flags, in which case you'd need separate .o-files for each module. If that is the case, this solution will work where the others won't.

Above are designs I've learnt over time. Not pretending it's state of the art or anything.

I guess you want something like the

https://www.mojohaus.org/flatten-maven-plugin/

It allows you to "merge" the parent POM into your POM.

Have you tried to putting something like in the moduleZ.py to get the path you are currently in and then do the relative path from the variable you generate?

You should make use of the resources folder.

In fact, this will let you access your data folder the same way from your sources and your tests.

The structure of your project may look like this:

Webpack uses ids as a chunk references and those ids are not guaranteed to remain the same for the same chunks among different builds. contenthash is used for files extracted by ExtractTextWebpackPlugin. The same source content will get the same contenthash but the generated file may differ due to id changes.

Try using myproj-[name]-[chunkhash].chunk.js instead.

Also take a look at optimization.moduleIds and optimization.chunkIds settings.