sibujs 3.4.0 → 4.0.0

package/dist/chunk-VPP2FONR.js

@@ -0,0 +1,142 @@
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
+    // The bare `__SIBU_DEV__` is a bundler define that only exists in
+    // production builds; under the test runner it is always undefined, so
+    // this branch is unreachable here.
+    /* v8 ignore next 2 */
+    typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
+  );
+}
+var _isDev = isDev();
+function devAssert(condition, message) {
+  if (_isDev && !condition) {
+    throw new Error(`[SibuJS] ${message}`);
+  }
+}
+function devWarn(message) {
+  if (_isDev) {
+    console.warn(`[SibuJS] ${message}`);
+  }
+}
+
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g = globalThis;
+  const existing = g[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g[ERROR_STATE_KEY] = created;
+  return created;
+}
+function setRuntimeErrorHandler(handler) {
+  const s = state();
+  const prev = s.handler;
+  s.handler = handler;
+  return prev;
+}
+function getRuntimeErrorHandler() {
+  return state().handler;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
+}
+var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+var PROPAGATE_EVENT = "sibu:error-propagate";
+function claimedByBoundary(error, context) {
+  const raw = context.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self = node;
+  return typeof self.dispatchEvent === "function" ? self : null;
+}
+function defaultReport(error, context) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
+}
+function reportError(error, context) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context)) return;
+    const s = state();
+    const handler = s.handler;
+    if (handler && s.handlerDepth === 0) {
+      s.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s.handlerDepth--;
+      }
+    }
+    defaultReport(err, context);
+  });
+}
+
+export {
+  __require,
+  __export,
+  isDev,
+  devAssert,
+  devWarn,
+  setRuntimeErrorHandler,
+  getRuntimeErrorHandler,
+  normalizeError,
+  reportError
+};

package/dist/{chunk-KZBEVFXZ.js → chunk-W55YHPEP.js}

@@ -3,10 +3,10 @@ import {
   notifySubscribers,
   queueSignalNotification,
   recordDependency
-} from "./chunk-OOUQUCNN.js";
+} from "./chunk-ACBT6UZS.js";
 import {
   isDev
-} from "./chunk-COY6PUD2.js";
+} from "./chunk-VPP2FONR.js";
 
 // src/reactivity/batch.ts
 var batchDepth = 0;
@@ -69,7 +69,9 @@ function signal(initial, options) {
     subsHead: null,
     subsTail: null,
     __activeNode: null,
-    __name: void 0
+    __name: void 0,
+    _d: false,
+    _validate: void 0
   };
   const debugName = _isDev ? options?.name : void 0;
   const equalsFn = options?.equals;

package/dist/{chunk-FKQG7FTY.js → chunk-WN6WDFCB.js}

