Mador – Make any DOM reactive with a tiny 80-line Proxy state tuple

Join the discussion

• Hacker News
• > Hey HN! I wanted to see how far you can push modern JavaScript Proxies without all the heavy overhead of a traditional framework. The result is Mador: a tiny ~80-line reactive state tuple ([r, w]) that lets you make any DOM element reactive using a simple CSS selector, automated dependency tracking, and batched microtasks. No build steps required—just drop it in. I built this over the weekend just to experiment with clean, zero-dependency reactivity. Would love to hear your thoughts or see where you'd run into limits with something like this!

  Unsure why this comment from the author was flagged/dead but it certainly doesn’t seem to run afoul of HN guidelines.

  by hamburglar
• Hey HN! I wanted to see how far you can push modern JavaScript Proxies without all the heavy overhead of a traditional framework. The result is Mador: a tiny ~80-line reactive state tuple ([r, w]) that lets you make any DOM element reactive using a simple CSS selector, automated dependency tracking, and batched microtasks. No build steps required—just drop it in. I built this over the weekend just to experiment with clean, zero-dependency reactivity. Would love to hear your thoughts or see where you'd run into limits with something like this!
  by bosmarcel
• Great work!
  by ahmedhossamdev
• Thanks, I really appreciate it! Hope others will feel the same. The frontend community needs and deserves simple tools:)
  by bosmarcel
• Clean launch, good luck!
  by DylanMerigaud
• Thanx a lot!
  by bosmarcel
• Are reactive updates based on deep equality or reference equality?
  by PoignardAzur
• It is based on ref. equality, so assignment through '=' will trigger an "effect".
  by bosmarcel
• I love the minimalist approach here. Using Proxies for state management without the heavy overhead of large frameworks is really elegant. Keeping it under 80 lines is impressive. Great work!
  by abosalehworld
• I’m curious to know what performance looks like. In the recesses of my memory is the belief that proxies are not good for performance but I have no idea if that’s well founded (or maybe once was but isn’t any more).

  It’s a very smart idea though, I like it.

  by afavour
• It depends on count of variables and dependencies. The much worse problem with proxies is that they can be confused with raw values, for example, you can add a proxy into a Set, and then check for existence of a raw value. Or confuse raw value and proxy in dictionary's keys.
  by codedokode
• There are many standalone plug-n-play implementations of the signal primitive in JS. To name a few: preact/signals, vue reactivity, etc, there's even a TC39 proposal for a lang feature. Is this meant to stand out by doing things differently or reinvent them?
  by bedroom_jabroni
• Honestly, mostly for the fun of building it and seeing how small and simple I could make it. While big solutions like Preact or Vue are great, sometimes you just want a tiny zero-dependency script without the overhead. And it turned out to be quite nice as I may say so
  by bosmarcel
• The TC39 proposal seems pretty much dead :(; it doesn't look like much is happening. If I understand it correctly, it's really just about agreeing on a protocol, and it's ultimately up to frameworks to implement it, there isn't anything (yet?) that can run directly in JavaScript.
  by royal_ts
• (Just for (my) reference, the TC39 proposal is here:

  https://github.com/tc39/proposal-signals)

  by nxobject
• The syntax looks a bit too verbose for me. And function names like "read" and "write" are confusing too, given that "read" function isn't made for reading values. Cannot we use a single function for binding, like this (and name it "bind")?

      let counter = proxy({ count: 0 });
      bind('.counter', (el) => el.textContent = counter.count);
      counter.count++; // Queues DOM update
  

  Also,

  > Mador is distributed as an ES module.

  This means it cannot be used on a page opened from disk, and the user needs to set up a HTTP server which is time-consuming and distracting. And you cannot distribute an app as as HTML file.

  by codedokode
• https://github.com/tc39/proposal-module-expressions will fix the latter.
  by pwdisswordfishq
• > And you cannot distribute an app as as HTML file.

    <script type="module">
      console.log('Hello World!')
      export const a = 5
    </script>
  

  Inline module scripts work fine in HTML. You can't import this, but if you'd anyway need to do some "building" (at least doing some string concatenation as a build script) to get any JS baked into the HTML, so why not just concat the library and your own code to one module script in the HTML. Works fine.

  I think it's good that folks are starting to end distributing prebuilt code in every possible format that somebody could ask for. Waste of disk space for most people.

  ESM is how it's done now. If you don't like it, build it yourself to some other format.

  by inbx0
• Proposed variant optimised for human readaiblity...

  ```js import mador from "mador"; const [read, write] = mador({ count: 1 }); read(".counter", ctx => ctx.el.textContent = ctx.count); write(".increment", "click", ctx => ctx.count++); write(ctx => ctx.count = 0); ```

  ## Read

  Dependencies are detected automatically when the read function is run during initiation.

  ```js read(".counter", ctx => ctx.el.textContent = `Count: ${ctx.count}`); ```

  ## Write

  Immediate:

  ```js write(ctx => ctx.count++); ```

  Event-triggered:

  ```js write(".increment", "click", ctx => ctx.count++); ```

  Event writes expose `ctx.el` and `ctx.event`.

  by moostee
• O yes, thanks, appreciate it! I'm tired now, but i will find the time tomorrow to make it more readable!
  by bosmarcel