Web Components Aren't Framework Components

I like to think that I didn't reinvent it (just like react, et al didn't reinvent it), I only refined the concept into the simplest form that works :-)

After all, a custom element that takes a front-end newcomer 30m to write is absolutely preferable to a large infrastructure-based standard that, after 22 years, is still not included in the spec.

Look at the options for including HTML fragments in web pages:

1. Complex client-side react/vue/etc,

2. A server language ,

3. A build-step including a non-spec bundler/packer,

4. A `<remote-fragment src="..." />

My point is that webcomponents make quite a lot of complicated things redundant for particular use-cases. As time goes on I see the fat front-end frameworks having more of their functionality being replaced with less complex (to use) custom elements.

(Hence my experiments with value propagation using custom elements)

Meant to link to the root but can't change now.

https://htmx.org/

It is, but only for the subset I think is absolutely necessary.

Sure, but bear in mind it's only an experiment, so I do not expect this to be long-lived, or if it is, I do not expect it to look the same way as it does now, and even if either of the above remain true, I still think that alternatives such as htmx are preferably for multiple reasons, bar one (explained in the last paragraph of this post).

IOW, I expect this to be an experiment that I eventually throw away after having gained some insight. The `ps` in `psjs` below means "publish/subscribe".

The big draw for me about htmx is that common usage does not require knowledge of Javascript! This means that htmx (and my set of custom elements) does not require the creator of the front-end to know that npm even exists, much less how to use it. The same goes for Virtual DOMs, Hooks, tree-shaking/web-packing, promises and async, functions, and the whole container-ship full of arbitrary things that common front-end stacks need you to know.

My custom elements require javascript (for now), and require that the user know what is meant by 'publish a message onto a queue' and 'subscribe to a queue for messages of a particular subject'.

-------------------------------------

I have at least four custom elements: psjs-tree, psjs-bind, psjs-subscribe and psjs-publish.

I also have two JS functions, `publish` and `subscribe`: `publish` publishes an arbitrary payload (a JS object) to a channel (string) with a subject (also of string type). `subscribe` registers a callback function for a channel (string) with a pattern for the subject.

These are all global. A piece of code could do:

    subscribe("ERROR", "*", (sender, subject, payload) => {
        dialog.innerHTML = `${sender.id}: Error ${subject} ${payload.errMessage}`;
        dialog.showModal();
    });

My web components psjs-publish and psjs-subscribe execute those two functions (for publish, there is an `onevent` attribute). The psjs-publish component uses the closest psjs-tree ancestor to determine which fields go into the payload. The fields are set by psjs-bind. The psjs-subscribe does the opposite of psjs-publish, in that it uses the closest psjs-tree ancestor to determine which fields of the payload should be used to update the contents or values of the psjs-tree descendents.

For example, a form that can have the values reset by some other code (say, fetching them from a server) and can have the values submitted:

    <psjs-tree>
        <psjs-subscribe channel="MYFORM" subject="update-fields"> </psjs-subscribe>
        <psjs-bind for="team-name"> </psjs-bind>
        <psjs-bind for="notifications"> </psjs-bind>
        <psjs-bind for="user-name"> </psjs-bind>
        <psjs-bind for="user-email"> </psjs-bind>
        <form>
            <div id="title"> Example</div>
            <div id="team-name"> </div>
            <div id="notifications"> </div>
            <input id="user-name"> </input>
            <input id="user-email"> </input>
            <psjs-publish onevent="click" channel=MYFORM subject=submit-fields>
                <button>Submit</button>
            </psjs-publish>
        </form>
    </psjs-tree>

    subscribe("MYFORM", "submit-*", (sender, subject, payload) => { /* send payload to server */ });

    const rsp = successfulFetchFromServer();
    publish(this, "MYFORM", "update-fields", { "team-name": rsp.teamName, ... });

I'd like it to look like this eventually:

    <rpc-tree>
        <rpc-rx subject="Some Subject">
        <rpc-bind for="team-name"> </rpc-bind>
        <rpc-bind for="notifications"> </rpc-bind>
        <rpc-bind for="user-name"> </rpc-bind>
        <rpc-bind for="user-email"> </rpc-bind>
        <form>
            <div id="title"> Example</div>
            <div id="team-name"> </div>
            <div id="notifications"> </div>
            <input id="user-name"> </input>
            <input id="user-email"> </input>
            <rpc-tx onevent="click" href="/some/path/to/submit" subject="Some Subject">
                <button>Submit</button>
            </rpc-tx>
        </form>
    </rpc-tree>

All in all (and I realise that I wrote an exceptionally long post, so sorry!), I feel that htmx is better right now, but ... it forces the creation of a backend-for-frontend layer, so you have the layers of front-end -> backend-for-front-end -> API. With RPC calls only, I don't need to write the middle layer and can simply use the API directly from the client application, especially when using the custom element for specifying fragments.

Not a priority for webapps.

In websites, search engines ignoring the common elements that you would use this for, such as navbars, isn't a deal-breaker.

When I search Google for keyword FOO, results that have FOO only in the elements common to all web pages are useless results.

I'm typically looking for FOO in the content, not in the navigational elements or other common elements.

Wow, just wow! 100x simplicity accomplished! THANKS a TON!!! <3

> A framework component is effectively a reusable block of code.

I think that, for me as a newcomer to front-end development, this is the biggest takeaway: a framework component is a reusable block of javascript while a webcomponent is a reusable HTML element.

As a newcomer[1] it does not make sense to even learn the front-end frameworks. As an example, the time spent in learning the entire framework simply so I can 'watch' an element's value for changes, or propagate an element's changed value to other elements is going to be order of magnitudes greater than simply writing 3 custom elements that monitor and propagate values for any child element.

(PS. I like your post. I think a followup blog post with two concrete examples may make sense in refining your thesis:

Example 1. This is a popular React mechanism to do $FOO, here's how it is easier in a webcomponent.

Example 2. This is a complex webcomponent, here's how it is easier in React.)

[1] One who is not looking to put "react", "vue", etc on their CV.

> A framework component is effectively a reusable block of code.

So is a web component…