modular | Modular is based on Stuart Sierra 's component library | Build Tool library

Or is it mandatory that a module has a screen?

No, of course not, modules have nothing to do with views or view models. They are just a set of registrations with the container.

what would be the best way to create the instance?

Let the container do the work. Normally, you have (at least) one assembly that only contains public interfaces (and the associated enums), but no modules. You reference that from the module and register the module's implementations of the relevant interfaces withing the module's Initialize method. Some other module (or the main app) can then have classes that get the interfaces as constructor parameters, and the container will resolve (i.e. create) the concrete types registered in the module, although they are internal or even private and completely unknown outside the module.

This is as loose a coupling as it gets if you don't want to sacrifice strong typing.

is there a way to get rid of that var searcher = containerProvider.Resolve(); and a better way to achieve this?

You can skip the var searcher = part :-) But if the HotfixSearcher is never injected anywhere, it won't be created unless you do it yourself. OnInitialized is the perfect spot for this, because it runs after all modules had their chance to RegisterTypes so all dependencies should be registered.

If HotfixSearcher is not meant to be injected, you can also drop IHotfixSearcher and resolve HotfixSearcher directly:

While I can certainly change the context of $(this) by using $.call(Object, argument) or doing an Object.assign({}, object) somewhere in the code, to manipulate the $.fn.init(selector, context) of jQuery, I have decided to create an alternative Vanilla solution Framework.

And, while jQuery is worth pursuing, I have built this custom CORE jQuery support library in stead. In other words, this framework mimics everything in the jQuery syntax as shown in the minimum code example. I believe that this is also the missing manual that most developers need that is virtually impossible to search these days in the internet due to jQuery's popularity & search ranking wars.

The goal as mentioned in the OP is to try to include only as little jQuery code as possible or implement an alternative solution with the jQuery snippet as needed because jQuery has grown so huge with newer versions and extensions and most of those code have considerable performance overhead other than the learning curve.

With this new CORE, I can easily extend support for jQuery, with $.fn.extend or $.extend or $.prototype.extend and for future use cases whenever the need arises, do another plugin for some basic routines or re-plug $(function()}) or $(document.ready()}) or implement other custom filters and jQuery-like chores, some of which I have already built and stripped off from this code such as event handlers and the $.ajax.

The good news is, we can even reuse already built favorite jQuery plugins without having to worry about compatibility issues because the power of jQuery is already in our hands! The core also preserved our favorite dot notation among others! :D

Overall, this is very handy whenever building minimal, manageable, reusable, modular Javascript, as well as building on top of the missing Vanilla learning curve and understanding how browsers work, especially because the heart of jQuery which is the $.extend is herein preserved. Some of the mechanics of this library though (about 2% of the code), is ported from jQuery and I'm planning to build on top of this CORE for my projects without having to worry about licenses.

That said, I hope this will be helpful to some developers out there. I'm licensing this code with MIT.

We can do a join on the 'code' and 'old' from table and lookup respectively

Well, deep dive into Java 9 gives the most basic answer, it's all about

split packages issue

that should be solved.

Very interesting solutions are proposed in the section How to Fix the Split Package Issue.

This is my hit on the clean architecture and hilt

• data is a java-only module with datasource interfaces, repository interfaces and models
• domain is a java-only module with usecase interfaces and entities
• framework is an android module where the actual implementations of datasources, repositories and usecases are found. This is the same module where the Hilt Modules are declared
• app is the app module with domain and framework as dependencies

So there's a mistake in your resource declaration:

It should be "this" instead of this. See below:

This is an unfortunate limitation of the component mapping to elements defined in a template. When mapping to Java, the parent-child relationships are not preserved and thus the tabs component does not realize that the tab is one of its child components.

See https://github.com/vaadin/flow/issues/7622

The way to make it work would be to create the Tabs and Tab instances in Java and the rest in Designer.

Obviously, from the pasted repolist, "remi" repository is not enabled.

For a proper configuration, follow the wizard instructions

Solution as one-liner: