sibujs 1.5.0 → 2.0.0

package/dist/chunk-ZD6OAMTH.js

@@ -1,277 +0,0 @@
-import {
-  devWarn,
-  isDev
-} from "./chunk-5X6PP2UK.js";
-
-// src/reactivity/track.ts
-var _isDev = isDev();
-var subscriberStack = new Array(32);
-var stackCapacity = 32;
-var stackTop = -1;
-var currentSubscriber = null;
-var signalSubscribers = /* @__PURE__ */ new WeakMap();
-var SUBS = "__s";
-var notifyDepth = 0;
-var pendingQueue = [];
-var pendingSet = /* @__PURE__ */ new Set();
-function safeInvoke(sub) {
-  try {
-    sub();
-  } catch (err) {
-    if (_isDev) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-var suspendDepth = 0;
-var trackingSuspended = false;
-function track(effectFn, subscriber) {
-  if (!subscriber) subscriber = effectFn;
-  cleanup(subscriber);
-  ++stackTop;
-  if (stackTop >= stackCapacity) {
-    stackCapacity *= 2;
-    subscriberStack.length = stackCapacity;
-  }
-  subscriberStack[stackTop] = subscriber;
-  currentSubscriber = subscriber;
-  try {
-    effectFn();
-  } finally {
-    stackTop--;
-    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
-  }
-  return () => cleanup(subscriber);
-}
-function suspendTracking() {
-  if (suspendDepth === 0) {
-    ++stackTop;
-    if (stackTop >= stackCapacity) {
-      stackCapacity *= 2;
-      subscriberStack.length = stackCapacity;
-    }
-    subscriberStack[stackTop] = null;
-    currentSubscriber = null;
-    trackingSuspended = true;
-  }
-  suspendDepth++;
-}
-function resumeTracking() {
-  suspendDepth--;
-  if (suspendDepth === 0) {
-    stackTop--;
-    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
-    trackingSuspended = false;
-  }
-}
-function untracked(fn) {
-  suspendTracking();
-  try {
-    return fn();
-  } finally {
-    resumeTracking();
-  }
-}
-function recordDependency(signal) {
-  if (!currentSubscriber) return;
-  const sub = currentSubscriber;
-  if (sub._dep === signal) return;
-  const deps = sub._deps;
-  if (deps) {
-    if (deps.has(signal)) return;
-    deps.add(signal);
-  } else if (sub._dep !== void 0) {
-    const set = /* @__PURE__ */ new Set();
-    set.add(sub._dep);
-    set.add(signal);
-    sub._deps = set;
-    sub._dep = void 0;
-  } else {
-    sub._dep = signal;
-  }
-  let subs = signal[SUBS];
-  if (!subs) {
-    subs = /* @__PURE__ */ new Set();
-    signalSubscribers.set(signal, subs);
-    signal[SUBS] = subs;
-  }
-  subs.add(currentSubscriber);
-  if (subs.size === 1) {
-    signal.__f = currentSubscriber;
-  } else if (signal.__f !== void 0) {
-    signal.__f = void 0;
-  }
-}
-function queueSignalNotification(signal) {
-  const subs = signal[SUBS];
-  if (!subs) return;
-  for (const sub of subs) {
-    if (sub._c) {
-      propagateDirty(sub);
-    } else if (!pendingSet.has(sub)) {
-      pendingSet.add(sub);
-      pendingQueue.push(sub);
-    }
-  }
-}
-function drainNotificationQueue() {
-  if (notifyDepth > 0) return;
-  notifyDepth++;
-  try {
-    let i = 0;
-    while (i < pendingQueue.length) {
-      safeInvoke(pendingQueue[i]);
-      i++;
-    }
-  } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
-    notifyDepth--;
-  }
-}
-function propagateDirty(sub) {
-  sub();
-  let sig = sub._sig;
-  while (sig) {
-    const first = sig.__f;
-    if (first) {
-      if (first._c) {
-        const nSig = first._sig;
-        nSig._d = true;
-        sig = nSig;
-        continue;
-      }
-      if (!pendingSet.has(first)) {
-        pendingSet.add(first);
-        pendingQueue.push(first);
-      }
-      break;
-    }
-    const subs = sig[SUBS];
-    if (!subs) break;
-    let nextSig;
-    for (const s of subs) {
-      if (s._c) {
-        s();
-        const nSig = s._sig;
-        if (nSig && !nextSig) {
-          nextSig = nSig;
-        } else if (nSig) {
-          propagateDirty(s);
-        }
-      } else if (!pendingSet.has(s)) {
-        pendingSet.add(s);
-        pendingQueue.push(s);
-      }
-    }
-    sig = nextSig;
-  }
-}
-function notifySubscribers(signal) {
-  const first = signal.__f;
-  if (first) {
-    if (notifyDepth > 0) {
-      if (first._c) {
-        propagateDirty(first);
-      } else if (!pendingSet.has(first)) {
-        pendingSet.add(first);
-        pendingQueue.push(first);
-      }
-      return;
-    }
-    notifyDepth++;
-    try {
-      if (first._c) {
-        propagateDirty(first);
-      } else {
-        safeInvoke(first);
-      }
-      let i = 0;
-      while (i < pendingQueue.length) {
-        safeInvoke(pendingQueue[i]);
-        i++;
-      }
-    } finally {
-      pendingQueue.length = 0;
-      pendingSet.clear();
-      notifyDepth--;
-    }
-    return;
-  }
-  const subs = signal[SUBS];
-  if (!subs || subs.size === 0) return;
-  if (notifyDepth > 0) {
-    for (const sub of subs) {
-      if (sub._c) {
-        propagateDirty(sub);
-      } else if (!pendingSet.has(sub)) {
-        pendingSet.add(sub);
-        pendingQueue.push(sub);
-      }
-    }
-    return;
-  }
-  notifyDepth++;
-  try {
-    let directCount = 0;
-    for (const sub of subs) {
-      pendingQueue[directCount++] = sub;
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (pendingQueue[i2]._c) {
-        propagateDirty(pendingQueue[i2]);
-      }
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (!pendingQueue[i2]._c) {
-        if (!pendingSet.has(pendingQueue[i2])) {
-          safeInvoke(pendingQueue[i2]);
-        }
-      }
-    }
-    let i = directCount;
-    while (i < pendingQueue.length) {
-      safeInvoke(pendingQueue[i]);
-      i++;
-    }
-  } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
-    notifyDepth--;
-  }
-}
-function cleanup(subscriber) {
-  const sub = subscriber;
-  const singleDep = sub._dep;
-  if (singleDep !== void 0) {
-    const subs = singleDep[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (singleDep.__f === subscriber) {
-        singleDep.__f = void 0;
-      }
-    }
-    sub._dep = void 0;
-    return;
-  }
-  const deps = sub._deps;
-  if (!deps || deps.size === 0) return;
-  for (const signal of deps) {
-    const subs = signal[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (signal.__f === subscriber) {
-        signal.__f = void 0;
-      }
-    }
-  }
-  deps.clear();
-}
-
-export {
-  trackingSuspended,
-  track,
-  untracked,
-  recordDependency,
-  queueSignalNotification,
-  drainNotificationQueue,
-  notifySubscribers
-};

