NeoComp: new framework with a new paradigm

Hello all,
I would like to present a new JavaScript framework I recently developed called NeoComp.
Before I start, this is just a concept framework, so please do not increment the framework count. This is not production-ready and may not be.

NeoComp is a JavaScript framework that aims to be simple and lightweight, yet powerful and flexible. Inspired by Solid and Ripple, it supports vanilla JavaScript approaches while remaining declarative and reactive in nature.

here is a counter example:

class Counter extends Component {
    constructor() {
        super();
        const { $temp } = this.createTop();

        let count = this.signal(0);
        $temp`

            
count: ${count}
            ${() => count.value++}>increment
        
`;

        this.fireInit();
    }
}

NeoComp, like any other modern framework, is a component-oriented framework that has first-class support for TypeScript. However, it has some interesting properties:

• It is constructive: there is a one-time initialization where the structure is created, and then further updates are handled by:
• fine-grained reactivity, where updates are direct and efficient, with no need to re-render the whole app.
• It is declarative in the sense that the structure is defined in HTML syntax, with bindings inferred implicitly.
• vanilla JavaScript, it is just regular JavaScript, with the full power of JavaScript, requiring no custom syntax or build step.
• It utilizes object-oriented components. Isn’t OOP bad? have your tried large-scale functional component, plus classes are just an init function plus a free scope and interface.
• It features template chunks. Opposite to defining the template as a big blob at the end, you can define every section separately, with its own logic around it.
• It is super flexible, with out of the box async programming, lazy loading, context for state management, auto dependency management, and more.
• It is close to the root, providing you with full control over the DOM, as bindings are localized to specific elements.
• It has simplified internals with no complex mechanisms or hidden magic, only lightweight, extensible utilities.
• vanilla transformation, an optional build step to eliminate parsing the template at runtime.

NeoComp has a unique view on UI development: vanilla JavaScript imperative construction with direct, implicit bindings. The web is static structure dynamic content, we don’t need custom syntax or a build step, just a lightweight foundation with flexible templating and implicit bindings.

If you are interested in NeoComp, you can:

• Check out its documentation and dive into its source code on its repo on GitHub.
• Test it on your machine by running npm i @neocomp/full.
• Read the blog posts on recomputed. The current posts are:
• Share your suggestions and comments in the comment section. I would love to hear from you.

And that is it. I hope you find NeoComp interesting and useful.

And please note, this is a concept framework, not a production-ready one, also I am a first-year university student.