xote 6.4.0 → 7.0.0

package/src/Router.res.mjs

@@ -6,6 +6,7 @@ import * as Route$Xote from "./Route.res.mjs";
 import * as Signal$Xote from "./Signal.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Computed$Xote from "./Computed.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as RuntimeJsxProp$Xote from "./RuntimeJsxProp.res.mjs";
 
@@ -90,6 +91,26 @@ function addBasePath(pathname) {
   }
 }
 
+function parseTarget(to) {
+  let hashParts = to.split("#");
+  let beforeHash = Stdlib_Option.getOr(hashParts[0], "");
+  let value = hashParts[1];
+  let hash = value !== undefined ? "#" + value : "";
+  let searchParts = beforeHash.split("?");
+  let pathname = Stdlib_Option.getOr(searchParts[0], "/");
+  let value$1 = searchParts[1];
+  let search = value$1 !== undefined ? "?" + value$1 : "";
+  return {
+    pathname: pathname,
+    search: search,
+    hash: hash
+  };
+}
+
+function targetToHref(target) {
+  return addBasePath(target.pathname) + target.search + target.hash;
+}
+
 function getScrollPosition() {
   let x = (window.scrollX || window.pageXOffset || 0);
   let y = (window.scrollY || window.pageYOffset || 0);
@@ -103,6 +124,32 @@ function scrollTo(x, y) {
   ((window.scrollTo(x, y)));
 }
 
+function queueMicrotask(callback) {
+  ((globalThis.queueMicrotask(callback)));
+}
+
+function scrollHashIntoView(hash) {
+  (((() => {
+      if (!hash) {
+        return;
+      }
+
+      const id = decodeURIComponent(hash.startsWith("#") ? hash.slice(1) : hash);
+      const target = document.getElementById(id);
+      if (target && typeof target.scrollIntoView === "function") {
+        target.scrollIntoView();
+      }
+    })()));
+}
+
+function scrollAfterNavigation(hash) {
+  if (hash === "") {
+    return scrollTo(0.0, 0.0);
+  } else {
+    return queueMicrotask(() => scrollHashIntoView(hash));
+  }
+}
+
 function makeHistoryState(scrollX, scrollY) {
   return (({ scrollX: scrollX, scrollY: scrollY }));
 }
@@ -193,7 +240,7 @@ function push(pathname, searchOpt, hashOpt, param) {
   let url = browserPathname + search + hash;
   window.history.pushState(emptyHistoryState(), "", url);
   Signal$Xote.set(getGlobalState().location, newLocation);
-  scrollTo(0.0, 0.0);
+  scrollAfterNavigation(hash);
 }
 
 function replace(pathname, searchOpt, hashOpt, param) {
@@ -209,7 +256,7 @@ function replace(pathname, searchOpt, hashOpt, param) {
   let url = browserPathname + search + hash;
   window.history.replaceState(emptyHistoryState(), "", url);
   Signal$Xote.set(getGlobalState().location, newLocation);
-  scrollTo(0.0, 0.0);
+  scrollAfterNavigation(hash);
 }
 
 function route(pattern, render) {
@@ -249,11 +296,12 @@ function link(to, attrsOpt, childrenOpt, param) {
   let attrs = attrsOpt !== undefined ? attrsOpt : [];
   let children = childrenOpt !== undefined ? childrenOpt : [];
   warnIfNotInitialized("Router.link()");
+  let target = parseTarget(to);
   let handleClick = _evt => {
     ((_evt.preventDefault()));
-    push(to, undefined, undefined, undefined);
+    push(target.pathname, target.search, target.hash, undefined);
   };
-  return Html$Xote.a(attrs.concat([View$Xote.attr("href", addBasePath(to))]), [[
+  return Html$Xote.a(attrs.concat([View$Xote.attr("href", targetToHref(target))]), [[
       "click",
       handleClick
     ]], children, undefined);
@@ -299,15 +347,16 @@ function getChildren(props) {
 
 function make(props) {
   warnIfNotInitialized("Router.Link");
+  let target = parseTarget(props.to);
   let handleClick = evt => {
     ((evt.preventDefault()));
-    push(props.to, undefined, undefined, undefined);
+    push(target.pathname, target.search, target.hash, undefined);
     let handler = props.onClick;
     if (handler !== undefined) {
       return handler(evt);
     }
   };
-  return Html$Xote.a(propsToAttrs(props).concat([View$Xote.attr("href", addBasePath(props.to))]), [[
+  return Html$Xote.a(propsToAttrs(props).concat([View$Xote.attr("href", targetToHref(target))]), [[
       "click",
       handleClick
     ]], getChildren(props), undefined);
@@ -349,8 +398,13 @@ export {
   normalizeBasePath,
   stripBasePath,
   addBasePath,
+  parseTarget,
+  targetToHref,
   getScrollPosition,
   scrollTo,
+  queueMicrotask,
+  scrollHashIntoView,
+  scrollAfterNavigation,
   makeHistoryState,
   emptyHistoryState,
   getScrollFromState,

package/src/RuntimeDom.res

@@ -1,3 +1,5 @@
+module Core = RescriptCore
+
 let svgNamespace = "http://www.w3.org/2000/svg"
 
 let svgTags = [
@@ -61,6 +63,11 @@ external getElementById: string => Nullable.t<Dom.element> = "getElementById"
 @get external getNextSibling: Dom.element => Nullable.t<Dom.element> = "nextSibling"
 @get external getFirstChild: Dom.element => Nullable.t<Dom.element> = "firstChild"
 @get external getParentNode: Dom.element => Nullable.t<Dom.element> = "parentNode"
+@get external childNodes: Dom.element => Array.arrayLike<Dom.element> = "childNodes"
+
+let childNodesToArray = (el: Dom.element): array<Dom.element> => {
+  el->childNodes->Core.Array.fromArrayLike
+}
 
 @send
 external addEventListener: (Dom.element, string, Dom.event => unit) => unit = "addEventListener"

package/src/RuntimeDom.res.mjs

@@ -55,6 +55,10 @@ function isSvgTag(tag) {
   return Stdlib_Option.isSome(d[tag]);
 }
 
+function childNodesToArray(el) {
+  return Array.from(el.childNodes);
+}
+
 function createElementForTag(tag) {
   if (Stdlib_Option.isSome(d[tag])) {
     return document.createElementNS(svgNamespace, tag);
@@ -88,13 +92,17 @@ function setAttrOrProp(el, key, value) {
   }
 }
 
+let Core;
+
 let svgTagSet = d;
 
 export {
+  Core,
   svgNamespace,
   svgTags,
   svgTagSet,
   isSvgTag,
+  childNodesToArray,
   createElementForTag,
   setAttrOrProp,
 }

package/src/RuntimeJsxProp.res

@@ -1,7 +1,4 @@
-let isReactiveProp = (value: 'a): bool => {
-  ignore(value)
-  %raw(`value && typeof value === 'object' && ('TAG' in value) && (value.TAG === 'Static' || value.TAG === 'Reactive')`)
-}
+let isReactiveProp = RuntimeValue.isReactiveProp
 
 let toStringAttr = (key: string, value: 'a): (string, View.attrValue) => {
   if isReactiveProp(value) {
@@ -10,10 +7,10 @@ let toStringAttr = (key: string, value: 'a): (string, View.attrValue) => {
     | Static(value) => View.attr(key, value)
     | Reactive(signal) => View.signalAttr(key, signal)
     }
-  } else if typeof(value) == #function {
+  } else if value->RuntimeValue.isFunction {
     let compute: unit => string = Obj.magic(value)
     View.computedAttr(key, compute)
-  } else if typeof(value) == #object {
+  } else if value->RuntimeValue.isObject {
     let signal: Signal.t<string> = Obj.magic(value)
     View.signalAttr(key, signal)
   } else {
@@ -32,10 +29,10 @@ let toBoolAttr = (key: string, value: 'a): (string, View.attrValue) => {
         View.signalAttr(key, stringSignal)
       }
     }
-  } else if typeof(value) == #function {
+  } else if value->RuntimeValue.isFunction {
     let compute: unit => bool = Obj.magic(value)
     View.computedAttr(key, () => RuntimeAttr.boolToString(compute()))
-  } else if typeof(value) == #object {
+  } else if value->RuntimeValue.isObject {
     let signal: Signal.t<bool> = Obj.magic(value)
     let stringSignal = Computed.make(() => RuntimeAttr.boolToString(Signal.get(signal)))
     View.signalAttr(key, stringSignal)

package/src/RuntimeJsxProp.res.mjs

@@ -4,21 +4,18 @@ import * as View$Xote from "./View.res.mjs";
 import * as Signal$Xote from "./Signal.res.mjs";
 import * as Computed$Xote from "./Computed.res.mjs";
 import * as RuntimeAttr$Xote from "./RuntimeAttr.res.mjs";
-
-function isReactiveProp(value) {
-  return (value && typeof value === 'object' && ('TAG' in value) && (value.TAG === 'Static' || value.TAG === 'Reactive'));
-}
+import * as RuntimeValue$Xote from "./RuntimeValue.res.mjs";
 
 function toStringAttr(key, value) {
-  if (isReactiveProp(value)) {
+  if (RuntimeValue$Xote.isReactiveProp(value)) {
     if (value.TAG === "Reactive") {
       return View$Xote.signalAttr(key, value._0);
     } else {
       return View$Xote.attr(key, value._0);
     }
-  } else if (typeof value === "function") {
+  } else if (RuntimeValue$Xote.isFunction(value)) {
     return View$Xote.computedAttr(key, value);
-  } else if (typeof value === "object") {
+  } else if (RuntimeValue$Xote.isObject(value)) {
     return View$Xote.signalAttr(key, value);
   } else {
     return View$Xote.attr(key, value);
@@ -26,7 +23,7 @@ function toStringAttr(key, value) {
 }
 
 function toBoolAttr(key, value) {
-  if (isReactiveProp(value)) {
+  if (RuntimeValue$Xote.isReactiveProp(value)) {
     if (value.TAG !== "Reactive") {
       return View$Xote.attr(key, RuntimeAttr$Xote.boolToString(value._0));
     }
@@ -34,16 +31,18 @@ function toBoolAttr(key, value) {
     let stringSignal = Computed$Xote.make(() => RuntimeAttr$Xote.boolToString(Signal$Xote.get(signal)), undefined, undefined);
     return View$Xote.signalAttr(key, stringSignal);
   }
-  if (typeof value === "function") {
+  if (RuntimeValue$Xote.isFunction(value)) {
     return View$Xote.computedAttr(key, () => RuntimeAttr$Xote.boolToString(value()));
   }
-  if (typeof value !== "object") {
+  if (!RuntimeValue$Xote.isObject(value)) {
     return View$Xote.attr(key, RuntimeAttr$Xote.boolToString(value));
   }
   let stringSignal$1 = Computed$Xote.make(() => RuntimeAttr$Xote.boolToString(Signal$Xote.get(value)), undefined, undefined);
   return View$Xote.signalAttr(key, stringSignal$1);
 }
 
+let isReactiveProp = RuntimeValue$Xote.isReactiveProp;
+
 export {
   isReactiveProp,
   toStringAttr,

package/src/RuntimeValue.res

@@ -0,0 +1,35 @@
+module Core = RescriptCore
+
+let objectHasTag = (obj: {..}, tag: string): bool =>
+  switch obj->Core.Object.get("TAG") {
+  | Some(value) => value == tag
+  | None => false
+  }
+
+let isReactiveProp = (value: 'value): bool => {
+  switch value->Core.Type.Classify.classify {
+  | Object(obj) => {
+      let obj: {..} = Obj.magic(obj)
+      obj->Core.Object.hasOwnProperty("TAG") &&
+        (obj->objectHasTag("Static") || obj->objectHasTag("Reactive"))
+    }
+  | _ => false
+  }
+}
+
+let isFunction = (value: 'value): bool =>
+  switch value->Core.Type.Classify.classify {
+  | Function(_) => true
+  | _ => false
+  }
+
+let isObject = (value: 'value): bool =>
+  switch value->Core.Type.Classify.classify {
+  | Object(_) => true
+  | _ => false
+  }
+
+let getField = (props: 'props, key: string): option<'value> => {
+  let props: {..} = Obj.magic(props)
+  props->Core.Object.get(key)
+}

package/src/RuntimeValue.res.mjs

@@ -0,0 +1,67 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core__Type from "@rescript/core/src/Core__Type.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function objectHasTag(obj, tag) {
+  let value = obj["TAG"];
+  if (value !== undefined) {
+    return Primitive_option.valFromOption(value) === tag;
+  } else {
+    return false;
+  }
+}
+
+function isReactiveProp(value) {
+  let obj = Core__Type.Classify.classify(value);
+  if (typeof obj !== "object") {
+    return false;
+  }
+  if (obj.TAG !== "Object") {
+    return false;
+  }
+  let obj$1 = obj._0;
+  if (Object.prototype.hasOwnProperty.call(obj$1, "TAG")) {
+    if (objectHasTag(obj$1, "Static")) {
+      return true;
+    } else {
+      return objectHasTag(obj$1, "Reactive");
+    }
+  } else {
+    return false;
+  }
+}
+
+function isFunction(value) {
+  let match = Core__Type.Classify.classify(value);
+  if (typeof match !== "object") {
+    return false;
+  } else {
+    return match.TAG === "Function";
+  }
+}
+
+function isObject(value) {
+  let match = Core__Type.Classify.classify(value);
+  if (typeof match !== "object") {
+    return false;
+  } else {
+    return match.TAG === "Object";
+  }
+}
+
+function getField(props, key) {
+  return props[key];
+}
+
+let Core;
+
+export {
+  Core,
+  objectHasTag,
+  isReactiveProp,
+  isFunction,
+  isObject,
+  getField,
+}
+/* No side effect */

package/src/SSRState.res

@@ -239,11 +239,8 @@ let sync = (id: string, signal: Signal.t<'a>, codec: Codec.t<'a>): unit => {
 }
 
 /* Create and sync a signal in one call */
-let make = (id: string, initial: 'a, codec: Codec.t<'a>): Signal.t<'a> => {
+let signal = (id: string, initial: 'a, codec: Codec.t<'a>): Signal.t<'a> => {
   let signal = Signal.make(initial)
   sync(id, signal, codec)
   signal
 }
-
-let signal = make
-let syncSignal = sync

package/src/SSRState.res.mjs

@@ -265,16 +265,12 @@ function sync(id, signal, codec) {
   SSRContext$Xote.match(() => register(id, signal, codec), () => restore(id, signal, codec));
 }
 
-function make$1(id, initial, codec) {
-  let signal = Signal$Xote.make(initial, undefined, undefined);
-  sync(id, signal, codec);
-  return signal;
+function signal(id, initial, codec) {
+  let signal$1 = Signal$Xote.make(initial, undefined, undefined);
+  sync(id, signal$1, codec);
+  return signal$1;
 }
 
-let signal = make$1;
-
-let syncSignal = sync;
-
 export {
   Codec,
   registry,
@@ -285,8 +281,6 @@ export {
   getClientState,
   restore,
   sync,
-  make$1 as make,
   signal,
-  syncSignal,
 }
 /* SSRContext-Xote Not a pure module */