sibujs 1.4.0 → 2.0.0

package/dist/{chunk-3ARAQO7B.js → chunk-52YJLLRO.js}

@@ -1,6 +1,6 @@
 import {
   signal
-} from "./chunk-V2XTI523.js";
+} from "./chunk-CC65Y57T.js";
 
 // src/ui/transition.ts
 function transition(element, options = {}) {
@@ -16,20 +16,29 @@ function transition(element, options = {}) {
     onLeaveDone
   } = options;
   const transitionValue = `${property} ${duration}ms ${easing} ${delay}ms`;
+  let activeTimer = null;
+  function cancelPending() {
+    if (activeTimer !== null) {
+      clearTimeout(activeTimer);
+      activeTimer = null;
+    }
+  }
   function enter() {
     return new Promise((resolve) => {
+      cancelPending();
       element.style.transition = transitionValue;
       if (enterClass) element.classList.add(enterClass);
       if (leaveClass) element.classList.remove(leaveClass);
       void element.offsetHeight;
       if (activeClass) element.classList.add(activeClass);
       const done = () => {
+        activeTimer = null;
         if (enterClass) element.classList.remove(enterClass);
         onEnterDone?.();
         resolve();
       };
       if (duration > 0) {
-        setTimeout(done, duration + delay);
+        activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
       }
@@ -37,17 +46,19 @@ function transition(element, options = {}) {
   }
   function leave() {
     return new Promise((resolve) => {
+      cancelPending();
       element.style.transition = transitionValue;
       if (activeClass) element.classList.remove(activeClass);
       if (leaveClass) element.classList.add(leaveClass);
       if (enterClass) element.classList.remove(enterClass);
       const done = () => {
+        activeTimer = null;
         if (leaveClass) element.classList.remove(leaveClass);
         onLeaveDone?.();
         resolve();
       };
       if (duration > 0) {
-        setTimeout(done, duration + delay);
+        activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
       }
@@ -334,15 +345,24 @@ function springSignal(initial, options) {
   let velocity = 0;
   let target = initial;
   let rafId = null;
-  function tick() {
+  let lastTime = 0;
+  const REF_DT_MS = 1e3 / 60;
+  const MAX_STEP_RATIO = 4;
+  function tick(now) {
+    if (lastTime === 0) lastTime = now;
+    const rawDt = now - lastTime;
+    lastTime = now;
+    const dt = Number.isFinite(rawDt) && rawDt > 0 ? rawDt : REF_DT_MS;
+    const ratio = Math.min(MAX_STEP_RATIO, Math.max(0.1, dt / REF_DT_MS));
     const force = -stiffness * (current - target);
     const dampingForce = -damping * velocity;
-    velocity += force + dampingForce;
-    current += velocity;
+    velocity += (force + dampingForce) * ratio;
+    current += velocity * ratio;
     if (Math.abs(current - target) < precision && Math.abs(velocity) < precision) {
       current = target;
       velocity = 0;
       rafId = null;
+      lastTime = 0;
       setValue(current);
       return;
     }
@@ -358,10 +378,12 @@ function springSignal(initial, options) {
         cancelAnimationFrame(rafId);
         rafId = null;
       }
+      lastTime = 0;
       setValue(current);
       return;
     }
     if (rafId === null) {
+      lastTime = 0;
       rafId = requestAnimationFrame(tick);
     }
   }
@@ -370,6 +392,7 @@ function springSignal(initial, options) {
       cancelAnimationFrame(rafId);
       rafId = null;
     }
+    lastTime = 0;
   }
   return [value, set, dispose];
 }

package/dist/chunk-54EDRCEF.js

@@ -0,0 +1,93 @@
+import {
+  recordDependency,
+  retrack,
+  track,
+  trackingSuspended
+} from "./chunk-VLPPXTYG.js";
+import {
+  devAssert
+} from "./chunk-LMLD24FC.js";
+
+// src/core/signals/derived.ts
+function derived(getter, options) {
+  devAssert(typeof getter === "function", "derived: argument must be a getter function.");
+  const debugName = options?.name;
+  const equals = options?.equals;
+  const cs = {};
+  cs._d = false;
+  cs._g = getter;
+  const markDirty = () => {
+    if (cs._d) return;
+    cs._d = true;
+  };
+  markDirty._c = 1;
+  markDirty._sig = cs;
+  track(() => {
+    let threw = true;
+    try {
+      cs._v = getter();
+      cs._d = false;
+      threw = false;
+    } finally {
+      if (threw) cs._d = true;
+    }
+  }, markDirty);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  let evaluating = false;
+  function computedGetter() {
+    if (evaluating) {
+      throw new Error(
+        `[SibuJS] Circular dependency detected in derived${debugName ? ` "${debugName}"` : ""}. A derived signal cannot read itself (directly or through a chain).`
+      );
+    }
+    if (trackingSuspended) {
+      if (cs._d) {
+        evaluating = true;
+        let threw = true;
+        try {
+          retrack(() => {
+            cs._v = getter();
+            cs._d = false;
+            threw = false;
+          }, markDirty);
+        } finally {
+          evaluating = false;
+          if (threw) cs._d = true;
+        }
+      }
+      return cs._v;
+    }
+    recordDependency(cs);
+    if (cs._d) {
+      const oldValue = cs._v;
+      evaluating = true;
+      let threw = true;
+      try {
+        retrack(() => {
+          const next = getter();
+          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
+          cs._d = false;
+          threw = false;
+        }, markDirty);
+      } finally {
+        evaluating = false;
+        if (threw) cs._d = true;
+      }
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (debugName) {
+    computedGetter.__name = debugName;
+    cs.__name = debugName;
+  }
+  computedGetter.__signal = cs;
+  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  return computedGetter;
+}
+
+export {
+  derived
+};