xote 1.0.2 → 1.0.3

package/src/Xote__Component.res

@@ -1,151 +0,0 @@
-module Signal = Xote__Signal
-module Effect = Xote__Effect
-module Core = Xote__Core
-module Computed = Xote__Computed
-
-/* Type representing a virtual node */
-type rec node =
-  | Element({
-      tag: string,
-      attrs: array<(string, string)>,
-      events: array<(string, Dom.event => unit)>,
-      children: array<node>,
-    })
-  | Text(string)
-  | SignalText(Core.t<string>)
-  | Fragment(array<node>)
-  | SignalFragment(Core.t<array<node>>)
-
-/* Create a text node */
-let text = (content: string): node => Text(content)
-
-/* Create a reactive text node from a signal */
-let textSignal = (signal: Core.t<string>): node => SignalText(signal)
-
-/* Create a fragment (multiple children without wrapper) */
-let fragment = (children: array<node>): node => Fragment(children)
-
-/* Create a reactive fragment from a signal */
-let signalFragment = (signal: Core.t<array<node>>): node => SignalFragment(signal)
-
-/* Create a reactive list from a signal and render function */
-let list = (signal: Core.t<array<'a>>, renderItem: 'a => node): node => {
-  let nodesSignal = Computed.make(() => {
-    Signal.get(signal)->Array.map(renderItem)
-  })
-  SignalFragment(nodesSignal)
-}
-
-/* Create an element */
-let element = (
-  tag: string,
-  ~attrs: array<(string, string)>=[]->Array.map(x => x),
-  ~events: array<(string, Dom.event => unit)>=[]->Array.map(x => x),
-  ~children: array<node>=[]->Array.map(x => x),
-  (),
-): node => Element({tag, attrs, events, children})
-
-/* Helper to create common elements */
-let div = (~attrs=?, ~events=?, ~children=?, ()) => element("div", ~attrs?, ~events?, ~children?, ())
-let span = (~attrs=?, ~events=?, ~children=?, ()) => element("span", ~attrs?, ~events?, ~children?, ())
-let button = (~attrs=?, ~events=?, ~children=?, ()) =>
-  element("button", ~attrs?, ~events?, ~children?, ())
-let input = (~attrs=?, ~events=?, ()) => element("input", ~attrs?, ~events?, ())
-let h1 = (~attrs=?, ~events=?, ~children=?, ()) => element("h1", ~attrs?, ~events?, ~children?, ())
-let h2 = (~attrs=?, ~events=?, ~children=?, ()) => element("h2", ~attrs?, ~events?, ~children?, ())
-let h3 = (~attrs=?, ~events=?, ~children=?, ()) => element("h3", ~attrs?, ~events?, ~children?, ())
-let p = (~attrs=?, ~events=?, ~children=?, ()) => element("p", ~attrs?, ~events?, ~children?, ())
-let ul = (~attrs=?, ~events=?, ~children=?, ()) => element("ul", ~attrs?, ~events?, ~children?, ())
-let li = (~attrs=?, ~events=?, ~children=?, ()) => element("li", ~attrs?, ~events?, ~children?, ())
-
-/* External bindings for DOM manipulation */
-@val @scope("document") external createElement: string => Dom.element = "createElement"
-@val @scope("document") external createTextNode: string => Dom.element = "createTextNode"
-@val @scope("document") external createDocumentFragment: unit => Dom.element = "createDocumentFragment"
-@val @scope("document") external getElementById: string => Nullable.t<Dom.element> = "getElementById"
-
-@send external setAttribute: (Dom.element, string, string) => unit = "setAttribute"
-@send external addEventListener: (Dom.element, string, Dom.event => unit) => unit = "addEventListener"
-@send external appendChild: (Dom.element, Dom.element) => unit = "appendChild"
-@set external setTextContent: (Dom.element, string) => unit = "textContent"
-
-/* Render a virtual node to a real DOM element */
-let rec render = (node: node): Dom.element => {
-  switch node {
-  | Text(content) => createTextNode(content)
-  | SignalText(signal) => {
-      let el = createTextNode(Signal.peek(signal))
-
-      /* Set up effect to update text when signal changes */
-      let _ = Effect.run(() => {
-        let content = Signal.get(signal)
-        el->setTextContent(content)
-      })
-
-      el
-    }
-  | Element({tag, attrs, events, children}) => {
-      let el = createElement(tag)
-
-      /* Set attributes */
-      attrs->Array.forEach(((key, value)) => {
-        el->setAttribute(key, value)
-      })
-
-      /* Attach event listeners */
-      events->Array.forEach(((eventName, handler)) => {
-        el->addEventListener(eventName, handler)
-      })
-
-      /* Append children */
-      children->Array.forEach(child => {
-        let childEl = render(child)
-        el->appendChild(childEl)
-      })
-
-      el
-    }
-  | Fragment(children) => {
-      let fragment = createDocumentFragment()
-      children->Array.forEach(child => {
-        let childEl = render(child)
-        fragment->appendChild(childEl)
-      })
-      fragment
-    }
-  | SignalFragment(signal) => {
-      /* Create a container element to hold the dynamic children */
-      let container = createElement("div")
-      setAttribute(container, "data-signal-fragment", "true")
-      setAttribute(container, "style", "display: contents")
-
-      /* Set up effect to update children when signal changes */
-      let _ = Effect.run(() => {
-        let children = Signal.get(signal)
-        /* Clear existing children */
-        %raw(`container.innerHTML = ''`)
-        /* Render and append new children */
-        children->Array.forEach(child => {
-          let childEl = render(child)
-          container->appendChild(childEl)
-        })
-      })
-
-      container
-    }
-  }
-}
-
-/* Mount a node to a container element */
-let mount = (node: node, container: Dom.element): unit => {
-  let el = render(node)
-  container->appendChild(el)
-}
-
-/* Mount a node to a container by ID */
-let mountById = (node: node, containerId: string): unit => {
-  switch getElementById(containerId)->Nullable.toOption {
-  | Some(container) => mount(node, container)
-  | None => Console.error("Container element not found: " ++ containerId)
-  }
-}

