xote 4.16.1 → 6.0.0

package/src/{Xote__Hydration.res → Hydration.res}

@@ -1,8 +1,6 @@
-open Signals
 
-module Component = Xote__Component
-module DOM = Xote__Component.DOM
-module Reactivity = Xote__Component.Reactivity
+module DOM = Node.DOM
+module Reactivity = Node.Reactivity
 
 /* ============================================================================
  * Hydration Options
@@ -31,6 +29,7 @@ module DOMWalker = {
 
   /* Get child nodes as array */
   let getChildNodes = (el: Dom.element): array<Dom.element> => {
+    ignore(el)
     %raw(`Array.from(el.childNodes || [])`)
   }
 
@@ -157,12 +156,12 @@ let logHydrationWarning = (msg: string): unit => {
  * ============================================================================ */
 
 /* Hydrate a single node, attaching reactivity to existing DOM */
-let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
+let rec hydrateNode = (node: Node.node, domNode: Dom.element): unit => {
   switch node {
-  | Component.Text(_content) => /* Static text - nothing to hydrate, DOM already has the content */
+  | Node.Text(_content) => /* Static text - nothing to hydrate, DOM already has the content */
     ()
 
-  | Component.SignalText(signal) => {
+  | Node.SignalText(signal) => {
       /*
        * Server rendered: <!--$-->text<!--/$-->
        * We need to find the text node between markers and attach an effect
@@ -171,7 +170,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       Reactivity.setOwner(domNode, owner)
 
       Reactivity.runWithOwner(owner, () => {
-        let disposer = Effect.run(() => {
+        let disposer = Effect.runWithDisposer(() => {
           DOM.setTextContent(domNode, Signal.get(signal))
           None
         })
@@ -179,7 +178,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       })
     }
 
-  | Component.Fragment(children) => {
+  | Node.Fragment(children) => {
       /* Fragment children are directly in the parent - hydrate each */
       let walker = DOMWalker.make(domNode)
       children->Array.forEach(child => {
@@ -187,7 +186,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       })
     }
 
-  | Component.SignalFragment(signal) => {
+  | Node.SignalFragment(signal) => {
       /*
        * Server rendered: <!--#-->...children...<!--/#-->
        * We need to replace the content when the signal changes
@@ -196,7 +195,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       Reactivity.setOwner(domNode, owner)
 
       Reactivity.runWithOwner(owner, () => {
-        let disposer = Effect.run(() => {
+        let disposer = Effect.runWithDisposer(() => {
           let children = Signal.get(signal)
 
           /* Clear existing children */
@@ -213,7 +212,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
           /* Render and append new children */
           children->Array.forEach(
             child => {
-              let childEl = Component.Render.render(child)
+              let childEl = Node.Render.render(child)
               domNode->DOM.appendChild(childEl)
             },
           )
@@ -224,7 +223,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       })
     }
 
-  | Component.Element({attrs, events, children}) => {
+  | Node.Element({attrs, events, children}) => {
       let owner = Reactivity.createOwner()
       Reactivity.setOwner(domNode, owner)
 
@@ -232,9 +231,9 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
         /* Hydrate reactive attributes */
         attrs->Array.forEach(((key, value)) => {
           switch value {
-          | Component.Static(_) => () /* Already rendered, nothing to do */
-          | Component.SignalValue(signal) => {
-              let disposer = Effect.run(
+          | Node.Static(_) => () /* Already rendered, nothing to do */
+          | Node.SignalValue(signal) => {
+              let disposer = Effect.runWithDisposer(
                 () => {
                   DOM.setAttrOrProp(domNode, key, Signal.get(signal))
                   None
@@ -242,8 +241,8 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
               )
               Reactivity.addDisposer(owner, disposer)
             }
-          | Component.Compute(compute) => {
-              let disposer = Effect.run(
+          | Node.Compute(compute) => {
+              let disposer = Effect.runWithDisposer(
                 () => {
                   DOM.setAttrOrProp(domNode, key, compute())
                   None
@@ -267,7 +266,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       })
     }
 
-  | Component.LazyComponent(fn) => {
+  | Node.LazyComponent(fn) => {
       /* Execute lazy component and hydrate its result */
       let owner = Reactivity.createOwner()
       let childNode = Reactivity.runWithOwner(owner, fn)
@@ -275,7 +274,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       hydrateNode(childNode, domNode)
     }
 
-  | Component.KeyedList({signal, keyFn, renderItem}) => {
+  | Node.KeyedList({signal, keyFn, renderItem}) => {
       /*
        * Server rendered: <!--kl--><!--k:key1-->item1<!--/k--><!--k:key2-->item2<!--/k--><!--/kl-->
        * We need to set up the reconciliation effect
@@ -284,7 +283,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
       Reactivity.setOwner(domNode, owner)
 
       /* Build initial key -> element map from existing DOM */
-      let keyedItems: Dict.t<Component.Render.keyedItem<Obj.t>> = Dict.make()
+      let keyedItems: Dict.t<Node.Render.keyedItem<Obj.t>> = Dict.make()
       let walker = DOMWalker.make(domNode)
 
       /* Skip to list start marker */
@@ -355,7 +354,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
           keysToRemove->Array.forEach(key => {
             switch keyedItems->Dict.get(key) {
             | Some(keyedItem) => {
-                Component.Render.disposeElement(keyedItem.element)
+                Node.Render.disposeElement(keyedItem.element)
                 let _ = (%raw(`keyedItem.element.remove()`): unit)
                 keyedItems->Dict.delete(key)->ignore
               }
@@ -364,7 +363,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
           })
 
           /* Build new order */
-          let newOrder: array<Component.Render.keyedItem<Obj.t>> = []
+          let newOrder: array<Node.Render.keyedItem<Obj.t>> = []
           let elementsToReplace: Dict.t<bool> = Dict.make()
 
           newItems->Array.forEach(item => {
@@ -375,8 +374,8 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
               if existing.item !== item {
                 elementsToReplace->Dict.set(key, true)
                 let node = renderItem(item)
-                let element = Component.Render.render(node)
-                let keyedItem: Component.Render.keyedItem<Obj.t> = {key, item, element}
+                let element = Node.Render.render(node)
+                let keyedItem: Node.Render.keyedItem<Obj.t> = {key, item, element}
                 newOrder->Array.push(keyedItem)->ignore
                 keyedItems->Dict.set(key, keyedItem)
               } else {
@@ -384,8 +383,8 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
               }
             | None => {
                 let node = renderItem(item)
-                let element = Component.Render.render(node)
-                let keyedItem: Component.Render.keyedItem<Obj.t> = {key, item, element}
+                let element = Node.Render.render(node)
+                let keyedItem: Node.Render.keyedItem<Obj.t> = {key, item, element}
                 newOrder->Array.push(keyedItem)->ignore
                 keyedItems->Dict.set(key, keyedItem)
               }
@@ -407,7 +406,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
                   elementsToReplace->Dict.get(keyedItem.key)->Option.getOr(false)
 
                 if needsReplacement {
-                  Component.Render.disposeElement(elem)
+                  Node.Render.disposeElement(elem)
                   DOM.replaceChild(domNode, keyedItem.element, elem)
                   marker := DOM.getNextSibling(keyedItem.element)
                 } else {
@@ -420,7 +419,7 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
           })
         }
 
-        let disposer = Effect.run(() => {
+        let disposer = Effect.runWithDisposer(() => {
           reconcile()
           None
         })
@@ -431,14 +430,14 @@ let rec hydrateNode = (node: Component.node, domNode: Dom.element): unit => {
 }
 
 /* Hydrate using a walker (for traversing children) */
-and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit => {
+and hydrateNodeWithWalker = (node: Node.node, walker: DOMWalker.t): unit => {
   switch node {
-  | Component.Text(_) => {
+  | Node.Text(_) => {
       /* Skip text node in DOM */
       let _ = DOMWalker.next(walker)
     }
 
-  | Component.SignalText(signal) => {
+  | Node.SignalText(signal) => {
       /* Find the marker, then hydrate the text node */
       let _ = DOMWalker.skipUntilMarker(walker, "$")
 
@@ -449,7 +448,7 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
           Reactivity.setOwner(textNode, owner)
 
           Reactivity.runWithOwner(owner, () => {
-            let disposer = Effect.run(() => {
+            let disposer = Effect.runWithDisposer(() => {
               DOM.setTextContent(textNode, Signal.get(signal))
               None
             })
@@ -463,13 +462,13 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
       }
     }
 
-  | Component.Fragment(children) =>
+  | Node.Fragment(children) =>
     /* Fragment children are inline - hydrate each */
     children->Array.forEach(child => {
       hydrateNodeWithWalker(child, walker)
     })
 
-  | Component.SignalFragment(signal) => {
+  | Node.SignalFragment(signal) => {
       /* Find the container (div with display:contents in SSR, markers in comments) */
       let _ = DOMWalker.skipUntilMarker(walker, "#")
 
@@ -482,7 +481,10 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
 
       /* Get parent before moving nodes (we need it for insertion) */
       let parent: option<Dom.element> = switch contentNodes->Array.get(0) {
-      | Some(firstNode) => %raw(`firstNode.parentNode`)
+      | Some(firstNode) => {
+          ignore(firstNode)
+          %raw(`firstNode.parentNode`)
+        }
       | None => None
       }
 
@@ -503,17 +505,17 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
       Reactivity.setOwner(container, owner)
 
       Reactivity.runWithOwner(owner, () => {
-        let disposer = Effect.run(() => {
+        let disposer = Effect.runWithDisposer(() => {
           let children = Signal.get(signal)
 
           /* Clear and re-render */
           let childNodes: array<Dom.element> = %raw(`Array.from(container.childNodes || [])`)
-          childNodes->Array.forEach(Component.Render.disposeElement)
+          childNodes->Array.forEach(Node.Render.disposeElement)
           let _ = (%raw(`container.innerHTML = ''`): unit)
 
           children->Array.forEach(
             child => {
-              let childEl = Component.Render.render(child)
+              let childEl = Node.Render.render(child)
               container->DOM.appendChild(childEl)
             },
           )
@@ -524,7 +526,7 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
       })
     }
 
-  | Component.Element({attrs, events, children}) =>
+  | Node.Element({attrs, events, children}) =>
     switch DOMWalker.next(walker) {
     | Some(domNode) => {
         let owner = Reactivity.createOwner()
@@ -534,9 +536,9 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
           /* Hydrate reactive attributes */
           attrs->Array.forEach(((key, value)) => {
             switch value {
-            | Component.Static(_) => ()
-            | Component.SignalValue(signal) => {
-                let disposer = Effect.run(
+            | Node.Static(_) => ()
+            | Node.SignalValue(signal) => {
+                let disposer = Effect.runWithDisposer(
                   () => {
                     DOM.setAttrOrProp(domNode, key, Signal.get(signal))
                     None
@@ -544,8 +546,8 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
                 )
                 Reactivity.addDisposer(owner, disposer)
               }
-            | Component.Compute(compute) => {
-                let disposer = Effect.run(
+            | Node.Compute(compute) => {
+                let disposer = Effect.runWithDisposer(
                   () => {
                     DOM.setAttrOrProp(domNode, key, compute())
                     None
@@ -571,7 +573,7 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
     | None => logHydrationWarning("Missing DOM element for Element node")
     }
 
-  | Component.LazyComponent(fn) => {
+  | Node.LazyComponent(fn) => {
       /* Skip the lazy component markers and hydrate the content */
       let _ = DOMWalker.skipUntilMarker(walker, "lc")
 
@@ -581,12 +583,12 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
       let _ = DOMWalker.skipUntilMarker(walker, "/lc")
     }
 
-  | Component.KeyedList({signal, keyFn, renderItem}) => {
+  | Node.KeyedList({signal, keyFn, renderItem: _}) => {
       /* Find the keyed list in the DOM */
       let _ = DOMWalker.skipUntilMarker(walker, "kl")
 
       /* Parse existing keyed items from DOM */
-      let keyedItems: Dict.t<Component.Render.keyedItem<Obj.t>> = Dict.make()
+      let keyedItems: Dict.t<Node.Render.keyedItem<Obj.t>> = Dict.make()
 
       let rec parseKeyedItems = () => {
         switch DOMWalker.peek(walker) {
@@ -628,7 +630,7 @@ and hydrateNodeWithWalker = (node: Component.node, walker: DOMWalker.t): unit =>
 
 /* Hydrate a server-rendered component */
 let hydrate = (
-  component: unit => Component.node,
+  component: unit => Node.node,
   container: Dom.element,
   ~options: hydrateOptions={},
 ): unit => {
@@ -663,7 +665,7 @@ let hydrate = (
 
 /* Hydrate by element ID */
 let hydrateById = (
-  component: unit => Component.node,
+  component: unit => Node.node,
   containerId: string,
   ~options: hydrateOptions={},
 ): unit => {

package/src/{Xote__Hydration.res.mjs → Hydration.res.mjs}

@@ -1,9 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Signals from "rescript-signals/src/Signals.res.mjs";
+import * as Node$Xote from "./Node.res.mjs";
+import * as Effect$Xote from "./Effect.res.mjs";
+import * as Signal$Xote from "./Signal.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Xote__Component from "./Xote__Component.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -120,7 +121,7 @@ let DOMWalker = {
   collectUntilMarker: collectUntilMarker
 };
 
-let HydrationMismatch = /* @__PURE__ */Primitive_exceptions.create("Xote__Hydration.HydrationMismatch");
+let HydrationMismatch = /* @__PURE__ */Primitive_exceptions.create("Hydration-Xote.HydrationMismatch");
 
 function logHydrationWarning(msg) {
   console.warn(`[Xote Hydration] ` + msg);
@@ -134,9 +135,9 @@ function hydrateNode(_node, domNode) {
         let children = node.children;
         let events = node.events;
         let attrs = node.attrs;
-        let owner = Xote__Component.Reactivity.createOwner();
-        Xote__Component.Reactivity.setOwner(domNode, owner);
-        return Xote__Component.Reactivity.runWithOwner(owner, () => {
+        let owner = Node$Xote.Reactivity.createOwner();
+        Node$Xote.Reactivity.setOwner(domNode, owner);
+        return Node$Xote.Reactivity.runWithOwner(owner, () => {
           attrs.forEach(param => {
             let value = param[1];
             let key = param[0];
@@ -145,16 +146,16 @@ function hydrateNode(_node, domNode) {
                 return;
               case "SignalValue" :
                 let signal = value._0;
-                let disposer = Signals.Effect.run(() => {
-                  Xote__Component.DOM.setAttrOrProp(domNode, key, Signals.Signal.get(signal));
+                let disposer = Effect$Xote.runWithDisposer(() => {
+                  Node$Xote.DOM.setAttrOrProp(domNode, key, Signal$Xote.get(signal));
                 }, undefined);
-                return Xote__Component.Reactivity.addDisposer(owner, disposer);
+                return Node$Xote.Reactivity.addDisposer(owner, disposer);
               case "Compute" :
                 let compute = value._0;
-                let disposer$1 = Signals.Effect.run(() => {
-                  Xote__Component.DOM.setAttrOrProp(domNode, key, compute());
+                let disposer$1 = Effect$Xote.runWithDisposer(() => {
+                  Node$Xote.DOM.setAttrOrProp(domNode, key, compute());
                 }, undefined);
-                return Xote__Component.Reactivity.addDisposer(owner, disposer$1);
+                return Node$Xote.Reactivity.addDisposer(owner, disposer$1);
             }
           });
           events.forEach(param => {
@@ -167,13 +168,13 @@ function hydrateNode(_node, domNode) {
         return;
       case "SignalText" :
         let signal = node._0;
-        let owner$1 = Xote__Component.Reactivity.createOwner();
-        Xote__Component.Reactivity.setOwner(domNode, owner$1);
-        return Xote__Component.Reactivity.runWithOwner(owner$1, () => {
-          let disposer = Signals.Effect.run(() => {
-            domNode.textContent = Signals.Signal.get(signal);
+        let owner$1 = Node$Xote.Reactivity.createOwner();
+        Node$Xote.Reactivity.setOwner(domNode, owner$1);
+        return Node$Xote.Reactivity.runWithOwner(owner$1, () => {
+          let disposer = Effect$Xote.runWithDisposer(() => {
+            domNode.textContent = Signal$Xote.get(signal);
           }, undefined);
-          Xote__Component.Reactivity.addDisposer(owner$1, disposer);
+          Node$Xote.Reactivity.addDisposer(owner$1, disposer);
         });
       case "Fragment" :
         let walker = make(domNode);
@@ -181,33 +182,33 @@ function hydrateNode(_node, domNode) {
         return;
       case "SignalFragment" :
         let signal$1 = node._0;
-        let owner$2 = Xote__Component.Reactivity.createOwner();
-        Xote__Component.Reactivity.setOwner(domNode, owner$2);
-        return Xote__Component.Reactivity.runWithOwner(owner$2, () => {
-          let disposer = Signals.Effect.run(() => {
-            let children = Signals.Signal.get(signal$1);
+        let owner$2 = Node$Xote.Reactivity.createOwner();
+        Node$Xote.Reactivity.setOwner(domNode, owner$2);
+        return Node$Xote.Reactivity.runWithOwner(owner$2, () => {
+          let disposer = Effect$Xote.runWithDisposer(() => {
+            let children = Signal$Xote.get(signal$1);
             let childNodes = (Array.from(domNode.childNodes || []));
-            childNodes.forEach(child => Xote__Component.Reactivity.disposeOwner(Stdlib_Option.getOr(Xote__Component.Reactivity.getOwner(child), Xote__Component.Reactivity.createOwner())));
+            childNodes.forEach(child => Node$Xote.Reactivity.disposeOwner(Stdlib_Option.getOr(Node$Xote.Reactivity.getOwner(child), Node$Xote.Reactivity.createOwner())));
             ((domNode.innerHTML = ''));
             children.forEach(child => {
-              let childEl = Xote__Component.Render.render(child);
+              let childEl = Node$Xote.Render.render(child);
               domNode.appendChild(childEl);
             });
           }, undefined);
-          Xote__Component.Reactivity.addDisposer(owner$2, disposer);
+          Node$Xote.Reactivity.addDisposer(owner$2, disposer);
         });
       case "LazyComponent" :
-        let owner$3 = Xote__Component.Reactivity.createOwner();
-        let childNode = Xote__Component.Reactivity.runWithOwner(owner$3, node._0);
-        Xote__Component.Reactivity.setOwner(domNode, owner$3);
+        let owner$3 = Node$Xote.Reactivity.createOwner();
+        let childNode = Node$Xote.Reactivity.runWithOwner(owner$3, node._0);
+        Node$Xote.Reactivity.setOwner(domNode, owner$3);
         _node = childNode;
         continue;
       case "KeyedList" :
         let renderItem = node.renderItem;
         let keyFn = node.keyFn;
         let signal$2 = node.signal;
-        let owner$4 = Xote__Component.Reactivity.createOwner();
-        Xote__Component.Reactivity.setOwner(domNode, owner$4);
+        let owner$4 = Node$Xote.Reactivity.createOwner();
+        Node$Xote.Reactivity.setOwner(domNode, owner$4);
         let keyedItems = {};
         let walker$1 = make(domNode);
         skipUntilMarker(walker$1, "kl");
@@ -231,7 +232,7 @@ function hydrateNode(_node, domNode) {
             let itemElements = collectUntilMarker(walker$1, "/k");
             let element = itemElements.find(el => el.nodeType === 1);
             if (element !== undefined) {
-              let items = Signals.Signal.peek(signal$2);
+              let items = Signal$Xote.peek(signal$2);
               let item = Stdlib_Option.getOr(items.find(i => keyFn(i) === key), {});
               keyedItems[key] = {
                 key: key,
@@ -243,7 +244,7 @@ function hydrateNode(_node, domNode) {
           };
         };
         parseKeyedItems();
-        return Xote__Component.Reactivity.runWithOwner(owner$4, () => {
+        return Node$Xote.Reactivity.runWithOwner(owner$4, () => {
           let startAnchor = document.createComment(" keyed-list-start ");
           let endAnchor = document.createComment(" keyed-list-end ");
           let firstChild = domNode.firstChild;
@@ -254,7 +255,7 @@ function hydrateNode(_node, domNode) {
           }
           domNode.appendChild(endAnchor);
           let reconcile = () => {
-            let newItems = Signals.Signal.get(signal$2);
+            let newItems = Signal$Xote.get(signal$2);
             let newKeyMap = {};
             newItems.forEach(item => {
               newKeyMap[keyFn(item)] = item;
@@ -272,7 +273,7 @@ function hydrateNode(_node, domNode) {
             keysToRemove.forEach(key => {
               let keyedItem = keyedItems[key];
               if (keyedItem !== undefined) {
-                Xote__Component.Render.disposeElement(keyedItem.element);
+                Node$Xote.Render.disposeElement(keyedItem.element);
                 ((keyedItem.element.remove()));
                 Stdlib_Dict.$$delete(keyedItems, key);
                 return;
@@ -287,7 +288,7 @@ function hydrateNode(_node, domNode) {
                 if (existing.item !== item) {
                   elementsToReplace[key] = true;
                   let node = renderItem(item);
-                  let element = Xote__Component.Render.render(node);
+                  let element = Node$Xote.Render.render(node);
                   let keyedItem = {
                     key: key,
                     item: item,
@@ -301,7 +302,7 @@ function hydrateNode(_node, domNode) {
                 return;
               }
               let node$1 = renderItem(item);
-              let element$1 = Xote__Component.Render.render(node$1);
+              let element$1 = Node$Xote.Render.render(node$1);
               let keyedItem$1 = {
                 key: key,
                 item: item,
@@ -329,7 +330,7 @@ function hydrateNode(_node, domNode) {
               }
               let needsReplacement = Stdlib_Option.getOr(elementsToReplace[keyedItem.key], false);
               if (needsReplacement) {
-                Xote__Component.Render.disposeElement(currentElement);
+                Node$Xote.Render.disposeElement(currentElement);
                 domNode.replaceChild(keyedItem.element, currentElement);
                 marker.contents = keyedItem.element.nextSibling;
               } else {
@@ -338,10 +339,10 @@ function hydrateNode(_node, domNode) {
               }
             });
           };
-          let disposer = Signals.Effect.run(() => {
+          let disposer = Effect$Xote.runWithDisposer(() => {
             reconcile();
           }, undefined);
-          Xote__Component.Reactivity.addDisposer(owner$4, disposer);
+          Node$Xote.Reactivity.addDisposer(owner$4, disposer);
         });
     }
   };
@@ -358,9 +359,9 @@ function hydrateNodeWithWalker(node, walker) {
         return logHydrationWarning("Missing DOM element for Element node");
       }
       let domNode$1 = Primitive_option.valFromOption(domNode);
-      let owner = Xote__Component.Reactivity.createOwner();
-      Xote__Component.Reactivity.setOwner(domNode$1, owner);
-      return Xote__Component.Reactivity.runWithOwner(owner, () => {
+      let owner = Node$Xote.Reactivity.createOwner();
+      Node$Xote.Reactivity.setOwner(domNode$1, owner);
+      return Node$Xote.Reactivity.runWithOwner(owner, () => {
         attrs.forEach(param => {
           let value = param[1];
           let key = param[0];
@@ -369,16 +370,16 @@ function hydrateNodeWithWalker(node, walker) {
               return;
             case "SignalValue" :
               let signal = value._0;
-              let disposer = Signals.Effect.run(() => {
-                Xote__Component.DOM.setAttrOrProp(domNode$1, key, Signals.Signal.get(signal));
+              let disposer = Effect$Xote.runWithDisposer(() => {
+                Node$Xote.DOM.setAttrOrProp(domNode$1, key, Signal$Xote.get(signal));
               }, undefined);
-              return Xote__Component.Reactivity.addDisposer(owner, disposer);
+              return Node$Xote.Reactivity.addDisposer(owner, disposer);
             case "Compute" :
               let compute = value._0;
-              let disposer$1 = Signals.Effect.run(() => {
-                Xote__Component.DOM.setAttrOrProp(domNode$1, key, compute());
+              let disposer$1 = Effect$Xote.runWithDisposer(() => {
+                Node$Xote.DOM.setAttrOrProp(domNode$1, key, compute());
               }, undefined);
-              return Xote__Component.Reactivity.addDisposer(owner, disposer$1);
+              return Node$Xote.Reactivity.addDisposer(owner, disposer$1);
           }
         });
         events.forEach(param => {
@@ -398,13 +399,13 @@ function hydrateNodeWithWalker(node, walker) {
         return logHydrationWarning("Missing text node for SignalText");
       }
       let textNode$1 = Primitive_option.valFromOption(textNode);
-      let owner$1 = Xote__Component.Reactivity.createOwner();
-      Xote__Component.Reactivity.setOwner(textNode$1, owner$1);
-      Xote__Component.Reactivity.runWithOwner(owner$1, () => {
-        let disposer = Signals.Effect.run(() => {
-          textNode$1.textContent = Signals.Signal.get(signal);
+      let owner$1 = Node$Xote.Reactivity.createOwner();
+      Node$Xote.Reactivity.setOwner(textNode$1, owner$1);
+      Node$Xote.Reactivity.runWithOwner(owner$1, () => {
+        let disposer = Effect$Xote.runWithDisposer(() => {
+          textNode$1.textContent = Signal$Xote.get(signal);
         }, undefined);
-        Xote__Component.Reactivity.addDisposer(owner$1, disposer);
+        Node$Xote.Reactivity.addDisposer(owner$1, disposer);
       });
       skipUntilMarker(walker, "/$");
       return;
@@ -431,20 +432,20 @@ function hydrateNodeWithWalker(node, walker) {
           p.appendChild(container);
         }
       }
-      let owner$2 = Xote__Component.Reactivity.createOwner();
-      Xote__Component.Reactivity.setOwner(container, owner$2);
-      return Xote__Component.Reactivity.runWithOwner(owner$2, () => {
-        let disposer = Signals.Effect.run(() => {
-          let children = Signals.Signal.get(signal$1);
+      let owner$2 = Node$Xote.Reactivity.createOwner();
+      Node$Xote.Reactivity.setOwner(container, owner$2);
+      return Node$Xote.Reactivity.runWithOwner(owner$2, () => {
+        let disposer = Effect$Xote.runWithDisposer(() => {
+          let children = Signal$Xote.get(signal$1);
           let childNodes = (Array.from(container.childNodes || []));
-          childNodes.forEach(Xote__Component.Render.disposeElement);
+          childNodes.forEach(Node$Xote.Render.disposeElement);
           ((container.innerHTML = ''));
           children.forEach(child => {
-            let childEl = Xote__Component.Render.render(child);
+            let childEl = Node$Xote.Render.render(child);
             container.appendChild(childEl);
           });
         }, undefined);
-        Xote__Component.Reactivity.addDisposer(owner$2, disposer);
+        Node$Xote.Reactivity.addDisposer(owner$2, disposer);
       });
     case "LazyComponent" :
       skipUntilMarker(walker, "lc");
@@ -477,7 +478,7 @@ function hydrateNodeWithWalker(node, walker) {
           let itemElements = collectUntilMarker(walker, "/k");
           let element = itemElements.find(el => el.nodeType === 1);
           if (element !== undefined) {
-            let items = Signals.Signal.peek(signal$2);
+            let items = Signal$Xote.peek(signal$2);
             let item = Stdlib_Option.getOr(items.find(i => keyFn(i) === key), {});
             keyedItems[key] = {
               key: key,
@@ -521,14 +522,11 @@ function hydrateById(component, containerId, optionsOpt) {
   }
 }
 
-let Component;
-
 let DOM;
 
 let Reactivity;
 
 export {
-  Component,
   DOM,
   Reactivity,
   DOMWalker,
@@ -539,4 +537,4 @@ export {
   hydrate,
   hydrateById,
 }
-/* Xote__Component Not a pure module */
+/* Node-Xote Not a pure module */