sibujs 1.4.0 → 2.0.0

package/dist/chunk-WADYRCO2.js

@@ -1,304 +0,0 @@
-import {
-  bindAttribute,
-  isUrlAttribute,
-  sanitizeCSSValue,
-  sanitizeUrl
-} from "./chunk-23VV7YD3.js";
-import {
-  track
-} from "./chunk-V2XTI523.js";
-import {
-  devWarn,
-  isDev
-} from "./chunk-UNXCEF6S.js";
-
-// src/core/rendering/dispose.ts
-var elementDisposers = /* @__PURE__ */ new WeakMap();
-var _isDev = isDev();
-var activeBindingCount = 0;
-function registerDisposer(node, teardown) {
-  let disposers = elementDisposers.get(node);
-  if (!disposers) {
-    disposers = [];
-    elementDisposers.set(node, disposers);
-  }
-  disposers.push(teardown);
-  if (_isDev) activeBindingCount++;
-}
-function dispose(node) {
-  const stack = [node];
-  const order = [];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    order.push(current);
-    const children = current.childNodes;
-    for (let i = 0; i < children.length; i++) {
-      stack.push(children[i]);
-    }
-  }
-  for (let i = order.length - 1; i >= 0; i--) {
-    const current = order[i];
-    const disposers = elementDisposers.get(current);
-    if (disposers) {
-      if (_isDev) activeBindingCount -= disposers.length;
-      for (const d of disposers) d();
-      elementDisposers.delete(current);
-    }
-  }
-}
-function checkLeaks(warnThreshold = 0) {
-  if (!_isDev) return 0;
-  if (warnThreshold > 0 && activeBindingCount > warnThreshold) {
-    devWarn(
-      `checkLeaks: ${activeBindingCount} active DOM bindings detected. Expected \u2264${warnThreshold}. This may indicate a component was removed from the DOM without calling dispose().`
-    );
-  }
-  return activeBindingCount;
-}
-
-// src/reactivity/bindChildNode.ts
-var _isDev2 = isDev();
-function bindChildNode(placeholder, getter) {
-  let lastNodes = [];
-  function commit() {
-    let result;
-    try {
-      result = getter();
-    } catch (err) {
-      if (_isDev2) devWarn(`bindChildNode: getter threw: ${err instanceof Error ? err.message : String(err)}`);
-      return;
-    }
-    for (let i = 0; i < lastNodes.length; i++) {
-      const node = lastNodes[i];
-      if (node.parentNode) node.parentNode.removeChild(node);
-    }
-    if (result == null || typeof result === "boolean") {
-      lastNodes.length = 0;
-      return;
-    }
-    const parent = placeholder.parentNode;
-    if (!parent) {
-      lastNodes.length = 0;
-      return;
-    }
-    const anchor = placeholder.nextSibling;
-    let count = 0;
-    if (Array.isArray(result)) {
-      if (lastNodes.length < result.length) lastNodes = new Array(result.length);
-      for (let i = 0; i < result.length; i++) {
-        const item = result[i];
-        if (item == null || typeof item === "boolean") continue;
-        const node = item instanceof Node ? item : document.createTextNode(String(item));
-        parent.insertBefore(node, anchor);
-        lastNodes[count++] = node;
-      }
-    } else {
-      if (lastNodes.length < 1) lastNodes = [null];
-      const node = result instanceof Node ? result : document.createTextNode(String(result));
-      parent.insertBefore(node, anchor);
-      lastNodes[count++] = node;
-    }
-    lastNodes.length = count;
-  }
-  return track(commit);
-}
-
-// src/core/rendering/tagFactory.ts
-var SVG_NS = "http://www.w3.org/2000/svg";
-var kebabCache = /* @__PURE__ */ new Map();
-function toKebab(prop) {
-  let cached = kebabCache.get(prop);
-  if (cached !== void 0) return cached;
-  cached = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-  kebabCache.set(prop, cached);
-  return cached;
-}
-function applyStyle(el, style) {
-  if (typeof style === "function") {
-    const teardown = track(() => {
-      el.setAttribute("style", style());
-    });
-    registerDisposer(el, teardown);
-    return;
-  }
-  if (typeof style === "string") {
-    el.setAttribute("style", style);
-    return;
-  }
-  const htmlEl = el;
-  for (const prop in style) {
-    const val = style[prop];
-    const name = toKebab(prop);
-    if (typeof val === "function") {
-      const getter = val;
-      const teardown = track(() => {
-        htmlEl.style.setProperty(name, sanitizeCSSValue(String(getter())));
-      });
-      registerDisposer(el, teardown);
-    } else {
-      htmlEl.style.setProperty(name, sanitizeCSSValue(String(val)));
-    }
-  }
-}
-function applyClass(el, cls) {
-  if (typeof cls === "string") {
-    el.setAttribute("class", cls);
-    return;
-  }
-  if (typeof cls === "function") {
-    const teardown = track(() => {
-      el.setAttribute("class", cls());
-    });
-    registerDisposer(el, teardown);
-    return;
-  }
-  const obj = cls;
-  let hasReactive = false;
-  let result = "";
-  for (const name in obj) {
-    const val = obj[name];
-    if (typeof val === "function") {
-      hasReactive = true;
-      break;
-    }
-    if (val) result = result ? `${result} ${name}` : name;
-  }
-  if (hasReactive) {
-    const update = () => {
-      let r = "";
-      for (const name in obj) {
-        const val = obj[name];
-        const active = typeof val === "function" ? val() : val;
-        if (active) r = r ? `${r} ${name}` : name;
-      }
-      el.setAttribute("class", r);
-    };
-    const teardown = track(update);
-    registerDisposer(el, teardown);
-  } else {
-    el.setAttribute("class", result);
-  }
-}
-function appendChildren(el, nodes) {
-  if (typeof nodes === "string") {
-    el.textContent = nodes;
-    return;
-  }
-  if (typeof nodes === "number") {
-    el.textContent = String(nodes);
-    return;
-  }
-  if (typeof nodes === "boolean" || nodes == null) {
-    return;
-  }
-  if (typeof nodes === "function") {
-    const ph = document.createComment("");
-    el.appendChild(ph);
-    registerDisposer(el, bindChildNode(ph, nodes));
-    return;
-  }
-  if (nodes instanceof Node) {
-    el.appendChild(nodes);
-    return;
-  }
-  if (Array.isArray(nodes)) {
-    for (let i = 0; i < nodes.length; i++) {
-      const c = nodes[i];
-      if (typeof c === "function") {
-        const ph = document.createComment("");
-        el.appendChild(ph);
-        registerDisposer(el, bindChildNode(ph, c));
-      } else if (c instanceof Node) {
-        el.appendChild(c);
-      } else if (Array.isArray(c)) {
-        for (let j = 0; j < c.length; j++) {
-          const inner = c[j];
-          if (typeof inner === "function") {
-            const ph = document.createComment("");
-            el.appendChild(ph);
-            registerDisposer(el, bindChildNode(ph, inner));
-          } else if (inner instanceof Node) {
-            el.appendChild(inner);
-          } else if (inner != null && typeof inner !== "boolean") {
-            el.appendChild(document.createTextNode(String(inner)));
-          }
-        }
-      } else if (c != null && typeof c !== "boolean") {
-        el.appendChild(document.createTextNode(String(c)));
-      }
-    }
-  }
-}
-var tagFactory = (tag, ns) => (first, second) => {
-  const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
-  if (first === void 0) return el;
-  if (second === void 0 && typeof first === "string") {
-    el.textContent = first;
-    return el;
-  }
-  if (second !== void 0) {
-    el.setAttribute("class", first);
-    appendChildren(el, second);
-    return el;
-  }
-  if (Array.isArray(first) || first instanceof Node) {
-    appendChildren(el, first);
-    return el;
-  }
-  const props = first;
-  const pClass = props.class;
-  if (pClass != null) applyClass(el, pClass);
-  const pId = props.id;
-  if (pId != null) el.id = pId;
-  const pNodes = props.nodes;
-  if (pNodes != null) appendChildren(el, pNodes);
-  const pOn = props.on;
-  if (pOn) {
-    for (const ev in pOn) {
-      el.addEventListener(ev, pOn[ev]);
-    }
-  }
-  const pStyle = props.style;
-  if (pStyle != null) applyStyle(el, pStyle);
-  const pRef = props.ref;
-  if (pRef) pRef.current = el;
-  for (const key in props) {
-    switch (key) {
-      case "class":
-      case "id":
-      case "nodes":
-      case "on":
-      case "style":
-      case "ref":
-      case "onElement":
-        continue;
-      // already handled above / below
-      default: {
-        const value = props[key];
-        if (value == null || value === false) continue;
-        if (key[0] === "o" && key[1] === "n") continue;
-        if (typeof value === "function") {
-          registerDisposer(el, bindAttribute(el, key, value));
-        } else if (value === true) {
-          el.setAttribute(key, "");
-        } else {
-          const str = String(value);
-          el.setAttribute(key, isUrlAttribute(key) ? sanitizeUrl(str) : str);
-        }
-      }
-    }
-  }
-  if (props.onElement && typeof props.onElement === "function") {
-    props.onElement(el);
-  }
-  return el;
-};
-
-export {
-  bindChildNode,
-  registerDisposer,
-  dispose,
-  checkLeaks,
-  SVG_NS,
-  tagFactory
-};

package/dist/chunk-WILQZRO4.js

@@ -1,282 +0,0 @@
-import {
-  derived
-} from "./chunk-L6JRBDNS.js";
-import {
-  effect
-} from "./chunk-6SA3QQES.js";
-import {
-  signal
-} from "./chunk-V2XTI523.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 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 };
-}
-
-// 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
-};