package/src/Xote__Component.res.mjs

@@ -1,202 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Xote__Effect from "./Xote__Effect.res.mjs";
-import * as Xote__Signal from "./Xote__Signal.res.mjs";
-import * as Xote__Computed from "./Xote__Computed.res.mjs";
-
-function text(content) {
-  return {
-          TAG: "Text",
-          _0: content
-        };
-}
-
-function textSignal(signal) {
-  return {
-          TAG: "SignalText",
-          _0: signal
-        };
-}
-
-function fragment(children) {
-  return {
-          TAG: "Fragment",
-          _0: children
-        };
-}
-
-function signalFragment(signal) {
-  return {
-          TAG: "SignalFragment",
-          _0: signal
-        };
-}
-
-function list(signal, renderItem) {
-  var nodesSignal = Xote__Computed.make(function () {
-        return Xote__Signal.get(signal).map(renderItem);
-      });
-  return {
-          TAG: "SignalFragment",
-          _0: nodesSignal
-        };
-}
-
-function element(tag, attrsOpt, eventsOpt, childrenOpt, param) {
-  var attrs = attrsOpt !== undefined ? attrsOpt : [].map(function (x) {
-          return x;
-        });
-  var events = eventsOpt !== undefined ? eventsOpt : [].map(function (x) {
-          return x;
-        });
-  var children = childrenOpt !== undefined ? childrenOpt : [].map(function (x) {
-          return x;
-        });
-  return {
-          TAG: "Element",
-          tag: tag,
-          attrs: attrs,
-          events: events,
-          children: children
-        };
-}
-
-function div(attrs, events, children, param) {
-  return element("div", attrs, events, children, undefined);
-}
-
-function span(attrs, events, children, param) {
-  return element("span", attrs, events, children, undefined);
-}
-
-function button(attrs, events, children, param) {
-  return element("button", attrs, events, children, undefined);
-}
-
-function input(attrs, events, param) {
-  return element("input", attrs, events, undefined, undefined);
-}
-
-function h1(attrs, events, children, param) {
-  return element("h1", attrs, events, children, undefined);
-}
-
-function h2(attrs, events, children, param) {
-  return element("h2", attrs, events, children, undefined);
-}
-
-function h3(attrs, events, children, param) {
-  return element("h3", attrs, events, children, undefined);
-}
-
-function p(attrs, events, children, param) {
-  return element("p", attrs, events, children, undefined);
-}
-
-function ul(attrs, events, children, param) {
-  return element("ul", attrs, events, children, undefined);
-}
-
-function li(attrs, events, children, param) {
-  return element("li", attrs, events, children, undefined);
-}
-
-function render(node) {
-  switch (node.TAG) {
-    case "Element" :
-        var el = document.createElement(node.tag);
-        node.attrs.forEach(function (param) {
-              el.setAttribute(param[0], param[1]);
-            });
-        node.events.forEach(function (param) {
-              el.addEventListener(param[0], param[1]);
-            });
-        node.children.forEach(function (child) {
-              var childEl = render(child);
-              el.appendChild(childEl);
-            });
-        return el;
-    case "Text" :
-        return document.createTextNode(node._0);
-    case "SignalText" :
-        var signal = node._0;
-        var el$1 = document.createTextNode(Xote__Signal.peek(signal));
-        Xote__Effect.run(function () {
-              var content = Xote__Signal.get(signal);
-              el$1.textContent = content;
-            });
-        return el$1;
-    case "Fragment" :
-        var fragment = document.createDocumentFragment();
-        node._0.forEach(function (child) {
-              var childEl = render(child);
-              fragment.appendChild(childEl);
-            });
-        return fragment;
-    case "SignalFragment" :
-        var signal$1 = node._0;
-        var container = document.createElement("div");
-        container.setAttribute("data-signal-fragment", "true");
-        container.setAttribute("style", "display: contents");
-        Xote__Effect.run(function () {
-              var children = Xote__Signal.get(signal$1);
-              ((container.innerHTML = ''));
-              children.forEach(function (child) {
-                    var childEl = render(child);
-                    container.appendChild(childEl);
-                  });
-            });
-        return container;
-    
-  }
-}
-
-function mount(node, container) {
-  var el = render(node);
-  container.appendChild(el);
-}
-
-function mountById(node, containerId) {
-  var container = document.getElementById(containerId);
-  if (container == null) {
-    console.error("Container element not found: " + containerId);
-    return ;
-  } else {
-    return mount(node, container);
-  }
-}
-
-var Signal;
-
-var Effect;
-
-var Core;
-
-var Computed;
-
-export {
-  Signal ,
-  Effect ,
-  Core ,
-  Computed ,
-  text ,
-  textSignal ,
-  fragment ,
-  signalFragment ,
-  list ,
-  element ,
-  div ,
-  span ,
-  button ,
-  input ,
-  h1 ,
-  h2 ,
-  h3 ,
-  p ,
-  ul ,
-  li ,
-  render ,
-  mount ,
-  mountById ,
-}
-/* No side effect */