@@ -3,17 +3,17 @@ import {
 } from "./chunk-WWV3SJ3L.js";
 import {
   tagFactory
-} from "./chunk-JNGGM2XE.js";
+} from "./chunk-DQVUBVNX.js";
 import {
   derived
-} from "./chunk-ITWCTZYH.js";
+} from "./chunk-Z2CE42DB.js";
 import {
   effect
-} from "./chunk-BUKYCWHX.js";
+} from "./chunk-PBQEW5VW.js";
 import {
   batch,
   signal
-} from "./chunk-KZBEVFXZ.js";
+} from "./chunk-W55YHPEP.js";
 
 // src/ecosystem/adapters/mobx.ts
 function mobXAdapter(options) {

package/dist/{chunk-CEBWDD63.js → chunk-WOOMUJFT.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-H3SRKIYX.js";
 import {
   derived
-} from "./chunk-ITWCTZYH.js";
+} from "./chunk-Z2CE42DB.js";
 import {
   effect
-} from "./chunk-BUKYCWHX.js";
+} from "./chunk-PBQEW5VW.js";
 import {
   batch,
   signal
-} from "./chunk-KZBEVFXZ.js";
+} from "./chunk-W55YHPEP.js";
 
 // src/patterns/machine.ts
 function machine(config) {
@@ -177,116 +177,258 @@ function optimistic(initialValue) {
       }
     } finally {
       inflightCount--;
-      if (inflightCount === 0) setPending(false);
+      if (inflightCount <= 0) {
+        inflightCount = 0;
+        setPending(false);
+      }
     }
   }
   return { value, pending, update };
 }
 function optimisticList(initialValue) {
-  const [items, setItems] = signal([...initialValue]);
-  const [pending, setPending] = signal(false);
-  let inflightCount = 0;
-  let version = 0;
-  let tempIdCounter = 0;
-  const itemIds = /* @__PURE__ */ new WeakMap();
-  const idToItem = /* @__PURE__ */ new Map();
-  function tagItem(item) {
-    const id = ++tempIdCounter;
-    if (item !== null && typeof item === "object") {
-      itemIds.set(item, id);
+  let nextRowId = 0;
+  let nextKey = 0;
+  let nextOpId = 0;
+  const records = /* @__PURE__ */ new Map();
+  let order = [];
+  for (const value of initialValue) {
+    const row = { id: nextRowId++, key: nextKey++, base: value, claims: [], visible: true, refs: 0 };
+    records.set(row.id, row);
+    order.push(row.id);
+  }
+  function effectiveValue(row) {
+    const claims = row.claims;
+    return claims.length > 0 ? claims[claims.length - 1].value : row.base;
+  }
+  function valueBelow(row, opId) {
+    const claims = row.claims;
+    for (let i = claims.length - 1; i >= 0; i--) {
+      if (claims[i].opId < opId) return claims[i].value;
+    }
+    return row.base;
+  }
+  function stake(row, opId, value) {
+    const claim = { opId, value, settled: false };
+    const claims = row.claims;
+    let at = claims.length;
+    while (at > 0 && claims[at - 1].opId > opId) at--;
+    claims.splice(at, 0, claim);
+    return claim;
+  }
+  function dropClaim(row, claim) {
+    const at = row.claims.indexOf(claim);
+    if (at !== -1) row.claims.splice(at, 1);
+  }
+  function collapse(row) {
+    const claims = row.claims;
+    let i = 0;
+    while (i < claims.length && claims[i].settled) {
+      row.base = claims[i].value;
+      i++;
     }
-    idToItem.set(id, item);
-    return id;
-  }
-  function findIndexById(list, id) {
-    for (let i = 0; i < list.length; i++) {
-      const it = list[i];
-      if (it !== null && typeof it === "object" && itemIds.get(it) === id) {
-        return i;
+    if (i > 0) claims.splice(0, i);
+  }
+  const [items, setItems] = signal(order.map((id) => effectiveValue(records.get(id))));
+  const [pending, setPending] = signal(false);
+  let inflight = 0;
+  const retiredRowIds = /* @__PURE__ */ new Set();
+  function project() {
+    const out = new Array(order.length);
+    for (let i = 0; i < order.length; i++) out[i] = effectiveValue(records.get(order[i]));
+    return out;
+  }
+  function commit(mutate) {
+    batch(() => {
+      let visibleChanged = false;
+      try {
+        visibleChanged = mutate();
+      } finally {
+        setPending(inflight > 0);
+        if (visibleChanged) setItems(project());
       }
-      if (Object.is(it, idToItem.get(id))) return i;
+    });
+  }
+  function hide(id) {
+    const row = records.get(id);
+    if (!row || !row.visible) return false;
+    row.visible = false;
+    order = order.filter((x) => x !== id);
+    return true;
+  }
+  function restore(ids) {
+    const restorable = [];
+    for (const id of ids) {
+      const row = records.get(id);
+      if (!row || row.visible || retiredRowIds.has(id)) continue;
+      restorable.push(id);
+    }
+    if (restorable.length === 0) return false;
+    const merged = new Array(order.length + restorable.length);
+    let i = 0;
+    let j = 0;
+    let w = 0;
+    while (i < order.length && j < restorable.length) {
+      const a = records.get(order[i]).key;
+      const b = records.get(restorable[j]).key;
+      merged[w++] = a <= b ? order[i++] : restorable[j++];
     }
-    return -1;
+    while (i < order.length) merged[w++] = order[i++];
+    while (j < restorable.length) merged[w++] = restorable[j++];
+    for (const id of restorable) records.get(id).visible = true;
+    order = merged;
+    return true;
   }
-  function begin() {
-    const v = ++version;
-    inflightCount++;
-    setPending(true);
-    return v;
+  function retain(ids) {
+    for (const id of ids) {
+      const row = records.get(id);
+      if (row) row.refs++;
+    }
   }
-  function end(myVersion, revertFn) {
-    if (revertFn && version === myVersion) {
-      revertFn();
+  function release(ids) {
+    for (const id of ids) {
+      const row = records.get(id);
+      if (!row) continue;
+      row.refs--;
+      if (row.refs <= 0 && !row.visible) {
+        records.delete(id);
+        retiredRowIds.delete(id);
+      }
+    }
+  }
+  function settle(heldIds) {
+    release(heldIds);
+    inflight--;
+    if (inflight <= 0) {
+      inflight = 0;
+      retiredRowIds.clear();
+      if (records.size !== order.length) {
+        for (const [id, row] of records) {
+          if (!row.visible) records.delete(id);
+        }
+      }
     }
-    inflightCount--;
-    if (inflightCount === 0) setPending(false);
   }
   async function add(item, asyncAction) {
-    const prev = items();
-    const id = tagItem(item);
-    setItems([...prev, item]);
-    const myVersion = begin();
+    const opId = ++nextOpId;
+    const row = { id: nextRowId++, key: nextKey++, base: item, claims: [], visible: false, refs: 1 };
+    const claim = stake(row, opId, item);
+    commit(() => {
+      records.set(row.id, row);
+      row.visible = true;
+      order = [...order, row.id];
+      inflight++;
+      return true;
+    });
+    let result;
+    let failed = false;
     try {
-      const result = await asyncAction();
-      setItems((current) => {
-        const idx = findIndexById(current, id);
-        if (idx >= 0) {
-          const next = [...current];
-          next[idx] = result;
-          return next;
-        }
-        return [...current, result];
-      });
-      idToItem.delete(id);
-      end(myVersion);
+      result = await asyncAction();
     } catch {
-      idToItem.delete(id);
-      end(myVersion, () => setItems(prev));
+      failed = true;
     }
+    commit(() => {
+      try {
+        if (failed) {
+          retiredRowIds.add(row.id);
+          dropClaim(row, claim);
+          return hide(row.id);
+        }
+        const before = effectiveValue(row);
+        claim.value = result;
+        claim.settled = true;
+        collapse(row);
+        return row.visible && !Object.is(before, effectiveValue(row));
+      } finally {
+        settle([row.id]);
+      }
+    });
   }
   async function remove(predicate, asyncAction) {
-    const prev = items();
-    setItems(prev.filter((item) => !predicate(item)));
-    const myVersion = begin();
+    const opId = ++nextOpId;
+    const matchedIds = [];
+    for (const id of order) {
+      if (predicate(valueBelow(records.get(id), opId))) matchedIds.push(id);
+    }
+    commit(() => {
+      retain(matchedIds);
+      inflight++;
+      if (matchedIds.length === 0) return false;
+      const removing = new Set(matchedIds);
+      for (const id of matchedIds) {
+        const row = records.get(id);
+        if (row) row.visible = false;
+      }
+      order = order.filter((id) => !removing.has(id));
+      return true;
+    });
+    let failed = false;
     try {
       await asyncAction();
-      end(myVersion);
     } catch {
-      end(myVersion, () => setItems(prev));
+      failed = true;
     }
+    commit(() => {
+      try {
+        if (!failed) {
+          for (const id of matchedIds) retiredRowIds.add(id);
+          return false;
+        }
+        return restore(matchedIds);
+      } finally {
+        settle(matchedIds);
+      }
+    });
   }
   async function updateItem(predicate, patch, asyncAction) {
-    const prev = items();
-    const patchedIds = [];
-    setItems(
-      prev.map((item) => {
-        if (predicate(item)) {
-          const patched = { ...item, ...patch };
-          const id = tagItem(patched);
-          patchedIds.push(id);
-          return patched;
-        }
-        return item;
-      })
-    );
-    const myVersion = begin();
+    const opId = ++nextOpId;
+    const prepared = [];
+    for (const id of order) {
+      const row = records.get(id);
+      const seen = valueBelow(row, opId);
+      if (!predicate(seen)) continue;
+      prepared.push({ row, nextValue: { ...seen, ...patch } });
+    }
+    const preparedIds = prepared.map((p) => p.row.id);
+    const claims = [];
+    commit(() => {
+      retain(preparedIds);
+      inflight++;
+      let visibleChanged = false;
+      for (const p of prepared) {
+        const before = effectiveValue(p.row);
+        claims.push(stake(p.row, opId, p.nextValue));
+        if (p.row.visible && !Object.is(before, effectiveValue(p.row))) visibleChanged = true;
+      }
+      return visibleChanged;
+    });
+    let result;
+    let failed = false;
     try {
-      const result = await asyncAction();
-      setItems(
-        (current) => current.map((item) => {
-          if (item !== null && typeof item === "object") {
-            const existingId = itemIds.get(item);
-            if (existingId !== void 0 && patchedIds.includes(existingId)) return result;
-          }
-          return item;
-        })
-      );
-      for (const id of patchedIds) idToItem.delete(id);
-      end(myVersion);
+      result = await asyncAction();
     } catch {
-      for (const id of patchedIds) idToItem.delete(id);
-      end(myVersion, () => setItems(prev));
+      failed = true;
     }
+    commit(() => {
+      try {
+        let visibleChanged = false;
+        for (let i = 0; i < claims.length; i++) {
+          const row = prepared[i].row;
+          const claim = claims[i];
+          const before = effectiveValue(row);
+          if (failed) {
+            dropClaim(row, claim);
+          } else {
+            claim.value = result;
+            claim.settled = true;
+          }
+          collapse(row);
+          if (row.visible && !Object.is(before, effectiveValue(row))) visibleChanged = true;
+        }
+        return visibleChanged;
+      } finally {
+        settle(preparedIds);
+      }
+    });
   }
   return {
     items,

package/dist/{chunk-ITWCTZYH.js → chunk-Z2CE42DB.js}

@@ -3,10 +3,10 @@ import {
   recordDependency,
   retrack,
   track
-} from "./chunk-OOUQUCNN.js";
+} from "./chunk-ACBT6UZS.js";
 import {
   devAssert
-} from "./chunk-COY6PUD2.js";
+} from "./chunk-VPP2FONR.js";
 
 // src/core/signals/derived.ts
 function derived(getter, options) {
@@ -43,6 +43,21 @@ function derived(getter, options) {
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   let evaluating = false;
+  const validate = () => {
+    if (!cs._d) return;
+    const oldValue = cs._v;
+    evaluating = true;
+    try {
+      retrack(recompute, markDirty);
+      if (!Object.is(oldValue, cs._v)) cs.__v++;
+    } finally {
+      evaluating = false;
+    }
+    if (hook && !Object.is(oldValue, cs._v)) {
+      hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+    }
+  };
+  cs._validate = validate;
   function computedGetter() {
     if (evaluating) {
       throw new Error(
@@ -50,32 +65,11 @@ function derived(getter, options) {
       );
     }
     if (isTrackingSuspended()) {
-      if (cs._d) {
-        const prev = cs._v;
-        evaluating = true;
-        try {
-          retrack(recompute, markDirty);
-          if (!Object.is(prev, cs._v)) cs.__v++;
-        } finally {
-          evaluating = false;
-        }
-      }
+      if (cs._d) validate();
       return cs._v;
     }
+    if (cs._d) validate();
     recordDependency(cs);
-    if (cs._d) {
-      const oldValue = cs._v;
-      evaluating = true;
-      try {
-        retrack(recompute, markDirty);
-        if (!Object.is(oldValue, cs._v)) cs.__v++;
-      } finally {
-        evaluating = false;
-      }
-      if (hook && oldValue !== cs._v) {
-        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
-      }
-    }
     return cs._v;
   }
   if (debugName) {

package/dist/{contracts-ey_Qh8ef.d.cts → contracts-Hg6ITAEF.d.cts}

@@ -32,7 +32,7 @@ declare function withWrapper<P>(WrappedComponent: Component<P>, wrapper: (compon
  * Button("Click"); // type="button", disabled=false automatically
  * ```
  */
-declare function withDefaults<P extends Record<string, unknown>>(component: Component<P>, defaults: Partial<P>): Component<Partial<P>>;
+declare function withDefaults<P extends object>(component: Component<P>, defaults: Partial<P>): Component<Partial<P>>;
 /**
  * Composes multiple HOC wrappers into a single wrapper.
  * Applied from right to left (like function composition).
@@ -117,7 +117,7 @@ type WithNodes<Props> = Props & {
  * // Usage: Button({ label: 'Click me' }) — TypeScript infers props
  * ```
  */
-declare function defineComponent<Props extends Record<string, unknown>>(config: {
+declare function defineComponent<Props extends object>(config: {
     defaults?: Partial<Props>;
     setup: (props: Props) => HTMLElement;
 }): (props: Props) => HTMLElement;
@@ -148,7 +148,7 @@ declare function defineComponent<Props extends Record<string, unknown>>(config:
  * // Usage: Card({ title: 'Hello', nodes: p('World') })
  * ```
  */
-declare function defineSlottedComponent<Props extends Record<string, unknown>>(config: {
+declare function defineSlottedComponent<Props extends object>(config: {
     defaults?: Partial<Props>;
     setup: (props: WithNodes<Props>) => HTMLElement;
 }): (props: WithNodes<Props>) => HTMLElement;
@@ -177,7 +177,7 @@ declare function defineSlottedComponent<Props extends Record<string, unknown>>(c
  * // Usage: SmallIconButton({ icon: 'star', label: 'Favorite' })
  * ```
  */
-declare function withProps<OuterProps extends Record<string, unknown>, InnerProps extends Record<string, unknown>>(component: (props: InnerProps) => HTMLElement, mapProps: (outer: OuterProps) => InnerProps): (props: OuterProps) => HTMLElement;
+declare function withProps<OuterProps extends object, InnerProps extends object>(component: (props: InnerProps) => HTMLElement, mapProps: (outer: OuterProps) => InnerProps): (props: OuterProps) => HTMLElement;
 
 /**
  * Runtime prop validation and strict typing contracts for SibuJS.
@@ -216,12 +216,12 @@ type PropSchema<Props> = {
  * In production mode (process.env.NODE_ENV === 'production'), validation is skipped
  * and only defaults are applied for performance.
  */
-declare function validateProps<Props extends Record<string, unknown>>(props: Partial<Props>, schema: PropSchema<Props>): Props;
+declare function validateProps<Props extends object>(props: Partial<Props>, schema: PropSchema<Props>): Props;
 /**
  * Define a component with runtime prop validation.
  * Validates props in development mode, applies defaults, then calls setup.
  */
-declare function defineStrictComponent<Props extends Record<string, unknown>>(config: {
+declare function defineStrictComponent<Props extends object>(config: {
     name: string;
     props: PropSchema<Props>;
     setup: (props: Props) => HTMLElement;