sibujs 1.2.0 → 1.4.0

package/dist/chunk-NEKUBFPT.js

@@ -0,0 +1,60 @@
+import {
+  recordDependency,
+  track,
+  trackingSuspended
+} from "./chunk-ZD6OAMTH.js";
+import {
+  devAssert
+} from "./chunk-5X6PP2UK.js";
+
+// src/core/signals/derived.ts
+function derived(getter, options) {
+  devAssert(typeof getter === "function", "derived: argument must be a getter function.");
+  const debugName = options?.name;
+  const cs = {};
+  cs._d = false;
+  cs._g = getter;
+  const markDirty = () => {
+    if (cs._d) return;
+    cs._d = true;
+  };
+  markDirty._c = 1;
+  markDirty._sig = cs;
+  track(() => {
+    cs._d = false;
+    cs._v = getter();
+  }, markDirty);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  function computedGetter() {
+    if (trackingSuspended) {
+      if (cs._d) {
+        cs._d = false;
+        cs._v = getter();
+      }
+      return cs._v;
+    }
+    recordDependency(cs);
+    if (cs._d) {
+      const oldValue = cs._v;
+      track(() => {
+        cs._d = false;
+        cs._v = getter();
+      }, markDirty);
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (debugName) {
+    computedGetter.__name = debugName;
+    cs.__name = debugName;
+  }
+  computedGetter.__signal = cs;
+  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  return computedGetter;
+}
+
+export {
+  derived
+};

package/dist/chunk-NYVAC6P5.js

@@ -0,0 +1,37 @@
+import {
+  isSSR
+} from "./chunk-EUZND3CB.js";
+import {
+  track
+} from "./chunk-ZD6OAMTH.js";
+import {
+  devAssert
+} from "./chunk-5X6PP2UK.js";
+
+// src/core/signals/watch.ts
+function watch(getter, callback) {
+  devAssert(typeof getter === "function", "watch: first argument must be a getter function.");
+  devAssert(typeof callback === "function", "watch: second argument must be a callback function.");
+  if (isSSR()) return () => {
+  };
+  let oldValue;
+  let first = true;
+  const subscriber = () => {
+    const newValue = getter();
+    if (first) {
+      oldValue = newValue;
+      first = false;
+      return;
+    }
+    if (!Object.is(newValue, oldValue)) {
+      callback(newValue, oldValue);
+      oldValue = newValue;
+    }
+  };
+  const teardown = track(subscriber);
+  return teardown;
+}
+
+export {
+  watch
+};

package/dist/chunk-PTQJDMRT.js

@@ -0,0 +1,146 @@
+import {
+  isUrlAttribute,
+  sanitizeUrl
+} from "./chunk-CMBFNA7L.js";
+import {
+  track
+} from "./chunk-ZD6OAMTH.js";
+import {
+  devWarn,
+  isDev
+} from "./chunk-5X6PP2UK.js";
+
+// src/reactivity/bindAttribute.ts
+var _isDev = isDev();
+function isEventHandlerAttr(name) {
+  if (name.length < 3) return false;
+  const lower = name.toLowerCase();
+  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
+}
+function bindAttribute(el, attr, getter) {
+  if (isEventHandlerAttr(attr)) {
+    if (_isDev)
+      devWarn(
+        `bindAttribute: refusing to bind event-handler attribute "${attr}". Use on:{ ${attr.slice(2)}: fn } instead.`
+      );
+    return () => {
+    };
+  }
+  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);
+    }
+  };
+}
+
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var _isDev2 = isDev();
+var activeBindingCount = 0;
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  if (_isDev2) 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 (_isDev2) activeBindingCount -= disposers.length;
+      for (const d of disposers) d();
+      elementDisposers.delete(current);
+    }
+  }
+}
+function checkLeaks(warnThreshold = 0) {
+  if (!_isDev2) 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;
+}
+
+export {
+  bindAttribute,
+  bindDynamic,
+  registerDisposer,
+  dispose,
+  checkLeaks
+};