sibujs 1.0.0 → 1.0.2

package/dist/chunk-SDLZDHKP.js

@@ -0,0 +1,107 @@
+import {
+  track
+} from "./chunk-YECR7UIA.js";
+import {
+  devWarn,
+  isDev
+} from "./chunk-4MYMUBRS.js";
+
+// src/utils/sanitize.ts
+function sanitizeUrl(url) {
+  const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
+  if (!trimmed) return "";
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:") || lower.startsWith("blob:")) {
+    return "";
+  }
+  return trimmed;
+}
+function sanitizeCSSValue(value) {
+  const lower = value.toLowerCase().replace(/\s+/g, "");
+  if (lower.includes("url(") || lower.includes("expression(") || lower.includes("javascript:") || lower.includes("-moz-binding")) {
+    return "";
+  }
+  return value;
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "cite", "poster", "background", "srcset"]);
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr);
+}
+
+// src/reactivity/bindAttribute.ts
+var _isDev = isDev();
+function bindAttribute(el, attr, getter) {
+  function commit() {
+    let value;
+    try {
+      value = getter();
+    } catch (err) {
+      if (_isDev)
+        devWarn(`bindAttribute: getter for "${attr}" threw: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    if (typeof value === "boolean") {
+      if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
+        el[attr] = value;
+      } else if (value) {
+        el.setAttribute(attr, "");
+      } else {
+        el.removeAttribute(attr);
+      }
+      return;
+    }
+    const str = String(value);
+    if ((attr === "value" || attr === "checked") && attr in el) {
+      el[attr] = attr === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(attr, isUrlAttribute(attr) ? sanitizeUrl(str) : str);
+    }
+  }
+  const teardown = track(commit);
+  return teardown;
+}
+function bindDynamic(el, nameGetter, valueGetter) {
+  let prevName = null;
+  function commit() {
+    let name;
+    try {
+      name = typeof nameGetter === "function" ? nameGetter() : nameGetter;
+    } catch (err) {
+      if (_isDev) devWarn(`bindDynamic: name getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    let value;
+    try {
+      value = typeof valueGetter === "function" ? valueGetter() : valueGetter;
+    } catch (err) {
+      if (_isDev) devWarn(`bindDynamic: value getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    if ((name[0] === "o" || name[0] === "O") && (name[1] === "n" || name[1] === "N")) return;
+    if (prevName !== null && prevName !== name) {
+      el.removeAttribute(prevName);
+    }
+    const str = String(value);
+    if ((name === "value" || name === "checked") && name in el) {
+      el[name] = name === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(name, isUrlAttribute(name) ? sanitizeUrl(str) : str);
+    }
+    prevName = name;
+  }
+  const teardown = track(commit);
+  return () => {
+    teardown();
+    if (prevName !== null) {
+      el.removeAttribute(prevName);
+    }
+  };
+}
+
+export {
+  sanitizeUrl,
+  sanitizeCSSValue,
+  isUrlAttribute,
+  bindAttribute,
+  bindDynamic
+};

package/dist/chunk-Y6GP4QGG.js

@@ -0,0 +1,276 @@
+import {
+  derived
+} from "./chunk-FGOEVHY3.js";
+import {
+  effect
+} from "./chunk-PZEGYCF5.js";
+import {
+  signal
+} from "./chunk-YECR7UIA.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 patch = action(ctx);
+      setContext({ ...ctx, ...patch });
+    }
+    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;
+  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);
+  effect(() => {
+    const current = value();
+    try {
+      let serialized = serialize(current);
+      if (encrypt) serialized = encrypt(serialized);
+      storage.setItem(key, serialized);
+    } catch {
+    }
+  });
+  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 patch = actionFn(current, payload);
+      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 };
+}
+
+// src/patterns/primitives.ts
+function createSignal(value) {
+  return signal(value);
+}
+function createMemo(fn) {
+  return derived(fn);
+}
+function createEffect(fn) {
+  return effect(fn);
+}
+
+export {
+  machine,
+  persisted,
+  optimistic,
+  optimisticList,
+  timeline,
+  globalStore,
+  createSignal,
+  createMemo,
+  createEffect
+};

package/dist/chunk-YECR7UIA.js

@@ -0,0 +1,347 @@
+import {
+  devWarn,
+  isDev
+} from "./chunk-4MYMUBRS.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(signal2) {
+  if (!currentSubscriber) return;
+  const sub = currentSubscriber;
+  if (sub._dep === signal2) return;
+  const deps = sub._deps;
+  if (deps) {
+    if (deps.has(signal2)) return;
+    deps.add(signal2);
+  } else if (sub._dep !== void 0) {
+    const set = /* @__PURE__ */ new Set();
+    set.add(sub._dep);
+    set.add(signal2);
+    sub._deps = set;
+    sub._dep = void 0;
+  } else {
+    sub._dep = signal2;
+  }
+  let subs = signal2[SUBS];
+  if (!subs) {
+    subs = /* @__PURE__ */ new Set();
+    signalSubscribers.set(signal2, subs);
+    signal2[SUBS] = subs;
+  }
+  subs.add(currentSubscriber);
+  if (subs.size === 1) {
+    signal2.__f = currentSubscriber;
+  } else if (signal2.__f !== void 0) {
+    signal2.__f = void 0;
+  }
+}
+function queueSignalNotification(signal2) {
+  const subs = signal2[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(signal2) {
+  const first = signal2.__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 = signal2[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 signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function isBatching() {
+  return batchDepth > 0;
+}
+function flushBatch() {
+  for (const signal2 of pendingSignals) {
+    queueSignalNotification(signal2);
+  }
+  pendingSignals.clear();
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+var _g = globalThis;
+var _isDev2 = isDev();
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = _isDev2 ? options?.name : void 0;
+  const equalsFn = options?.equals;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (equalsFn ? equalsFn(state.value, newValue) : Object.is(newValue, state.value)) return;
+    if (_isDev2) {
+      const oldValue = state.value;
+      state.value = newValue;
+      const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    } else {
+      state.value = newValue;
+    }
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  if (_isDev2) {
+    const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  }
+  return [get, set];
+}
+
+export {
+  trackingSuspended,
+  track,
+  untracked,
+  recordDependency,
+  notifySubscribers,
+  batch,
+  enqueueBatchedSignal,
+  isBatching,
+  signal
+};