package/src/Xote__Computed.res

@@ -1,43 +0,0 @@
-module IntSet = Belt.Set.Int
-module IntMap = Belt.Map.Int
-module Signal = Xote__Signal
-module Core = Xote__Core
-module Observer = Xote__Observer
-module Id = Xote__Id
-
-let make = (calc: unit => 'a): Core.t<'a> => {
-  /* create backing signal */
-  let s = Signal.make((Obj.magic(): 'a))
-  /* mark it as absent; force first compute */
-  let initialized = ref(false)
-
-  let id = Id.make()
-  let rec recompute = () => {
-    let next = calc()
-    if initialized.contents == false {
-      initialized := true
-      Signal.set(s, next)
-    } else {
-      Signal.set(s, next)
-    }
-  }
-
-  let rec o: Observer.t = {
-    id,
-    kind: #Computed(s.id),
-    run: recompute,
-    deps: IntSet.empty,
-  }
-
-  Core.observers := IntMap.set(Core.observers.contents, id, o)
-
-  /* initial compute under tracking */
-  Core.clearDeps(o)
-  Core.currentObserverId := Some(id)
-  o.run()
-  Core.currentObserverId := None
-
-  /* When dependencies change, scheduler will run `recompute` which writes to s,
-   and that write will notify s's own dependents. */
-  s
-}

package/src/Xote__Computed.res.mjs

@@ -1,61 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Xote__Id from "./Xote__Id.res.mjs";
-import * as Xote__Core from "./Xote__Core.res.mjs";
-import * as Belt_MapInt from "rescript/lib/es6/belt_MapInt.js";
-import * as Xote__Signal from "./Xote__Signal.res.mjs";
-
-function make(calc) {
-  var s = Xote__Signal.make();
-  var initialized = {
-    contents: false
-  };
-  var id = Xote__Id.make();
-  var recompute = function () {
-    var next = calc();
-    if (initialized.contents === false) {
-      initialized.contents = true;
-      return Xote__Signal.set(s, next);
-    } else {
-      return Xote__Signal.set(s, next);
-    }
-  };
-  var o = {
-    id: id,
-    kind: {
-      NAME: "Computed",
-      VAL: s.id
-    },
-    run: recompute,
-    deps: undefined
-  };
-  Xote__Core.observers.contents = Belt_MapInt.set(Xote__Core.observers.contents, id, o);
-  Xote__Core.clearDeps(o);
-  Xote__Core.currentObserverId.contents = id;
-  o.run();
-  Xote__Core.currentObserverId.contents = undefined;
-  return s;
-}
-
-var IntSet;
-
-var IntMap;
-
-var Signal;
-
-var Core;
-
-var Observer;
-
-var Id;
-
-export {
-  IntSet ,
-  IntMap ,
-  Signal ,
-  Core ,
-  Observer ,
-  Id ,
-  make ,
-}
-/* No side effect */

package/src/Xote__Core.res

@@ -1,105 +0,0 @@
-module IntSet = Belt.Set.Int
-module IntMap = Belt.Map.Int
-module Observer = Xote__Observer
-module Id = Xote__Id
-
-type t<'a> = {id: int, value: ref<'a>, version: ref<int>}
-
-/* Global tables */
-let observers: ref<IntMap.t<Observer.t>> = ref(IntMap.empty)
-let signalObservers: ref<IntMap.t<IntSet.t>> = ref(IntMap.empty) /* signal id -> observer ids */
-let signalPeeks: ref<IntSet.t> = ref(IntSet.empty) /* optional; for debugging */
-
-/* Currently running observer for tracking */
-let currentObserverId: ref<option<int>> = ref(None)
-
-/* Simple scheduler */
-let pending: ref<IntSet.t> = ref(IntSet.empty)
-let batching = ref(false)
-
-let ensureSignalBucket = (sid: int) => {
-  switch IntMap.get(signalObservers.contents, sid) {
-  | Some(_) => ()
-  | None => signalObservers := IntMap.set(signalObservers.contents, sid, IntSet.empty)
-  }
-}
-
-let addDep = (obsId: int, sid: int) => {
-  ensureSignalBucket(sid)
-  /* add obs -> dep */
-  let obs = Belt.Option.getExn(IntMap.get(observers.contents, obsId))
-  if currentObserverId.contents == Some(obsId) {
-    if obs.deps->IntSet.has(sid) == false {
-      obs.deps = obs.deps->IntSet.add(sid)
-      /* add dep -> obs */
-      let sset = Belt.Option.getExn(IntMap.get(signalObservers.contents, sid))
-      signalObservers := IntMap.set(signalObservers.contents, sid, sset->IntSet.add(obsId))
-    }
-  }
-}
-
-let clearDeps = (obs: Observer.t) => {
-  /* remove obs from all signal buckets it was in */
-  obs.deps->IntSet.forEach(sid => {
-    switch IntMap.get(signalObservers.contents, sid) {
-    | None => ()
-    | Some(sset) =>
-      signalObservers := IntMap.set(signalObservers.contents, sid, sset->IntSet.remove(obs.id))
-    }
-  })
-  obs.deps = IntSet.empty
-}
-
-let schedule = (obsId: int) => {
-  pending := pending.contents->IntSet.add(obsId)
-  if batching.contents == false {
-    /* flush immediately (sync microtask-ish) */
-    let toRun = pending.contents
-    pending := IntSet.empty
-    toRun->IntSet.forEach(id => {
-      switch IntMap.get(observers.contents, id) {
-      | None => ()
-      | Some(o) => {
-          /* re-track */
-          clearDeps(o)
-          currentObserverId := Some(id)
-          o.run()
-          currentObserverId := None
-        }
-      }
-    })
-  }
-}
-
-let notify = (sid: int) => {
-  ensureSignalBucket(sid)
-  switch IntMap.get(signalObservers.contents, sid) {
-  | None => ()
-  | Some(sset) => sset->IntSet.forEach(schedule)
-  }
-}
-
-/* Run a function without tracking dependencies */
-let untrack = (f: unit => 'a): 'a => {
-  let prev = currentObserverId.contents
-  currentObserverId := None
-  let r = f()
-  currentObserverId := prev
-  r
-}
-
-/* Batch: defer scheduling until after block ends */
-let batch = (f: unit => 'a): 'a => {
-  let prev = batching.contents
-  batching := true
-  let r = f()
-  batching := prev
-
-  /* flush anything queued */
-  if pending.contents != IntSet.empty {
-    let toRun = pending.contents
-    pending := IntSet.empty
-    toRun->IntSet.forEach(id => schedule(id))
-  }
-  r
-}

package/src/Xote__Core.res.mjs

@@ -1,148 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
-import * as Belt_MapInt from "rescript/lib/es6/belt_MapInt.js";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Belt_SetInt from "rescript/lib/es6/belt_SetInt.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
-
-var observers = {
-  contents: undefined
-};
-
-var signalObservers = {
-  contents: undefined
-};
-
-var signalPeeks = {
-  contents: undefined
-};
-
-var currentObserverId = {
-  contents: undefined
-};
-
-var pending = {
-  contents: undefined
-};
-
-var batching = {
-  contents: false
-};
-
-function ensureSignalBucket(sid) {
-  var match = Belt_MapInt.get(signalObservers.contents, sid);
-  if (match !== undefined) {
-    return ;
-  } else {
-    signalObservers.contents = Belt_MapInt.set(signalObservers.contents, sid, undefined);
-    return ;
-  }
-}
-
-function addDep(obsId, sid) {
-  ensureSignalBucket(sid);
-  var obs = Belt_Option.getExn(Belt_MapInt.get(observers.contents, obsId));
-  if (!Caml_obj.equal(currentObserverId.contents, obsId)) {
-    return ;
-  }
-  if (Belt_SetInt.has(obs.deps, sid) !== false) {
-    return ;
-  }
-  obs.deps = Belt_SetInt.add(obs.deps, sid);
-  var sset = Belt_Option.getExn(Belt_MapInt.get(signalObservers.contents, sid));
-  signalObservers.contents = Belt_MapInt.set(signalObservers.contents, sid, Belt_SetInt.add(sset, obsId));
-}
-
-function clearDeps(obs) {
-  Belt_SetInt.forEach(obs.deps, (function (sid) {
-          var sset = Belt_MapInt.get(signalObservers.contents, sid);
-          if (sset !== undefined) {
-            signalObservers.contents = Belt_MapInt.set(signalObservers.contents, sid, Belt_SetInt.remove(Caml_option.valFromOption(sset), obs.id));
-            return ;
-          }
-          
-        }));
-  obs.deps = undefined;
-}
-
-function schedule(obsId) {
-  pending.contents = Belt_SetInt.add(pending.contents, obsId);
-  if (batching.contents !== false) {
-    return ;
-  }
-  var toRun = pending.contents;
-  pending.contents = undefined;
-  Belt_SetInt.forEach(toRun, (function (id) {
-          var o = Belt_MapInt.get(observers.contents, id);
-          if (o !== undefined) {
-            clearDeps(o);
-            currentObserverId.contents = id;
-            o.run();
-            currentObserverId.contents = undefined;
-            return ;
-          }
-          
-        }));
-}
-
-function notify(sid) {
-  ensureSignalBucket(sid);
-  var sset = Belt_MapInt.get(signalObservers.contents, sid);
-  if (sset !== undefined) {
-    return Belt_SetInt.forEach(Caml_option.valFromOption(sset), schedule);
-  }
-  
-}
-
-function untrack(f) {
-  var prev = currentObserverId.contents;
-  currentObserverId.contents = undefined;
-  var r = f();
-  currentObserverId.contents = prev;
-  return r;
-}
-
-function batch(f) {
-  var prev = batching.contents;
-  batching.contents = true;
-  var r = f();
-  batching.contents = prev;
-  if (pending.contents !== undefined) {
-    var toRun = pending.contents;
-    pending.contents = undefined;
-    Belt_SetInt.forEach(toRun, (function (id) {
-            schedule(id);
-          }));
-  }
-  return r;
-}
-
-var IntSet;
-
-var IntMap;
-
-var Observer;
-
-var Id;
-
-export {
-  IntSet ,
-  IntMap ,
-  Observer ,
-  Id ,
-  observers ,
-  signalObservers ,
-  signalPeeks ,
-  currentObserverId ,
-  pending ,
-  batching ,
-  ensureSignalBucket ,
-  addDep ,
-  clearDeps ,
-  schedule ,
-  notify ,
-  untrack ,
-  batch ,
-}
-/* No side effect */