News for hackers. Stuff that matters.
Re:Web Components Aren't Framework Components by lelanthran on Monday December 11, 2023 @01:22AM (#38598128)
I've found much use out of custom elements.

On nice use, that took me maybe 30m to code up, is a `<remote-fragment>` element.

    <remote-fragment src=/fragments/topbar.htmlf />
simply retrieves the specified file and adds it to the DOM where the `remote-fragment` is declared.

No need for server-side scripting to include common parts of the HTML page.

There's a bunch of similar use-cases currently satisfied by fat client frameworks or server-side languages that simply go away when you have custom elements.

So, yeah, you can do components with webcomponents they way you do much of react components, but there's some stuff that you can do with webcomponents that just makes life a little bit better[1].

[1] Experimenting with propagating state throughout a (client-side) application using only declarations in HTML, with custom elements performing stuff.

Re:Web Components Aren't Framework Components by nesarkvechnep on Monday December 11, 2023 @01:35AM (#38598185)
It seems like you reinvented Edge Site Includes (https://en.m.wikipedia.org/wiki/Edge_Side_Includes).
Re:Web Components Aren't Framework Components by lelanthran on Monday December 11, 2023 @01:55AM (#38598272)
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)

Re:Web Components Aren't Framework Components by nesarkvechnep on Monday December 11, 2023 @03:50AM (#38598794)
Refined the concept into the simplest form that works… as long as you have JavaScript enabled.
Re:Web Components Aren't Framework Components by lelanthran on Monday December 11, 2023 @05:18AM (#38599227)
What's the alternative other than simply doing without this feature?
Re:Web Components Aren't Framework Components by Quekid5 on Monday December 11, 2023 @06:40AM (#38599726)
E.g. Apache's Server Side Includes[0] allows for

   <!--#include virtual="/footer.html" --> 
Tbf, you did specify 'server language' in a post further up the comment chain, but the the thing is that it doesn't have to be much more complicated that SSI -- assuming it's available for your deployment target, of course.

(SSI obviously does not require JavaScript.)

[0] https://httpd.apache.org/docs/current/howto/ssi.html

Re:Web Components Aren't Framework Components by lelanthran on Monday December 11, 2023 @07:50AM (#38600193)
I've used those before, but I feel that having something that works within the spec, independent of any particular implementation's extensions is much more valuable for longevity.

Sure, you can use $A if using $B server, or use $C when using $D language, or use $E when using $F framework, or use $G when using $H reverse-proxy, or use $I when using $J CDN, or use $K when using $L hosted cloud service ...

Or you can just use what's in the specification which works on all of the above, but won't work on clients with Javascript disabled.

It's a "choose your poison" scenario.

Re:Web Components Aren't Framework Components by mewpmewp2 on Monday December 11, 2023 @01:24PM (#38603350)
Technically you could also just write a bit of JS within the HTML to do without needing any of the first 3.

You could querySelectorAll and check the src attribute etc, then fetch the content put it in the innerHTML.

    <remote-fragment src="https://..." />

    <script>

      document.querySelectorAll("remote-fragment").forEach(async (el) => {

        const src = el.getAttribute("src");

        const result = await fetch(src).then((res) => res.text());

        el.innerHTML = result;

      });

    </script>

Or if you want to react to any such component inserted at times down the line or src attribute changes, you could use MutationObserver.
Re:Web Components Aren't Framework Components by lelanthran on Tuesday December 12, 2023 @12:41AM (#38609935)
That breaks on edge cases.

For example it won't work recursively when a fetched fragment has fragments of its own.

Or when the js snippet loads before some fragment element is loaded (say, from a DOM update).

The nice thing about custom elements is that you get to treat them exactly like normal elements.

Re:Web Components Aren't Framework Components by mewpmewp2 on Tuesday December 12, 2023 @05:56PM (#38619950)
In this case you could use MutationObserver - although we are doing manually the logic web components provide, but my point is that you can do it also without using web components. My code doesn't include attribute changes, but this should be possible to also do with MutationObserver.

    <body>
    <script>
      const onRemoteFragmentMount = async (el) => {
        const src = el.getAttribute("src");
        const result = await fetch(src).then((res) => res.text());
        el.innerHTML = result;
      };

      const callback = (mutationsList, observer) => {
        for (let mutation of mutationsList) {
          if (mutation.type === "childList") {
            mutation.addedNodes.forEach((node) => {
              if (node.tagName === "REMOTE-FRAGMENT") {
                onRemoteFragmentMount(node);
              }
            });
          }
        }
      };

      const observer = new MutationObserver(callback);
      const bodyElement = document.querySelector("body");
      observer.observe(bodyElement, {
        childList: true,
        subtree: true,
      });
    </script>

    <remote-fragment src="..." />
    </body>
Re:Web Components Aren't Framework Components by KatrinaKitten on Tuesday December 12, 2023 @06:00PM (#38620000)
While you certainly could do this, a major benefit of web components is that you get all of this for free out of the box. It's less error/mistake prone, keeps your code cleaner and more obvious exactly what it does, etc.
Re:Web Components Aren't Framework Components by dannye on Tuesday December 12, 2023 @07:53AM (#38611511)
why waste 28 minutes writing your own component? copy/paste takes 2 minutes https://dev.to/dannyengelman/load-file-web-component-add-ext...
Re:Web Components Aren't Framework Components by big_paps on Monday December 11, 2023 @03:03AM (#38598567)
Cool. But is it readable from a search engine?
Re:Web Components Aren't Framework Components by lelanthran on Monday December 11, 2023 @03:36AM (#38598720)
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.

