xote 5.0.0 → 6.0.1

package/src/{Xote__SSR.res → SSR.res}

@@ -1,6 +1,4 @@
-open Signals
 
-module Component = Xote__Component
 
 /* ============================================================================
  * HTML Utilities
@@ -77,11 +75,11 @@ type renderOptions = {
 
 module Attributes = {
   /* Render a single attribute to string */
-  let renderAttr = ((key, value): (string, Component.attrValue)): string => {
+  let renderAttr = ((key, value): (string, Node.attrValue)): string => {
     let attrValue = switch value {
-    | Component.Static(v) => v
-    | Component.SignalValue(signal) => Signal.peek(signal)
-    | Component.Compute(fn) => fn()
+    | Node.Static(v) => v
+    | Node.SignalValue(signal) => Signal.peek(signal)
+    | Node.Compute(fn) => fn()
     }
 
     /* Handle boolean attributes */
@@ -104,7 +102,7 @@ module Attributes = {
   }
 
   /* Render all attributes to string */
-  let renderAttrs = (attrs: array<(string, Component.attrValue)>): string => {
+  let renderAttrs = (attrs: array<(string, Node.attrValue)>): string => {
     let rendered =
       attrs
       ->Array.map(renderAttr)
@@ -123,26 +121,26 @@ module Attributes = {
  * ============================================================================ */
 
 /* Render a virtual node to an HTML string */
-let rec renderNodeToString = (node: Component.node): string => {
+let rec renderNodeToString = (node: Node.node): string => {
   switch node {
-  | Component.Text(content) => Html.escape(content)
+  | Node.Text(content) => Html.escape(content)
 
-  | Component.SignalText(signal) => {
+  | Node.SignalText(signal) => {
       /* Read current signal value and wrap with hydration markers */
       let value = Signal.peek(signal)
       Markers.signalTextStart ++ Html.escape(value) ++ Markers.signalTextEnd
     }
 
-  | Component.Fragment(children) => children->Array.map(renderNodeToString)->Array.join("")
+  | Node.Fragment(children) => children->Array.map(renderNodeToString)->Array.join("")
 
-  | Component.SignalFragment(signal) => {
+  | Node.SignalFragment(signal) => {
       /* Read current signal value and wrap with hydration markers */
       let children = Signal.peek(signal)
       let content = children->Array.map(renderNodeToString)->Array.join("")
       Markers.signalFragmentStart ++ content ++ Markers.signalFragmentEnd
     }
 
-  | Component.Element({tag, attrs, children, events: _}) => {
+  | Node.Element({tag, attrs, children, events: _}) => {
       let attrsStr = Attributes.renderAttrs(attrs)
 
       if Html.isVoidElement(tag) {
@@ -153,13 +151,13 @@ let rec renderNodeToString = (node: Component.node): string => {
       }
     }
 
-  | Component.LazyComponent(fn) => {
+  | Node.LazyComponent(fn) => {
       /* Execute the lazy component and render its result */
       let childNode = fn()
       Markers.lazyComponentStart ++ renderNodeToString(childNode) ++ Markers.lazyComponentEnd
     }
 
-  | Component.KeyedList({signal, keyFn, renderItem}) => {
+  | Node.KeyedList({signal, keyFn, renderItem}) => {
       let items = Signal.peek(signal)
       let content =
         items
@@ -180,7 +178,7 @@ let rec renderNodeToString = (node: Component.node): string => {
  * ============================================================================ */
 
 /* Render a component to an HTML string synchronously */
-let renderToString = (component: unit => Component.node, ~options: renderOptions={}): string => {
+let renderToString = (component: unit => Node.node, ~options: renderOptions={}): string => {
   let _ = options /* Will be used for nonce/renderId in future phases */
   let node = component()
   renderNodeToString(node)
@@ -188,7 +186,7 @@ let renderToString = (component: unit => Component.node, ~options: renderOptions
 
 /* Render a component and wrap with a hydration root marker */
 let renderToStringWithRoot = (
-  component: unit => Component.node,
+  component: unit => Node.node,
   ~rootId: string="root",
   ~options: renderOptions={},
 ): string => {
@@ -218,7 +216,7 @@ let renderDocument = (
   ~styles: array<string>=[],
   ~stateScript: string="",
   ~nonce: option<string>=?,
-  component: unit => Component.node,
+  component: unit => Node.node,
 ): string => {
   let content = renderToString(component)
   let hydrationScript = generateHydrationScript(~nonce?)

package/src/{Xote__SSR.res.mjs → SSR.res.mjs}

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Signals from "rescript-signals/src/Signals.res.mjs";
+import * as Signal$Xote from "./Signal.res.mjs";
 
 function escape(str) {
   return str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#x27;");
@@ -77,7 +77,7 @@ function renderAttr(param) {
       attrValue = value._0;
       break;
     case "SignalValue" :
-      attrValue = Signals.Signal.peek(value._0);
+      attrValue = Signal$Xote.peek(value._0);
       break;
     case "Compute" :
       attrValue = value._0();
@@ -130,12 +130,12 @@ function renderNodeToString(node) {
     case "Text" :
       return escape(node._0);
     case "SignalText" :
-      let value = Signals.Signal.peek(node._0);
+      let value = Signal$Xote.peek(node._0);
       return signalTextStart + escape(value) + signalTextEnd;
     case "Fragment" :
       return node._0.map(renderNodeToString).join("");
     case "SignalFragment" :
-      let children = Signals.Signal.peek(node._0);
+      let children = Signal$Xote.peek(node._0);
       let content = children.map(renderNodeToString).join("");
       return signalFragmentStart + content + signalFragmentEnd;
     case "LazyComponent" :
@@ -144,7 +144,7 @@ function renderNodeToString(node) {
     case "KeyedList" :
       let renderItem = node.renderItem;
       let keyFn = node.keyFn;
-      let items = Signals.Signal.peek(node.signal);
+      let items = Signal$Xote.peek(node.signal);
       let content$1 = items.map(item => {
         let key = keyFn(item);
         let itemHtml = renderNodeToString(renderItem(item));
@@ -202,10 +202,7 @@ function renderDocument(headOpt, bodyAttrsOpt, scriptsOpt, stylesOpt, stateScrip
 </html>`;
 }
 
-let Component;
-
 export {
-  Component,
   Html,
   Markers,
   Attributes,

package/src/{Xote__SSRState.res → SSRState.res}

@@ -1,4 +1,3 @@
-open Signals
 
 /* ============================================================================
  * SSR State Serialization
@@ -85,6 +84,7 @@ module Codec = {
   let tuple2 = (codec1: t<'a>, codec2: t<'b>): t<('a, 'b)> => {
     encode: ((a, b)) => JSON.Encode.array([codec1.encode(a), codec2.encode(b)]),
     decode: json => {
+      ignore(json)
       let arr: option<array<JSON.t>> = %raw(`Array.isArray(json) ? json : undefined`)
       switch arr {
       | Some([j1, j2]) =>
@@ -101,6 +101,7 @@ module Codec = {
     encode: ((a, b, c)) =>
       JSON.Encode.array([codec1.encode(a), codec2.encode(b), codec3.encode(c)]),
     decode: json => {
+      ignore(json)
       let arr: option<array<JSON.t>> = %raw(`Array.isArray(json) ? json : undefined`)
       switch arr {
       | Some([j1, j2, j3]) =>
@@ -165,7 +166,7 @@ let registry: Dict.t<JSON.t> = Dict.make()
 
 /* Register a signal for serialization (server only) */
 let register = (id: string, signal: Signal.t<'a>, codec: Codec.t<'a>): unit => {
-  if Xote__SSRContext.isServer {
+  if SSRContext.isServer {
     registry->Dict.set(id, codec.encode(Signal.peek(signal)))
   }
 }
@@ -192,7 +193,7 @@ let generateScript = (~nonce: option<string>=?): string => {
   let json = JSON.stringifyAny(registry)->Option.getOr("{}")
   let escapedJson = escapeForScript(json)
   let nonceAttr = switch nonce {
-  | Some(n) => ` nonce="${Xote__SSR.Html.escape(n)}"`
+  | Some(n) => ` nonce="${SSR.Html.escape(n)}"`
   | None => ""
   }
   `<script${nonceAttr}>window.__XOTE_STATE__=${escapedJson};</script>`
@@ -204,7 +205,7 @@ let generateScript = (~nonce: option<string>=?): string => {
 
 /* Get the serialized state from window */
 let getClientState = (): Dict.t<JSON.t> => {
-  if Xote__SSRContext.isClient {
+  if SSRContext.isClient {
     %raw(`window.__XOTE_STATE__ || {}`)
   } else {
     Dict.make()
@@ -213,7 +214,7 @@ let getClientState = (): Dict.t<JSON.t> => {
 
 /* Restore a signal from serialized state (client only) */
 let restore = (id: string, signal: Signal.t<'a>, codec: Codec.t<'a>): unit => {
-  if Xote__SSRContext.isClient {
+  if SSRContext.isClient {
     let state = getClientState()
     switch state->Dict.get(id) {
     | Some(json) =>
@@ -232,7 +233,7 @@ let restore = (id: string, signal: Signal.t<'a>, codec: Codec.t<'a>): unit => {
 
 /* Sync a signal: register on server, restore on client */
 let sync = (id: string, signal: Signal.t<'a>, codec: Codec.t<'a>): unit => {
-  Xote__SSRContext.match(
+  SSRContext.match(
     ~server=() => register(id, signal, codec),
     ~client=() => restore(id, signal, codec),
   )

package/src/{Xote__SSRState.res.mjs → SSRState.res.mjs}

@@ -1,13 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Signals from "rescript-signals/src/Signals.res.mjs";
-import * as Xote__SSR from "./Xote__SSR.res.mjs";
+import * as SSR$Xote from "./SSR.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_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SSRContext$Xote from "./SSRContext.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as Xote__SSRContext from "./Xote__SSRContext.res.mjs";
 
 function int_encode(v) {
   return v;
@@ -215,8 +215,8 @@ let Codec = {
 let registry = {};
 
 function register(id, signal, codec) {
-  if (Xote__SSRContext.isServer) {
-    registry[id] = codec.encode(Signals.Signal.peek(signal));
+  if (SSRContext$Xote.isServer) {
+    registry[id] = codec.encode(Signal$Xote.peek(signal));
     return;
   }
 }
@@ -234,12 +234,12 @@ function escapeForScript(str) {
 function generateScript(nonce) {
   let json = Stdlib_Option.getOr(JSON.stringify(registry), "{}");
   let escapedJson = escapeForScript(json);
-  let nonceAttr = nonce !== undefined ? ` nonce="` + Xote__SSR.Html.escape(nonce) + `"` : "";
+  let nonceAttr = nonce !== undefined ? ` nonce="` + SSR$Xote.Html.escape(nonce) + `"` : "";
   return `<script` + nonceAttr + `>window.__XOTE_STATE__=` + escapedJson + `;</script>`;
 }
 
 function getClientState() {
-  if (Xote__SSRContext.isClient) {
+  if (SSRContext$Xote.isClient) {
     return (window.__XOTE_STATE__ || {});
   } else {
     return {};
@@ -247,7 +247,7 @@ function getClientState() {
 }
 
 function restore(id, signal, codec) {
-  if (!Xote__SSRContext.isClient) {
+  if (!SSRContext$Xote.isClient) {
     return;
   }
   let state = getClientState();
@@ -257,16 +257,16 @@ function restore(id, signal, codec) {
   }
   let value = codec.decode(json);
   if (value !== undefined) {
-    return Signals.Signal.set(signal, Primitive_option.valFromOption(value));
+    return Signal$Xote.set(signal, Primitive_option.valFromOption(value));
   }
 }
 
 function sync(id, signal, codec) {
-  Xote__SSRContext.match(() => register(id, signal, codec), () => restore(id, signal, codec));
+  SSRContext$Xote.match(() => register(id, signal, codec), () => restore(id, signal, codec));
 }
 
 function make$1(id, initial, codec) {
-  let signal = Signals.Signal.make(initial, undefined, undefined);
+  let signal = Signal$Xote.make(initial, undefined, undefined);
   sync(id, signal, codec);
   return signal;
 }
@@ -283,4 +283,4 @@ export {
   sync,
   make$1 as make,
 }
-/* Xote__SSRContext Not a pure module */
+/* SSRContext-Xote Not a pure module */

package/src/Signal.res

@@ -0,0 +1 @@
+include Signals.Signal

package/src/Signal.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Signal$Signals from "rescript-signals/src/signals/Signal.res.mjs";
+
+let make = Signal$Signals.make;
+
+let makeForComputed = Signal$Signals.makeForComputed;
+
+let get = Signal$Signals.get;
+
+let peek = Signal$Signals.peek;
+
+let set = Signal$Signals.set;
+
+let update = Signal$Signals.update;
+
+let batch = Signal$Signals.batch;
+
+let untrack = Signal$Signals.untrack;
+
+export {
+  make,
+  makeForComputed,
+  get,
+  peek,
+  set,
+  update,
+  batch,
+  untrack,
+}
+/* No side effect */

package/src/{Xote__JSX.res → XoteJSX.res}

@@ -1,9 +1,7 @@
-open Signals
-module Component = Xote__Component
-module ReactiveProp = Xote__ReactiveProp
+module ReactiveProp = ReactiveProp
 
 /* ReScript JSX transform type aliases */
-type element = Component.node
+type element = Node.node
 
 type component<'props> = 'props => element
 
@@ -14,7 +12,7 @@ type componentLike<'props, 'return> = 'props => 'return
  * evaluated during a Computed context, which would incorrectly track their
  * dependencies as belonging to the outer computed. */
 let jsx = (component: component<'props>, props: 'props): element =>
-  Component.LazyComponent(() => component(props))
+  Node.LazyComponent(() => component(props))
 
 let jsxs = jsx
 
@@ -36,14 +34,14 @@ type fragmentProps = {children?: element}
 let jsxFragment = (props: fragmentProps): element => {
   switch props.children {
   | Some(child) => child
-  | None => Component.fragment([])
+  | None => Node.fragment([])
   }
 }
 
 /* Element converters for JSX expressions */
-let array = (children: array<element>): element => Component.fragment(children)
+let array = (children: array<element>): element => Node.fragment(children)
 
-let null = (): element => Component.text("")
+let null = (): element => Node.text("")
 
 /* Elements module for lowercase HTML tags */
 module Elements = {
@@ -146,58 +144,59 @@ module Elements = {
 
   /* Helper to detect if a value is a ReactiveProp variant (checks for Static/Reactive tags) */
   let isReactiveProp = (value: 'a): bool => {
+    ignore(value)
     %raw(`value && typeof value === 'object' && ('TAG' in value) && (value.TAG === 'Static' || value.TAG === 'Reactive')`)
   }
 
   /* Helper to convert string attribute value (supports raw string, ReactiveProp, Signal, or computed function) */
-  let convertAttrValue = (key: string, value: 'a): (string, Component.attrValue) => {
+  let convertAttrValue = (key: string, value: 'a): (string, Node.attrValue) => {
     if isReactiveProp(value) {
       // It's a ReactiveProp variant - pattern match on it
       let rp: ReactiveProp.t<string> = Obj.magic(value)
       switch rp {
-      | Static(s) => Component.attr(key, s)
-      | Reactive(signal) => Component.signalAttr(key, signal)
+      | Static(s) => Node.attr(key, s)
+      | Reactive(signal) => Node.signalAttr(key, signal)
       }
     } else if typeof(value) == #function {
       // It's a computed function (for backward compatibility)
       let f: unit => string = Obj.magic(value)
-      Component.computedAttr(key, f)
+      Node.computedAttr(key, f)
     } else if typeof(value) == #object {
       // It's a raw signal (for backward compatibility)
       let sig: Signal.t<string> = Obj.magic(value)
-      Component.signalAttr(key, sig)
+      Node.signalAttr(key, sig)
     } else {
       // It's a raw string
       let s: string = Obj.magic(value)
-      Component.attr(key, s)
+      Node.attr(key, s)
     }
   }
 
   /* Helper to convert boolean attribute value (supports raw bool, ReactiveProp, Signal, or computed function) */
-  let convertBoolAttrValue = (key: string, value: 'a): (string, Component.attrValue) => {
+  let convertBoolAttrValue = (key: string, value: 'a): (string, Node.attrValue) => {
     if isReactiveProp(value) {
       // It's a ReactiveProp variant - pattern match on it
       let rp: ReactiveProp.t<bool> = Obj.magic(value)
       switch rp {
-      | Static(b) => Component.attr(key, b ? "true" : "false")
+      | Static(b) => Node.attr(key, b ? "true" : "false")
       | Reactive(signal) => {
           let strSignal = Computed.make(() => Signal.get(signal) ? "true" : "false")
-          Component.signalAttr(key, strSignal)
+          Node.signalAttr(key, strSignal)
         }
       }
     } else if typeof(value) == #function {
       // It's a computed function that returns bool (for backward compatibility)
       let f: unit => bool = Obj.magic(value)
-      Component.computedAttr(key, () => f() ? "true" : "false")
+      Node.computedAttr(key, () => f() ? "true" : "false")
     } else if typeof(value) == #object {
       // It's a raw signal (for backward compatibility)
       let sig: Signal.t<bool> = Obj.magic(value)
       let strSignal = Computed.make(() => Signal.get(sig) ? "true" : "false")
-      Component.signalAttr(key, strSignal)
+      Node.signalAttr(key, strSignal)
     } else {
       // It's a raw bool
       let b: bool = Obj.magic(value)
-      Component.attr(key, b ? "true" : "false")
+      Node.attr(key, b ? "true" : "false")
     }
   }
 
@@ -212,7 +211,7 @@ module Elements = {
   /* Helper to add optional int attribute */
   let addIntAttr = (attrs, opt, key) => {
     switch opt {
-    | Some(v) => attrs->Array.push(Component.attr(key, Int.toString(v)))
+    | Some(v) => attrs->Array.push(Node.attr(key, Int.toString(v)))
     | None => ()
     }
   }
@@ -251,7 +250,7 @@ module Elements = {
       _,
       _,
     >,
-  ): array<(string, Component.attrValue)> => {
+  ): array<(string, Node.attrValue)> => {
     let attrs = []
 
     /* Standard attributes */
@@ -457,7 +456,7 @@ module Elements = {
       _,
     >,
   ): element => {
-    Component.Element({
+    Node.Element({
       tag,
       attrs: propsToAttrs(props),
       events: propsToEvents(props),

package/src/{Xote__JSX.res.mjs → XoteJSX.res.mjs}

@@ -1,7 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Signals from "rescript-signals/src/Signals.res.mjs";
-import * as Xote__Component from "./Xote__Component.res.mjs";
+import * as Node$Xote from "./Node.res.mjs";
+import * as Signal$Xote from "./Signal.res.mjs";
+import * as Computed$Xote from "./Computed.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
 function jsx(component, props) {
@@ -23,14 +24,14 @@ function jsxFragment(props) {
   if (child !== undefined) {
     return child;
   } else {
-    return Xote__Component.fragment([]);
+    return Node$Xote.fragment([]);
   }
 }
 
-let array = Xote__Component.fragment;
+let array = Node$Xote.fragment;
 
 function $$null() {
-  return Xote__Component.text("");
+  return Node$Xote.text("");
 }
 
 function isReactiveProp(value) {
@@ -40,36 +41,36 @@ function isReactiveProp(value) {
 function convertAttrValue(key, value) {
   if (isReactiveProp(value)) {
     if (value.TAG === "Reactive") {
-      return Xote__Component.signalAttr(key, value._0);
+      return Node$Xote.signalAttr(key, value._0);
     } else {
-      return Xote__Component.attr(key, value._0);
+      return Node$Xote.attr(key, value._0);
     }
   } else if (typeof value === "function") {
-    return Xote__Component.computedAttr(key, value);
+    return Node$Xote.computedAttr(key, value);
   } else if (typeof value === "object") {
-    return Xote__Component.signalAttr(key, value);
+    return Node$Xote.signalAttr(key, value);
   } else {
-    return Xote__Component.attr(key, value);
+    return Node$Xote.attr(key, value);
   }
 }
 
 function convertBoolAttrValue(key, value) {
   if (isReactiveProp(value)) {
     if (value.TAG !== "Reactive") {
-      return Xote__Component.attr(key, value._0 ? "true" : "false");
+      return Node$Xote.attr(key, value._0 ? "true" : "false");
     }
     let signal = value._0;
-    let strSignal = Signals.Computed.make(() => {
-      if (Signals.Signal.get(signal)) {
+    let strSignal = Computed$Xote.make(() => {
+      if (Signal$Xote.get(signal)) {
         return "true";
       } else {
         return "false";
       }
     }, undefined);
-    return Xote__Component.signalAttr(key, strSignal);
+    return Node$Xote.signalAttr(key, strSignal);
   }
   if (typeof value === "function") {
-    return Xote__Component.computedAttr(key, () => {
+    return Node$Xote.computedAttr(key, () => {
       if (value()) {
         return "true";
       } else {
@@ -78,16 +79,16 @@ function convertBoolAttrValue(key, value) {
     });
   }
   if (typeof value !== "object") {
-    return Xote__Component.attr(key, value ? "true" : "false");
+    return Node$Xote.attr(key, value ? "true" : "false");
   }
-  let strSignal$1 = Signals.Computed.make(() => {
-    if (Signals.Signal.get(value)) {
+  let strSignal$1 = Computed$Xote.make(() => {
+    if (Signal$Xote.get(value)) {
       return "true";
     } else {
       return "false";
     }
   }, undefined);
-  return Xote__Component.signalAttr(key, strSignal$1);
+  return Node$Xote.signalAttr(key, strSignal$1);
 }
 
 function addAttr(attrs, opt, key, converter) {
@@ -99,7 +100,7 @@ function addAttr(attrs, opt, key, converter) {
 
 function addIntAttr(attrs, opt, key) {
   if (opt !== undefined) {
-    attrs.push(Xote__Component.attr(key, opt.toString()));
+    attrs.push(Node$Xote.attr(key, opt.toString()));
     return;
   }
 }
@@ -225,8 +226,6 @@ let Elements = {
   jsxsKeyed: jsxKeyed$1
 };
 
-let Component;
-
 let ReactiveProp;
 
 let jsxs = jsx;
@@ -234,7 +233,6 @@ let jsxs = jsx;
 let jsxsKeyed = jsxKeyed;
 
 export {
-  Component,
   ReactiveProp,
   jsx,
   jsxs,
@@ -245,4 +243,4 @@ export {
   $$null,
   Elements,
 }
-/* Xote__Component Not a pure module */
+/* Node-Xote Not a pure module */

package/src/Xote.res

@@ -1,43 +0,0 @@
-module Signal = {
-  include Signals.Signal
-}
-
-module Computed = {
-  include Signals.Computed
-}
-
-module Effect = {
-  include Signals.Effect
-}
-
-module Component = {
-  include Xote__Component
-}
-
-module Route = {
-  include Xote__Route
-}
-
-module Router = {
-  include Xote__Router
-}
-
-module ReactiveProp = {
-  include Xote__ReactiveProp
-}
-
-module SSR = {
-  include Xote__SSR
-}
-
-module SSRContext = {
-  include Xote__SSRContext
-}
-
-module SSRState = {
-  include Xote__SSRState
-}
-
-module Hydration = {
-  include Xote__Hydration
-}