package/dist/chunk-ZWKZCBO6.js

@@ -1,317 +0,0 @@
-import {
-  derived
-} from "./chunk-NEKUBFPT.js";
-import {
-  effect
-} from "./chunk-CHF5OHIA.js";
-import {
-  signal
-} from "./chunk-WZSPOOER.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());
-  }
-  function send(event) {
-    const currentState = state();
-    const stateDef = config.states[currentState];
-    if (!stateDef?.on) return;
-    const transition = stateDef.on[event];
-    if (!transition) return;
-    let target;
-    let guard;
-    let action;
-    if (typeof transition === "string") {
-      target = transition;
-    } else {
-      target = transition.target;
-      guard = transition.guard;
-      action = transition.action;
-    }
-    const ctx = context();
-    if (guard && !guard(ctx)) return;
-    if (stateDef.exit) {
-      stateDef.exit(ctx);
-    }
-    if (action) {
-      const rawPatch = action(ctx);
-      const next = { ...ctx };
-      for (const key of Object.keys(rawPatch)) {
-        if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-        next[key] = rawPatch[key];
-      }
-      setContext(next);
-    }
-    setState(target);
-    const targetDef = config.states[target];
-    if (targetDef?.entry) {
-      targetDef.entry(context());
-    }
-  }
-  function matches(s) {
-    return state() === s;
-  }
-  function can(event) {
-    const currentState = state();
-    const stateDef = config.states[currentState];
-    if (!stateDef?.on) return false;
-    const transition = stateDef.on[event];
-    if (!transition) return false;
-    if (typeof transition === "string") return true;
-    if (transition.guard) {
-      return transition.guard(context());
-    }
-    return true;
-  }
-  return { state, context, send, matches, can };
-}
-
-// src/patterns/persist.ts
-function persisted(key, initial, options = {}) {
-  const storage = options.session ? sessionStorage : localStorage;
-  const serialize = options.serialize || JSON.stringify;
-  const deserialize = options.deserialize || JSON.parse;
-  const encrypt = options.encrypt;
-  const decrypt = options.decrypt;
-  const syncTabs = options.session ? false : options.syncTabs ?? true;
-  let restored = initial;
-  try {
-    let raw = storage.getItem(key);
-    if (raw !== null) {
-      if (decrypt) raw = decrypt(raw);
-      const parsed = deserialize(raw);
-      restored = options.validate && !options.validate(parsed) ? initial : parsed;
-    }
-  } catch {
-  }
-  const [value, setValue] = signal(restored);
-  let applyingFromStorage = false;
-  effect(() => {
-    const current = value();
-    if (applyingFromStorage) return;
-    try {
-      let serialized = serialize(current);
-      if (encrypt) serialized = encrypt(serialized);
-      storage.setItem(key, serialized);
-    } catch {
-    }
-  });
-  let storageListener = null;
-  if (syncTabs && typeof window !== "undefined") {
-    storageListener = (e) => {
-      if (e.storageArea !== storage || e.key !== key) return;
-      if (e.newValue === null) {
-        applyingFromStorage = true;
-        try {
-          setValue(initial);
-        } finally {
-          applyingFromStorage = false;
-        }
-        return;
-      }
-      try {
-        let raw = e.newValue;
-        if (decrypt) raw = decrypt(raw);
-        const parsed = deserialize(raw);
-        if (options.validate && !options.validate(parsed)) return;
-        applyingFromStorage = true;
-        try {
-          setValue(parsed);
-        } finally {
-          applyingFromStorage = false;
-        }
-      } catch {
-      }
-    };
-    window.addEventListener("storage", storageListener);
-  }
-  const dispose = () => {
-    if (storageListener && typeof window !== "undefined") {
-      window.removeEventListener("storage", storageListener);
-      storageListener = null;
-    }
-  };
-  Object.defineProperty(setValue, "dispose", {
-    value: dispose,
-    enumerable: false,
-    writable: false,
-    configurable: false
-  });
-  return [value, setValue];
-}
-
-// src/patterns/optimistic.ts
-function optimistic(initialValue) {
-  const [value, setValue] = signal(initialValue);
-  const [_pending, setPending] = signal(false);
-  async function addOptimistic(optimisticValue, asyncAction) {
-    const previousValue = value();
-    setValue(optimisticValue);
-    setPending(true);
-    try {
-      const result = await asyncAction();
-      setValue(result);
-    } catch {
-      setValue(previousValue);
-    } finally {
-      setPending(false);
-    }
-  }
-  return [value, addOptimistic];
-}
-function optimisticList(initialValue) {
-  const [items, setItems] = signal([...initialValue]);
-  async function addOptimistic(item, asyncAction) {
-    const prev = items();
-    setItems([...prev, item]);
-    try {
-      const result = await asyncAction();
-      setItems((current) => {
-        const idx = current.lastIndexOf(item);
-        if (idx >= 0) {
-          const next = [...current];
-          next[idx] = result;
-          return next;
-        }
-        return [...current.filter((i) => i !== item), result];
-      });
-    } catch {
-      setItems(prev);
-    }
-  }
-  async function removeOptimistic(predicate, asyncAction) {
-    const prev = items();
-    setItems(prev.filter((item) => !predicate(item)));
-    try {
-      await asyncAction();
-    } catch {
-      setItems(prev);
-    }
-  }
-  async function updateOptimistic(predicate, update, asyncAction) {
-    const prev = items();
-    setItems(prev.map((item) => predicate(item) ? { ...item, ...update } : item));
-    try {
-      const result = await asyncAction();
-      setItems((current) => current.map((item) => predicate(item) ? result : item));
-    } catch {
-      setItems(prev);
-    }
-  }
-  return { items, addOptimistic, removeOptimistic, updateOptimistic };
-}
-
-// src/patterns/timeTravel.ts
-function timeline(initial, maxHistory = 100) {
-  const [history, setHistory] = signal([initial]);
-  const [index, setIndex] = signal(0);
-  const value = derived(() => history()[index()]);
-  const canUndo = derived(() => index() > 0);
-  const canRedo = derived(() => index() < history().length - 1);
-  function set(next) {
-    const current = value();
-    const newValue = typeof next === "function" ? next(current) : next;
-    if (Object.is(newValue, current)) return;
-    const hist = history();
-    const idx = index();
-    const newHistory = hist.slice(0, idx + 1);
-    newHistory.push(newValue);
-    if (newHistory.length > maxHistory) {
-      newHistory.shift();
-      setHistory(newHistory);
-      setIndex(newHistory.length - 1);
-    } else {
-      setHistory(newHistory);
-      setIndex(idx + 1);
-    }
-  }
-  function undo() {
-    if (canUndo()) {
-      setIndex(index() - 1);
-    }
-  }
-  function redo() {
-    if (canRedo()) {
-      setIndex(index() + 1);
-    }
-  }
-  function reset() {
-    setHistory([initial]);
-    setIndex(0);
-  }
-  function jumpTo(targetIndex) {
-    const hist = history();
-    if (targetIndex >= 0 && targetIndex < hist.length) {
-      setIndex(targetIndex);
-    }
-  }
-  return { value, set, undo, redo, canUndo, canRedo, history, index, reset, jumpTo };
-}
-
-// src/patterns/globalStore.ts
-function globalStore(config) {
-  const initialState = { ...config.state };
-  const [getState, setState] = signal({ ...initialState });
-  const listeners = /* @__PURE__ */ new Set();
-  const middlewares = config.middleware || [];
-  function dispatch(action, payload) {
-    const actionFn = config.actions[action];
-    if (!actionFn) throw new Error(`Unknown action: ${String(action)}`);
-    const execute = () => {
-      const current = getState();
-      const rawPatch = actionFn(current, payload);
-      const patch = {};
-      for (const key of Object.keys(rawPatch)) {
-        if (key !== "__proto__" && key !== "constructor" && key !== "prototype") {
-          patch[key] = rawPatch[key];
-        }
-      }
-      setState({ ...current, ...patch });
-      const newState = getState();
-      for (const listener of listeners) {
-        listener(newState);
-      }
-    };
-    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 {
-        execute();
-      }
-    };
-    next();
-  }
-  function select(selector) {
-    return derived(() => selector(getState()));
-  }
-  function subscribe(callback) {
-    listeners.add(callback);
-    return () => listeners.delete(callback);
-  }
-  function reset() {
-    setState({ ...initialState });
-    for (const listener of listeners) {
-      listener(getState());
-    }
-  }
-  return { getState, select, dispatch, subscribe, reset };
-}
-
-export {
-  machine,
-  persisted,
-  optimistic,
-  optimisticList,
-  timeline,
-  globalStore
-};