Re:Web Components Aren't Framework Components by DylanSp on Monday December 11, 2023 @09:47AM (#38601087)
Can you elaborate a bit more on the example in your footnote about propagating client-side state? Does that provide functionality similar to Alpine.js's data objects/stores?
Re:Web Components Aren't Framework Components by lelanthran on Tuesday December 12, 2023 @01:50AM (#38610392)
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();
    });
and then any code, anywhere else can do `publish(this, "ERROR", "Rpc Request", { errMsg: "Rxed 404"});`

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>

Of course, this means that I have a line of js somewhere that looks like this:

    subscribe("MYFORM", "submit-*", (sender, subject, payload) => { /* send payload to server */ });
And another that looks like this:

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

This is still very much a WIP, and I'm playing with having custom elements for performing RPC without using the publish/subscribe functions; this is so that, during usage of these components, there will be zero JS to write. Right now there is still the publish/subscribe calls that intercept messages and tx/rx messages from the server to local components.

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>
The psjs-subscribe/publish elements are still useful to propagate value changes locally within the client, but for non-local state an RPC set of elements seems preferable.

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.

Re:Web Components Aren't Framework Components by DylanSp on Tuesday December 12, 2023 @10:37PM (#38622329)
No need to apologize for the length of your post! It's interesting to read about your experiments.

Looking at your example with the psjs elements, it looks like the psjs-bind elements define what fields get captured and used in the published payload, as well as setting the input elements' values from a subscription event; is that correct? That does seem useful for keeping state synchronized across multiple local components.

It seems like you'd still need some JS if there's any client-side logic that needs to be run, though I'm not sure if there's a way to avoid that. I'm thinking of something like displaying different parts of the page based on multiple input fields. Maybe you could handle a lot of use cases like that with plain HTML and CSS, though.

Re:Web Components Aren't Framework Components by lelanthran on Wednesday December 13, 2023 @01:47AM (#38623547)
> No need to apologize for the length of your post! It's interesting to read about your experiments.

Thanks. As a newcomer, I looked into what knowledge is required to produce a dynamic front-end, and completely 'noped' out of it after a few days[1]. The web component approach looks, to me, more future-proof as well as easier to use.

> Looking at your example with the psjs elements, it looks like the psjs-bind elements define what fields get captured and used in the published payload, as well as setting the input elements' values from a subscription event; is that correct?

Broadly correct, yes, but a little clarification - elements don't have to be input elements, then can be any elements. So, for example, if the psjs-bind 'for' target would is a span element, then the innerText content is updated. For input elements, the value is updated, etc. I'm still working out whether this is a good idea or not.

> It seems like you'd still need some JS if there's any client-side logic that needs to be run, though I'm not sure if there's a way to avoid that. I'm thinking of something like displaying different parts of the page based on multiple input fields.

You're correct; some JS is still needed! Of course I consider that a failure that needs to be rectified - for updating the page based on user actions (or input element changes) I'm considering a custom element that subscribes to a channel and listens for a subject pattern, and then changes its style fields (`display: none` to `display: block` (or vice versa)) based on the payload.

Keep an eye out for when I finally make this available to the world (maybe a name like 'ZeroJS', for example :-))

[1] Programming web services is dominated by out-of-standards/never-standardised technology - npm, build-steps (for front-end), frameworks, tree-shaking, commonjs includes, webpacking, etc. All I want is a quick way to produce dynamic web pages. A full 6-months of learning all the existing techis exactly my idea of a non-fun time.

Re:Web Components Aren't Framework Components by DylanSp on Thursday December 14, 2023 @08:16PM (#38649878)
> Broadly correct, yes, but a little clarification - elements don't have to be input elements, then can be any elements. So, for example, if the psjs-bind 'for' target would is a span element, then the innerText content is updated. For input elements, the value is updated, etc. I'm still working out whether this is a good idea or not.

Got it. I'm curious how this works out in practice; it feels like this would end up being a bit too unstructured in practice, but that's just a guess, and that might not be an issue when it's used in relatively small amounts.

> You're correct; some JS is still needed! Of course I consider that a failure that needs to be rectified - for updating the page based on user actions (or input element changes) I'm considering a custom element that subscribes to a channel and listens for a subject pattern, and then changes its style fields (`display: none` to `display: block` (or vice versa)) based on the payload.

I like the idea of being able to write most/all client-side logic with custom elements and/or a server-side rendering library. It can't cover all use cases without being so general that you might as well use JS, but there's probably some 80/20 point that covers most use cases with relatively simple tools.

Re:Web Components Aren't Framework Components by jbergens on Monday December 11, 2023 @04:23PM (#38605682)
Re:Web Components Aren't Framework Components by jbergens on Monday December 11, 2023 @04:25PM (#38605709)
Meant to link to the root but can't change now.

https://htmx.org/

Re:Web Components Aren't Framework Components by lelanthran on Tuesday December 12, 2023 @12:50AM (#38609996)
It is, but only for the subset I think is absolutely necessary.