sibujs 4.14.0 → 4.15.0

package/dist/{chunk-MIRKTVH4.js → chunk-GFM5WWPU.js}

@@ -3,7 +3,7 @@ import {
   currentDisposerCapture,
   endDisposerCapture,
   reportError
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 import {
   DEV,
   devWarn
@@ -172,6 +172,201 @@ function bindOwnerScope(fn) {
   return (...args) => runWithOwnerScope(scope, () => fn(...args));
 }
 var currentStructOwner = null;
+var frozenOwners = 0;
+var ACTIVE = 0;
+var PAUSED = 1;
+var ENDED = 2;
+var NOOP = () => {
+};
+var skippedWhileHeld = /* @__PURE__ */ new Set();
+var waiters = /* @__PURE__ */ new Set();
+var heldRoots = /* @__PURE__ */ new Set();
+function ownerState(tok) {
+  let state = ACTIVE;
+  for (let t = tok; t !== null; ) {
+    const o = t.sub;
+    if (o === null) return ENDED;
+    if (o._frozen === true) state = PAUSED;
+    t = o._owner ?? null;
+  }
+  return state;
+}
+var endWatchers = /* @__PURE__ */ new Set();
+var stateWatchers = /* @__PURE__ */ new Set();
+var stateCheckQueued = false;
+function queueStateCheck() {
+  if (stateCheckQueued || stateWatchers.size === 0) return;
+  stateCheckQueued = true;
+  queueMicrotask(() => {
+    stateCheckQueued = false;
+    for (const watcher of [...stateWatchers]) {
+      if (!stateWatchers.has(watcher)) continue;
+      const state = watcher.check.state();
+      if (state === ENDED) stateWatchers.delete(watcher);
+      if (state === ENDED || state === watcher.last) continue;
+      watcher.last = state;
+      try {
+        watcher.listener(state);
+      } catch (err) {
+        reportError(err, { phase: "effect" });
+      }
+    }
+  });
+}
+var ALWAYS_ACTIVE = Object.assign(() => false, {
+  state: () => ACTIVE,
+  wait: (onActive) => {
+    onActive();
+    return NOOP;
+  },
+  onEnd: () => NOOP,
+  run: (fn) => fn(),
+  onChange: () => NOOP,
+  within: () => false
+});
+function captureFrozen() {
+  const tok = currentStructOwner;
+  if (tok === null) return ALWAYS_ACTIVE;
+  const state = () => ownerState(tok);
+  const check = Object.assign(() => state() !== ACTIVE, {
+    state,
+    wait: (onActive, onEnd) => {
+      const now = state();
+      if (now !== PAUSED) {
+        (now === ACTIVE ? onActive : onEnd)();
+        return NOOP;
+      }
+      const waiter = { check, onActive, onEnd };
+      waiters.add(waiter);
+      return () => {
+        waiters.delete(waiter);
+      };
+    },
+    onEnd: (onEnd) => {
+      if (state() === ENDED) {
+        onEnd();
+        return NOOP;
+      }
+      const watcher = { check, onActive: NOOP, onEnd };
+      endWatchers.add(watcher);
+      return () => {
+        endWatchers.delete(watcher);
+      };
+    },
+    run: (fn) => {
+      const prev = currentStructOwner;
+      currentStructOwner = tok.sub === null ? null : tok;
+      try {
+        return fn();
+      } finally {
+        currentStructOwner = prev;
+      }
+    },
+    onChange: (listener) => {
+      const last = state();
+      if (last === ENDED) return NOOP;
+      const watcher = { check, last, listener };
+      stateWatchers.add(watcher);
+      return () => {
+        stateWatchers.delete(watcher);
+      };
+    },
+    within: (owner) => {
+      const target = owner.run(() => currentStructOwner);
+      if (target === null) return false;
+      for (let t = tok; t !== null; ) {
+        if (t === target) return true;
+        const o = t.sub;
+        if (o === null) return false;
+        t = o._owner ?? null;
+      }
+      return false;
+    }
+  });
+  return check;
+}
+function holdSubtree(root) {
+  heldRoots.add(root);
+  return () => {
+    if (heldRoots.delete(root)) settleHeld();
+  };
+}
+function isHeld(sub) {
+  if (frozenOwners !== 0 && hasFrozenOwner(sub)) return true;
+  if (heldRoots.size !== 0) {
+    const node = sub._errorNode;
+    if (node != null) {
+      for (const root of heldRoots) if (root.contains(node)) return true;
+    }
+  }
+  return false;
+}
+function notifyEnded() {
+  for (const watcher of stateWatchers) if (watcher.check.state() === ENDED) stateWatchers.delete(watcher);
+  let ended = null;
+  for (const watcher of endWatchers) {
+    if (watcher.check.state() !== ENDED) continue;
+    endWatchers.delete(watcher);
+    (ended ?? (ended = [])).push(watcher);
+  }
+  if (ended === null) return;
+  for (const watcher of ended) {
+    try {
+      watcher.onEnd();
+    } catch (err) {
+      reportError(err, { phase: "cleanup" });
+    }
+  }
+}
+function dropReleasedSkipped() {
+  for (const sub of skippedWhileHeld) {
+    if (sub._disposed === true || sub.depsHead == null) skippedWhileHeld.delete(sub);
+  }
+}
+function settleHeld() {
+  for (const sub of skippedWhileHeld) {
+    if (sub._disposed === true) skippedWhileHeld.delete(sub);
+    else if (!isHeld(sub)) {
+      skippedWhileHeld.delete(sub);
+      if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+  }
+  if (frozenOwners === 0 && heldRoots.size === 0) skippedWhileHeld.clear();
+  let ready = null;
+  for (const waiter of waiters) {
+    if (waiter.check.state() === PAUSED) continue;
+    waiters.delete(waiter);
+    (ready ?? (ready = [])).push(waiter);
+  }
+  if (ready !== null) {
+    const settle = ready;
+    queueMicrotask(() => {
+      for (const waiter of settle) {
+        const state = waiter.check.state();
+        if (state === PAUSED) waiters.add(waiter);
+        else
+          try {
+            (state === ACTIVE ? waiter.onActive : waiter.onEnd)();
+          } catch (err) {
+            reportError(err, { phase: "effect" });
+          }
+      }
+    });
+  }
+  if (pendingQueue.length > 0) drainNotificationQueue();
+}
+function hasFrozenOwner(sub) {
+  for (let t = sub._owner ?? null; t !== null; ) {
+    const o = t.sub;
+    if (o === null) return false;
+    if (o._frozen === true) return true;
+    t = o._owner ?? null;
+  }
+  return false;
+}
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
@@ -279,6 +474,20 @@ function structuralBinding(commit, ownerNode) {
       } finally {
         currentStructOwner = prev;
       }
+    },
+    freeze: () => {
+      const s = sub;
+      if (s._disposed || s._frozen) return;
+      s._frozen = true;
+      frozenOwners++;
+      queueStateCheck();
+    },
+    thaw: () => {
+      if (!sub._frozen) return;
+      sub._frozen = false;
+      frozenOwners--;
+      queueStateCheck();
+      settleHeld();
     }
   };
 }
