sibujs 4.4.0 → 4.6.0

package/dist/{chunk-LQFGQNMV.js → chunk-AIF3Z2T7.js}

@@ -4,25 +4,42 @@ import {
 } from "./chunk-H3SRKIYX.js";
 import {
   derived
-} from "./chunk-W2EQ7X2L.js";
+} from "./chunk-QE4TTDU3.js";
 import {
   effect
-} from "./chunk-7GIHSAWB.js";
+} from "./chunk-XC4MEKGA.js";
 import {
   batch,
   signal
-} from "./chunk-NVNJH22U.js";
+} from "./chunk-D33YTSX5.js";
+import {
+  DEV,
+  devWarn,
+  reportError
+} from "./chunk-NYNYSPK7.js";
 
 // src/patterns/machine.ts
 function machine(config) {
   const [state, setState] = signal(config.initial);
   const [context, setContext] = signal(config.context || {});
-  const initialDef = config.states[config.initial];
-  if (initialDef?.entry) {
-    initialDef.entry(context());
+  let currentState = config.initial;
+  let currentContext = context();
+  const queue = [];
+  let processing = false;
+  function drain() {
+    processing = true;
+    try {
+      while (queue.length > 0) {
+        step(queue.shift());
+      }
+    } catch (err) {
+      queue.length = 0;
+      throw err;
+    } finally {
+      processing = false;
+    }
   }
-  function send(event) {
-    const currentState = state();
+  function step(event) {
     const stateDef = config.states[currentState];
     if (!stateDef?.on) return;
     const transition = stateDef.on[event];
@@ -37,28 +54,51 @@ function machine(config) {
       guard = transition.guard;
       action = transition.action;
     }
-    const ctx = context();
+    const ctx = currentContext;
     if (guard && !guard(ctx)) return;
     if (stateDef.exit) {
       stateDef.exit(ctx);
     }
+    let nextContext = ctx;
     if (action) {
       const rawPatch = action(ctx);
-      const next = { ...ctx, ...stripUnsafeKeys(rawPatch) };
-      setContext(next);
+      nextContext = { ...ctx, ...stripUnsafeKeys(rawPatch) };
     }
-    setState(target);
+    currentState = target;
+    currentContext = nextContext;
+    batch(() => {
+      if (action) setContext(nextContext);
+      setState(target);
+    });
     const targetDef = config.states[target];
     if (targetDef?.entry) {
-      targetDef.entry(context());
+      targetDef.entry(currentContext);
+    }
+  }
+  function send(event) {
+    queue.push(event);
+    if (processing) return;
+    drain();
+  }
+  const initialDef = config.states[config.initial];
+  if (initialDef?.entry) {
+    processing = true;
+    try {
+      initialDef.entry(currentContext);
+    } catch (err) {
+      queue.length = 0;
+      throw err;
+    } finally {
+      processing = false;
     }
+    if (queue.length > 0) drain();
   }
   function matches(s) {
     return state() === s;
   }
   function can(event) {
-    const currentState = state();
-    const stateDef = config.states[currentState];
+    const currentState2 = state();
+    const stateDef = config.states[currentState2];
     if (!stateDef?.on) return false;
     const transition = stateDef.on[event];
     if (!transition) return false;
@@ -441,6 +481,9 @@ function optimisticList(initialValue) {
 
 // src/patterns/timeTravel.ts
 function timeline(initial, maxHistory = 100) {
+  if (!Number.isSafeInteger(maxHistory) || maxHistory < 1) {
+    throw new RangeError(`[timeline] maxHistory must be a positive safe integer, got ${maxHistory}`);
+  }
   const [history, setHistory] = signal([initial]);
   const [index, setIndex] = signal(0);
   const value = derived(() => history()[index()]);
@@ -487,7 +530,126 @@ function timeline(initial, maxHistory = 100) {
       setIndex(targetIndex);
     }
   }
-  return { value, set, undo, redo, canUndo, canRedo, history, index, reset, jumpTo };
+  function dispose() {
+    value.dispose();
+    canUndo.dispose();
+    canRedo.dispose();
+  }
+  return { value, set, undo, redo, canUndo, canRedo, history, index, reset, jumpTo, dispose };
+}
+
+// src/utils/adoption.ts
+var nativeThen = Promise.prototype.then;
+function probeNative(target, onRejected, onOpen) {
+  let decided = false;
+  const decide = (rejected) => {
+    if (decided) return;
+    decided = true;
+    (rejected ? onRejected : onOpen)();
+  };
+  try {
+    Reflect.apply(nativeThen, target, [void 0, () => decide(true)]);
+  } catch {
+    queueMicrotask(() => decide(true));
+    return;
+  }
+  queueMicrotask(() => decide(false));
+}
+function adopt(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
+  let then;
+  try {
+    then = value.then;
+  } catch (error) {
+    return {
+      promise: Promise.reject(error),
+      failedEarly: true,
+      probe: (onRejected) => queueMicrotask(onRejected)
+    };
+  }
+  if (typeof then !== "function") return null;
+  let resolvePromise;
+  let rejectPromise;
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  let state = "invoking";
+  let nativeTarget;
+  const waiters = [];
+  const transition = (next) => {
+    state = next;
+    if (next === "invoking") return;
+    for (const waiter of waiters.splice(0)) waiter();
+  };
+  const fulfil = (result) => {
+    resolvePromise(result);
+    transition("fulfilled");
+  };
+  const fail = (error) => {
+    rejectPromise(error);
+    transition("rejected");
+  };
+  const follow = (result) => {
+    if (result === promise) {
+      fail(new TypeError("adopt: a thenable resolved to its own adoption"));
+      return;
+    }
+    if (result === null || typeof result !== "object" && typeof result !== "function") {
+      fulfil(result);
+      return;
+    }
+    let nextThen;
+    try {
+      nextThen = result.then;
+    } catch (error) {
+      fail(error);
+      return;
+    }
+    if (typeof nextThen !== "function") {
+      fulfil(result);
+      return;
+    }
+    invokeLater(result, nextThen);
+  };
+  const invokeLater = (target, targetThen) => {
+    if (targetThen === nativeThen) {
+      nativeTarget = target;
+      transition("native");
+    } else {
+      transition("invoking");
+    }
+    queueMicrotask(() => {
+      let done = false;
+      const onResolve = (result) => {
+        if (done) return;
+        done = true;
+        follow(result);
+      };
+      const onReject = (error) => {
+        if (done) return;
+        done = true;
+        fail(error);
+      };
+      try {
+        Reflect.apply(targetThen, target, [onResolve, onReject]);
+      } catch (error) {
+        onReject(error);
+      }
+      if (!done && state === "invoking") transition("pending");
+    });
+  };
+  invokeLater(value, then);
+  const probe = (onRejected, onOpen) => {
+    const decide = () => {
+      if (state === "native") probeNative(nativeTarget, onRejected, onOpen);
+      else (state === "rejected" ? onRejected : onOpen)();
+    };
+    if (state === "native") probeNative(nativeTarget, onRejected, onOpen);
+    else if (state === "invoking") waiters.push(decide);
+    else queueMicrotask(state === "rejected" ? onRejected : onOpen);
+  };
+  return { promise, failedEarly: false, probe };
 }
 
 // src/patterns/globalStore.ts
@@ -524,8 +686,51 @@ function deepClone(value) {
 function globalStore(config) {
   const initialState = deepClone(config.state);
   const [getState, setState] = signal({ ...initialState });
-  const listeners = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
   const middlewares = config.middleware || [];
+  function notifyListeners(state) {
+    if (subscriptions.size === 0) return;
+    for (const subscription of Array.from(subscriptions.values())) {
+      if (!subscription.active) continue;
+      try {
+        subscription.callback(state);
+      } catch (err) {
+        reportError(err, { phase: "event", name: "globalStore(subscribe)" });
+      }
+    }
+  }
+  const operations = [];
+  let running = false;
+  function perform(operation, rethrowOwn = true) {
+    operations.push(operation);
+    if (running) return;
+    running = true;
+    let callerError;
+    let callerFailed = false;
+    try {
+      let first = true;
+      let cursor = 0;
+      while (cursor < operations.length) {
+        const next = operations[cursor];
+        operations[cursor++] = void 0;
+        try {
+          next();
+        } catch (err) {
+          if (first && rethrowOwn) {
+            callerFailed = true;
+            callerError = err;
+          } else {
+            reportError(err, { phase: "event", name: "globalStore(dispatch)" });
+          }
+        }
+        first = false;
+      }
+    } finally {
+      operations.length = 0;
+      running = false;
+    }
+    if (callerFailed) throw callerError;
+  }
   function dispatch(action, payload) {
     const actionFn = config.actions[action];
     if (!actionFn) throw new Error(`Unknown action: ${String(action)}`);
@@ -534,38 +739,96 @@ function globalStore(config) {
       const rawPatch = actionFn(current, payload);
       const patch = stripUnsafeKeys(rawPatch);
       setState({ ...current, ...patch });
-      const newState = getState();
-      for (const listener of listeners) {
-        listener(newState);
-      }
+      notifyListeners(getState());
     };
-    if (middlewares.length === 0) {
-      execute();
-      return;
-    }
-    let index = 0;
-    const next = () => {
-      if (index < middlewares.length) {
-        const mw = middlewares[index++];
-        mw(getState(), String(action), payload, next);
-      } else {
+    perform(() => {
+      if (middlewares.length === 0) {
         execute();
+        return;
       }
-    };
-    next();
+      const runFrom = (index) => {
+        if (index >= middlewares.length) {
+          execute();
+          return;
+        }
+        let called = false;
+        let failed = false;
+        let synchronous = true;
+        const next = () => {
+          if (failed && !called) {
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called after it failed for "${String(action)}"; ignored.`
+              );
+            called = true;
+            return;
+          }
+          if (called) {
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called more than once for "${String(action)}"; ignored.`
+              );
+            return;
+          }
+          called = true;
+          if (synchronous) {
+            runFrom(index + 1);
+            return;
+          }
+          const proceed = () => perform(() => runFrom(index + 1), false);
+          if (!adoption) {
+            proceed();
+            return;
+          }
+          adoption.probe(() => {
+            failed = true;
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called after it failed for "${String(action)}"; ignored.`
+              );
+          }, proceed);
+        };
+        let adoption = null;
+        try {
+          adoption = adopt(middlewares[index](getState(), String(action), payload, next));
+        } catch (err) {
+          failed = true;
+          throw err;
+        } finally {
+          synchronous = false;
+        }
+        if (adoption) {
+          if (adoption.failedEarly) failed = true;
+          adoption.promise.then(void 0, (err) => {
+            failed = true;
+            reportError(err, { phase: "async", name: "globalStore(middleware)" });
+          });
+        }
+      };
+      runFrom(0);
+    });
   }
   function select(selector) {
     return () => selector(getState());
   }
   function subscribe(callback) {
-    listeners.add(callback);
-    return () => listeners.delete(callback);
+    let subscription = subscriptions.get(callback);
+    if (!subscription) {
+      subscription = { callback, active: true };
+      subscriptions.set(callback, subscription);
+    }
+    const own = subscription;
+    return () => {
+      if (subscriptions.get(callback) !== own) return;
+      own.active = false;
+      subscriptions.delete(callback);
+    };
   }
   function reset() {
-    setState({ ...initialState });
-    for (const listener of listeners) {
-      listener(getState());
-    }
+    perform(() => {
+      setState({ ...initialState });
+      notifyListeners(getState());
+    });
   }
   return { getState, select, dispatch, subscribe, reset };
 }

package/dist/{chunk-UCALUKB5.js → chunk-BAAG6ZTI.js}

@@ -1,19 +1,22 @@
 import {
   createPlugin
-} from "./chunk-WWV3SJ3L.js";
+} from "./chunk-J6FW5TV6.js";
 import {
   tagFactory
-} from "./chunk-PNIRUQ4C.js";
+} from "./chunk-VVWPJ543.js";
 import {
   derived
-} from "./chunk-W2EQ7X2L.js";
+} from "./chunk-QE4TTDU3.js";
+import {
+  globalSingleton
+} from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-7GIHSAWB.js";
+} from "./chunk-XC4MEKGA.js";
 import {
   batch,
   signal
-} from "./chunk-NVNJH22U.js";
+} from "./chunk-D33YTSX5.js";
 
 // src/ecosystem/adapters/mobx.ts
 function mobXAdapter(options) {
@@ -111,53 +114,119 @@ function zustandAdapter(options) {
 }
 
 // src/ecosystem/ui/componentAdapter.ts
+var _themeLayers = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.themeLayers.v1"),
+  () => /* @__PURE__ */ new WeakMap()
+);
+function commitThemeProperty(root, name, record) {
+  const top = record.layers[record.layers.length - 1];
+  if (top) {
+    root.style.setProperty(name, top.value);
+    return;
+  }
+  _themeLayers.get(root)?.delete(name);
+  if (record.original.value === "") root.style.removeProperty(name);
+  else root.style.setProperty(name, record.original.value, record.original.priority);
+}
+function setThemeLayer(root, name, handle, value) {
+  let properties = _themeLayers.get(root);
+  if (!properties) _themeLayers.set(root, properties = /* @__PURE__ */ new Map());
+  let record = properties.get(name);
+  if (!record) {
+    record = {
+      original: { value: root.style.getPropertyValue(name), priority: root.style.getPropertyPriority(name) },
+      layers: []
+    };
+    properties.set(name, record);
+  }
+  const layer = record.layers.find((l) => l.handle === handle);
+  if (layer) layer.value = value;
+  else record.layers.push({ handle, value });
+  commitThemeProperty(root, name, record);
+}
+function removeThemeLayer(root, name, handle) {
+  const record = _themeLayers.get(root)?.get(name);
+  if (!record) return;
+  const index = record.layers.findIndex((l) => l.handle === handle);
+  if (index === -1) return;
+  record.layers.splice(index, 1);
+  commitThemeProperty(root, name, record);
+}
+function ownString(map, key) {
+  if (!map || key === void 0 || !Object.hasOwn(map, key)) return void 0;
+  const value = map[key];
+  return typeof value === "string" ? value : void 0;
+}
 function createTheme(initial) {
   const [getConfig, setConfig] = signal(initial);
   function resolveClass(component, variant) {
     const config = getConfig();
     const overrideKey = variant ? `${component}-${variant}` : component;
-    if (config.classOverrides?.[overrideKey]) {
-      return config.classOverrides[overrideKey];
-    }
+    const override = ownString(config.classOverrides, overrideKey);
+    if (override) return override;
     const base = `${config.prefix}-${component}`;
     return variant ? `${base} ${config.prefix}-${component}--${variant}` : base;
   }
   function setTheme(partial) {
     setConfig((prev) => ({ ...prev, ...partial }));
   }
-  return { config: getConfig, setTheme, resolveClass };
+  function applyTo(root) {
+    const handle = {};
+    let applied = /* @__PURE__ */ new Set();
+    const stop = effect(() => {
+      const variables = getConfig().variables ?? {};
+      const next = new Set(Object.keys(variables));
+      for (const name of applied) {
+        if (!next.has(name)) removeThemeLayer(root, name, handle);
+      }
+      for (const [name, value] of Object.entries(variables)) setThemeLayer(root, name, handle, value);
+      applied = next;
+    });
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      stop();
+      for (const name of applied) removeThemeLayer(root, name, handle);
+      applied.clear();
+    };
+  }
+  return { config: getConfig, setTheme, resolveClass, applyTo };
 }
 function componentAdapter(config) {
   const theme = createTheme({ prefix: config.prefix });
+  const reprefix = (cls, prefix) => prefix !== config.prefix && cls.startsWith(`${config.prefix}-`) ? `${prefix}-${cls.slice(config.prefix.length + 1)}` : cls;
   const components = {};
   for (const [name, mapping] of Object.entries(config.components)) {
     const factory = tagFactory(mapping.tag || "div");
-    components[name] = (props = {}) => {
+    components[name] = (props = {}, children) => {
       const { variant, size, class: userClass, ...rest } = props;
-      const classes = [mapping.baseClass];
-      if (variant && mapping.variants?.[variant]) {
-        classes.push(mapping.variants[variant]);
-      }
-      if (size && mapping.sizes?.[size]) {
-        classes.push(mapping.sizes[size]);
-      }
-      let finalClass;
-      if (typeof userClass === "function") {
-        finalClass = () => {
-          const extra = userClass();
-          return extra ? `${classes.join(" ")} ${extra}` : classes.join(" ");
-        };
-      } else if (typeof userClass === "string" && userClass) {
-        finalClass = `${classes.join(" ")} ${userClass}`;
-      } else {
-        finalClass = classes.join(" ");
-      }
+      const themeClasses = () => {
+        const current = theme.config();
+        const overrides = current.classOverrides ?? {};
+        const pick = (key, fallback) => Object.hasOwn(overrides, key) ? overrides[key] : reprefix(fallback, current.prefix);
+        const classes = [pick(name, mapping.baseClass)];
+        const variantClass = ownString(mapping.variants, variant);
+        if (variant && variantClass) {
+          classes.push(pick(`${name}-${variant}`, variantClass));
+        }
+        const sizeClass = ownString(mapping.sizes, size);
+        if (size && sizeClass) {
+          classes.push(pick(`${name}-${size}`, sizeClass));
+        }
+        return classes.filter(Boolean).join(" ");
+      };
+      const finalClass = () => {
+        const base = themeClasses();
+        const extra = typeof userClass === "function" ? userClass() : userClass;
+        return typeof extra === "string" && extra ? `${base} ${extra}` : base;
+      };
       const mergedProps = {
         ...mapping.defaultProps,
         ...rest,
         class: finalClass
       };
-      return factory(mergedProps);
+      return children === void 0 ? factory(mergedProps) : factory(mergedProps, children);
     };
   }
   return { name: config.name, components, theme };

package/dist/{chunk-NVNJH22U.js → chunk-D33YTSX5.js}

@@ -3,10 +3,10 @@ import {
   notifySubscribers,
   queueSignalNotification,
   recordDependency
-} from "./chunk-3BTTCZ5J.js";
+} from "./chunk-5Q4R7HCL.js";
 import {
   DEV
-} from "./chunk-2WLZ6757.js";
+} from "./chunk-NYNYSPK7.js";
 
 // src/reactivity/batch.ts
 var batchDepth = 0;