@@ -307,20 +516,34 @@ function createBinding(commit, ownerNode, structural) {
   subscriber._errorNode = ownerNode;
   subscriber._tok = null;
   subscriber._owner = null;
+  subscriber._frozen = false;
   if (structural) subscriber._tok = { sub: subscriber };
   try {
     run();
   } catch (err) {
     subscriber._disposed = true;
     subscriber._errorNode = void 0;
-    if (subscriber._tok != null) subscriber._tok.sub = null;
+    if (subscriber._tok != null) {
+      subscriber._tok.sub = null;
+      if (endWatchers.size !== 0 || stateWatchers.size !== 0) notifyEnded();
+    }
     cleanup(subscriber);
     throw err;
   }
   subscriber._dispose = () => {
     subscriber._disposed = true;
+    const wasFrozen = subscriber._frozen === true;
+    if (wasFrozen) {
+      subscriber._frozen = false;
+      frozenOwners--;
+    }
     subscriber._errorNode = void 0;
-    if (subscriber._tok != null) subscriber._tok.sub = null;
+    if (subscriber._tok != null) {
+      subscriber._tok.sub = null;
+      if (endWatchers.size !== 0 || stateWatchers.size !== 0) notifyEnded();
+      if (skippedWhileHeld.size !== 0) dropReleasedSkipped();
+      if (wasFrozen || waiters.size !== 0) settleHeld();
+    }
     cleanup(subscriber);
   };
   return subscriber;
@@ -430,6 +653,10 @@ function runPendingOwners(sub) {
   }
 }
 function runQueued(sub) {
+  if ((frozenOwners !== 0 || heldRoots.size !== 0) && isHeld(sub)) {
+    skippedWhileHeld.add(sub);
+    return;
+  }
   if (quarantined.size > 0 && quarantined.has(sub)) return;
   if (sub._hasComputedDep === true && !depsChanged(sub)) return;
   if (tickRepeat(sub)) {
@@ -577,7 +804,7 @@ function forEachSubscriber(signal, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.14.0" : "dev";
+var _runtimeVersion = true ? "4.15.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -613,6 +840,8 @@ function resolveReactiveApi() {
     runWithOwnerScope,
     bindOwnerScope,
     structuralBinding,
+    captureFrozen,
+    holdSubtree,
     version: _runtimeVersion
   };
   g[REGISTRY_KEY] = local;
@@ -640,6 +869,22 @@ var getOwnerScope2 = API.getOwnerScope ?? getOwnerScope;
 var runWithOwnerScope2 = API.runWithOwnerScope ?? runWithOwnerScope;
 var bindOwnerScope2 = API.bindOwnerScope ?? bindOwnerScope;
 var structuralBinding2 = API.structuralBinding ?? ((commit, ownerNode) => ({ stop: API.reactiveBinding(commit, ownerNode), run: (fn) => fn() }));
+var captureFrozen2 = API.captureFrozen ?? (() => Object.assign(() => false, {
+  state: () => 0,
+  wait: (onActive) => {
+    onActive();
+    return () => {
+    };
+  },
+  onEnd: () => () => {
+  },
+  run: (fn) => fn(),
+  onChange: () => () => {
+  },
+  within: () => false
+}));
+var holdSubtree2 = API.holdSubtree ?? (() => () => {
+});
 
 export {
   suspendTracking2 as suspendTracking,
@@ -661,5 +906,7 @@ export {
   getOwnerScope2 as getOwnerScope,
   runWithOwnerScope2 as runWithOwnerScope,
   bindOwnerScope2 as bindOwnerScope,
-  structuralBinding2 as structuralBinding
+  structuralBinding2 as structuralBinding,
+  captureFrozen2 as captureFrozen,
+  holdSubtree2 as holdSubtree
 };

package/dist/{chunk-52XFPGSN.js → chunk-HTPOIAAL.js}

@@ -1,6 +1,6 @@
 import {
   globalSingleton
-} from "./chunk-7ZHH77QA.js";
+} from "./chunk-BF3WBJJQ.js";
 
 // src/utils/singletonResource.ts
 function singletonResource(io) {

package/dist/{chunk-3HEX6QJQ.js → chunk-I2R5QALY.js}

@@ -1,12 +1,10 @@
-import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
 import {
   adoptThenable
 } from "./chunk-5HZXGZ6T.js";
 import {
+  globalSingleton,
   reportError
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 import {
   DEV,
   devWarn

package/dist/{chunk-4FJSAUKB.js → chunk-IUBV5WO5.js}

@@ -3,7 +3,7 @@ import {
   notifySubscribers,
   queueSignalNotification,
   recordDependency
-} from "./chunk-MIRKTVH4.js";
+} from "./chunk-GFM5WWPU.js";
 import {
   DEV
 } from "./chunk-NT3ZYB5S.js";

package/dist/{chunk-A454RAEK.js → chunk-KIDETDMU.js}

@@ -1,25 +1,23 @@
 import {
   acquireTitle
-} from "./chunk-52XFPGSN.js";
+} from "./chunk-HTPOIAAL.js";
 import {
   isUnsafeKey
 } from "./chunk-62BDYGAG.js";
-import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-AE32RGWX.js";
+} from "./chunk-LGUXYHTZ.js";
 import {
   sanitizeUrl
 } from "./chunk-B3HOT4TK.js";
 import {
   batch,
   signal
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
+  globalSingleton,
   reportError
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 
 // src/browser/media.ts
 function media(query) {

package/dist/{chunk-JTFQ7IL4.js → chunk-KPAXG5IR.js}

@@ -3,20 +3,17 @@ import {
 } from "./chunk-N5TBYXHW.js";
 import {
   domBinding
-} from "./chunk-CCKUNHVU.js";
+} from "./chunk-DAEXQJQA.js";
 import {
   bindAttribute,
   setSafeAttribute
-} from "./chunk-HQIAL7F2.js";
+} from "./chunk-XPDZ2LDR.js";
 import {
   isBlockedElement
 } from "./chunk-RVWJGWCL.js";
 import {
   derived
-} from "./chunk-N7A6FKWW.js";
-import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
+} from "./chunk-D44TAGCT.js";
 import {
   isEventHandlerAttr,
   sanitizeStylesheetText
@@ -26,20 +23,21 @@ import {
 } from "./chunk-5HZXGZ6T.js";
 import {
   signal
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
   reactiveBinding,
   track
-} from "./chunk-MIRKTVH4.js";
+} from "./chunk-GFM5WWPU.js";
 import {
   dispose,
   disposeNodeOwn,
+  globalSingleton,
   registerDisposer,
   replaceChildrenSafely,
   reportError,
   unregisterDisposer,
   withDisposerRollback
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 
 // src/ui/form.ts
 function required(message = "This field is required") {

package/dist/{chunk-AE32RGWX.js → chunk-LGUXYHTZ.js}

@@ -3,17 +3,17 @@ import {
 } from "./chunk-UYTYNCMZ.js";
 import {
   emitDevtools
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
   cleanup,
   getOwnerScope,
   retrack,
   runWithOwnerScope,
   untracked
-} from "./chunk-MIRKTVH4.js";
+} from "./chunk-GFM5WWPU.js";
 import {
   reportError
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 import {
   devAssert
 } from "./chunk-NT3ZYB5S.js";

package/dist/{chunk-Y4LUM2XS.js → chunk-LQWLPQOK.js}

@@ -1,23 +1,21 @@
-import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-AE32RGWX.js";
+} from "./chunk-LGUXYHTZ.js";
 import {
   stripHtml
 } from "./chunk-B3HOT4TK.js";
 import {
   signal
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
   forEachSubscriber,
   getSubscriberCount,
   getSubscriberDeps
-} from "./chunk-MIRKTVH4.js";
+} from "./chunk-GFM5WWPU.js";
 import {
-  dispose
-} from "./chunk-S37PZD6I.js";
+  dispose,
+  globalSingleton
+} from "./chunk-BF3WBJJQ.js";
 import {
   isDev
 } from "./chunk-NT3ZYB5S.js";

package/dist/{chunk-CNPT6NKV.js → chunk-MINLMJUY.js}

@@ -1,3 +1,6 @@
+import {
+  styleKeyToProperty
+} from "./chunk-DNCQDFJJ.js";
 import {
   requestSlot
 } from "./chunk-UYTYNCMZ.js";
@@ -635,9 +638,15 @@ var ServerAttr = class {
   get nodeValue() {
     return this._value;
   }
+  set nodeValue(v) {
+    this.value = v;
+  }
   get textContent() {
     return this._value;
   }
+  set textContent(v) {
+    this.value = v;
+  }
 };
 var ServerNamedNodeMap = class extends Array {
   static get [Symbol.species]() {
@@ -674,12 +683,6 @@ function splitDeclarations(text) {
   out.push(text.slice(start));
   return out;
 }
-var CAMEL_EXCEPTIONS = { cssFloat: "float" };
-function toKebab(prop) {
-  if (prop.startsWith("--")) return prop;
-  if (Object.hasOwn(CAMEL_EXCEPTIONS, prop)) return CAMEL_EXCEPTIONS[prop];
-  return prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`).replace(/^(webkit|moz|ms)-/, "-$1-");
-}
 var ServerStyle = class {
   constructor(el) {
     this.el = el;
@@ -774,13 +777,13 @@ function styleProxy(style) {
     get(target, key, receiver) {
       if (typeof key === "string" && !(key in target)) {
         if (/^\d+$/.test(key)) return target.item(Number(key));
-        return target.getPropertyValue(toKebab(key));
+        return target.getPropertyValue(styleKeyToProperty(key));
       }
       return Reflect.get(target, key, receiver);
     },
     set(target, key, value, receiver) {
       if (typeof key === "string" && !(key in target)) {
-        target.setProperty(toKebab(key), value == null ? "" : String(value));
+        target.setProperty(styleKeyToProperty(key), value == null ? "" : String(value));
         return true;
       }
       return Reflect.set(target, key, value, receiver);
@@ -1185,6 +1188,10 @@ var ServerInputElement = class extends ServerHTMLElement {
   get defaultChecked() {
     return this.hasAttribute("checked");
   }
+  /** Reflects to the `checked` attribute; `checked` follows it until written (dirty checkedness). */
+  set defaultChecked(v) {
+    this.toggleAttribute("checked", !!v);
+  }
   get type() {
     return (this.getAttribute("type") ?? "text").toLowerCase();
   }
@@ -1242,8 +1249,10 @@ reflectDisabled(ServerTextAreaElement.prototype);
 var ServerOptionElement = class extends ServerHTMLElement {
   constructor() {
     super(...arguments);
-    /** @internal */
+    /** Selectedness; `null` while it follows the `selected` attribute. @internal */
     this._selected = null;
+    /** Set by a `selected` write: the attribute no longer decides selectedness. @internal */
+    this._dirty = false;
   }
   get value() {
     return this.getAttribute("value") ?? this.text;
@@ -1260,18 +1269,48 @@ var ServerOptionElement = class extends ServerHTMLElement {
   get label() {
     return this.getAttribute("label") ?? this.text;
   }
+  set label(v) {
+    this.setAttribute("label", v);
+  }
   get selected() {
     return this._selected ?? this.hasAttribute("selected");
   }
   set selected(v) {
     this._selected = !!v;
+    this._dirty = true;
+    const select = singleSelectOf(this);
+    if (select && v) {
+      for (const o of select.options) if (o !== this) o._selected = false;
+    }
   }
   get defaultSelected() {
     return this.hasAttribute("selected");
   }
+  /** Reflects to the `selected` attribute; `selected` follows it unless written. */
+  set defaultSelected(v) {
+    this.toggleAttribute("selected", !!v);
+    if (this._dirty) return;
+    this._selected = null;
+    const select = singleSelectOf(this);
+    if (!select) return;
+    let last = null;
+    for (const o of select.options) if (o.selected) last = o;
+    for (const o of select.options) if (o !== last && o.selected) o._selected = false;
+  }
 };
+function singleSelectOf(option) {
+  let parent = option.parentNode;
+  if (parent instanceof ServerElement && parent.localName === "optgroup") parent = parent.parentNode;
+  return parent instanceof ServerSelectElement && !parent.hasAttribute("multiple") ? parent : null;
+}
 reflectDisabled(ServerOptionElement.prototype);
 var ServerSelectElement = class extends ServerHTMLElement {
+  get multiple() {
+    return this.hasAttribute("multiple");
+  }
+  set multiple(v) {
+    this.toggleAttribute("multiple", !!v);
+  }
   get options() {
     return this.querySelectorAll("option");
   }

package/dist/{chunk-BNXRWZZV.js → chunk-OURTGOJT.js}

@@ -2,11 +2,11 @@ import {
   acquireBase,
   acquireScrollRestorationMode,
   acquireTitle
-} from "./chunk-52XFPGSN.js";
+} from "./chunk-HTPOIAAL.js";
 import {
   div,
   span
-} from "./chunk-7ILEHTVX.js";
+} from "./chunk-4AEFGRYW.js";
 import {
   STATIC_VALUE_RESOLVER,
   planHeadElementEntry,
@@ -14,13 +14,10 @@ import {
   recordServerHead,
   serializeHeadEntry,
   serializePlannedHeadEntry
-} from "./chunk-BOYKGGVD.js";
-import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
+} from "./chunk-DRWOD7RZ.js";
 import {
   effect
-} from "./chunk-AE32RGWX.js";
+} from "./chunk-LGUXYHTZ.js";
 import {
   sanitizeUrl
 } from "./chunk-B3HOT4TK.js";
@@ -30,15 +27,16 @@ import {
 import {
   batch,
   signal
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
   bindOwnerScope
-} from "./chunk-MIRKTVH4.js";
+} from "./chunk-GFM5WWPU.js";
 import {
+  globalSingleton,
   registerDisposer,
   replaceChildrenSafely,
   reportError
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 
 // src/platform/head.ts
 function escapeScriptJsonLocal(json) {

package/dist/{chunk-F67F77IA.js → chunk-TQ24Y3IV.js}

@@ -3,11 +3,11 @@ import {
 } from "./chunk-5HZXGZ6T.js";
 import {
   signal
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
   registerDisposer,
   reportError
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 
 // src/ui/transition.ts
 function transition(element, options = {}) {