sibujs 1.0.0-beta.1

package/dist/chunk-EL6Z5MDY.js

@@ -0,0 +1,55 @@
+import {
+  recordDependency,
+  resumeTracking,
+  suspendTracking,
+  track,
+  trackingSuspended
+} from "./chunk-OB2LMD7C.js";
+
+// src/core/signals/sbDerived.ts
+function sbDerived(getter) {
+  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;
+      cs._d = false;
+      suspendTracking();
+      try {
+        cs._v = getter();
+      } finally {
+        resumeTracking();
+      }
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (hook) hook.emit("computed:create", { signal: cs, getter: computedGetter });
+  return computedGetter;
+}
+
+export {
+  sbDerived
+};

package/dist/chunk-EP7VRLEB.js

@@ -0,0 +1,41 @@
+import {
+  notifySubscribers,
+  recordDependency,
+  track
+} from "./chunk-F5JCIH3Q.js";
+
+// src/core/useEffect.ts
+function useEffect(effectFn) {
+  let cleanupHandle = () => {
+  };
+  const subscriber = () => {
+    cleanupHandle();
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  return () => {
+    cleanupHandle();
+  };
+}
+
+// src/core/useComputed.ts
+function useComputed(getter) {
+  let value = getter();
+  const computedSignal = {};
+  const recompute = () => {
+    const next = getter();
+    if (Object.is(next, value)) return;
+    value = next;
+    notifySubscribers(computedSignal);
+  };
+  track(recompute);
+  return function computedGetter() {
+    recordDependency(computedSignal);
+    return value;
+  };
+}
+
+export {
+  useEffect,
+  useComputed
+};

package/dist/chunk-ETMEC6FH.js

@@ -0,0 +1,99 @@
+import {
+  track
+} from "./chunk-M5GNLDEO.js";
+
+// src/utils/sanitize.ts
+function sanitize(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+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;
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "cite", "poster", "background", "srcset"]);
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr);
+}
+function sanitizeAttribute(attr, value) {
+  if (isUrlAttribute(attr)) {
+    return sanitizeUrl(value);
+  }
+  return sanitize(value);
+}
+
+// src/reactivity/bindAttribute.ts
+function bindAttribute(el, attr, getter) {
+  function commit() {
+    let value;
+    try {
+      value = getter();
+    } catch {
+      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 = sanitizeAttribute(attr, String(value));
+    if ((attr === "value" || attr === "checked") && attr in el) {
+      el[attr] = attr === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(attr, 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 {
+      return;
+    }
+    let value;
+    try {
+      value = typeof valueGetter === "function" ? valueGetter() : valueGetter;
+    } catch {
+      return;
+    }
+    if (name.toLowerCase().startsWith("on")) return;
+    if (prevName !== null && prevName !== name) {
+      el.removeAttribute(prevName);
+    }
+    const str = sanitizeAttribute(name, String(value));
+    if ((name === "value" || name === "checked") && name in el) {
+      el[name] = name === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(name, str);
+    }
+    prevName = name;
+  }
+  const teardown = track(commit);
+  return () => {
+    teardown();
+    if (prevName !== null) {
+      el.removeAttribute(prevName);
+    }
+  };
+}
+
+export {
+  sanitizeUrl,
+  sanitizeAttribute,
+  bindAttribute,
+  bindDynamic
+};

package/dist/chunk-EZ2WHYVL.js

@@ -0,0 +1,65 @@
+import {
+  devAssert
+} from "./chunk-XRLFASCY.js";
+import {
+  recordDependency,
+  resumeTracking,
+  suspendTracking,
+  track,
+  trackingSuspended
+} from "./chunk-M5GNLDEO.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;
+      cs._d = false;
+      suspendTracking();
+      try {
+        cs._v = getter();
+      } finally {
+        resumeTracking();
+      }
+      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-EZRVMSZK.js

@@ -0,0 +1,67 @@
+import {
+  notifySubscribers,
+  recordDependency,
+  track,
+  useState
+} from "./chunk-SNYHQP3D.js";
+
+// src/core/hooks/useEffect.ts
+function useEffect(effectFn) {
+  let cleanupHandle = () => {
+  };
+  const subscriber = () => {
+    cleanupHandle();
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  return () => {
+    cleanupHandle();
+  };
+}
+
+// src/core/hooks/useComputed.ts
+function useComputed(getter) {
+  let value;
+  const computedSignal = {};
+  const recompute = () => {
+    let next;
+    track(() => {
+      next = getter();
+    }, recompute);
+    if (Object.is(next, value)) return;
+    value = next;
+    notifySubscribers(computedSignal);
+  };
+  track(() => {
+    value = getter();
+  }, recompute);
+  return function computedGetter() {
+    recordDependency(computedSignal);
+    return value;
+  };
+}
+
+// src/core/rendering/context.ts
+function createContext(defaultValue) {
+  const [getValue, setValue] = useState(defaultValue);
+  return {
+    provide(value) {
+      setValue(value);
+    },
+    use() {
+      return getValue;
+    },
+    get() {
+      return getValue();
+    },
+    set(value) {
+      setValue(value);
+    }
+  };
+}
+
+export {
+  useEffect,
+  useComputed,
+  createContext
+};

package/dist/chunk-F2TRGINX.js

@@ -0,0 +1,254 @@
+// src/core/platform/ssr.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function renderToString(element) {
+  if (element instanceof DocumentFragment) {
+    return Array.from(element.childNodes).map((child) => renderToString(child)).join("");
+  }
+  if (element.nodeType === 3) {
+    return escapeHtml(element.textContent || "");
+  }
+  if (element.nodeType === 8) {
+    const content = (element.textContent || "").replace(/-->/g, "-->");
+    return `<!--${content}-->`;
+  }
+  if (!(element instanceof HTMLElement)) {
+    return element.textContent || "";
+  }
+  const tag = element.tagName.toLowerCase();
+  let html = `<${tag}`;
+  for (const attr of Array.from(element.attributes)) {
+    html += ` ${attr.name}="${escapeAttr(attr.value)}"`;
+  }
+  if (element.dataset && !element.dataset.sibuHydrate) {
+    html += ` data-sibu-ssr="true"`;
+  }
+  if (VOID_ELEMENTS.has(tag)) {
+    return `${html} />`;
+  }
+  html += ">";
+  for (const child of Array.from(element.childNodes)) {
+    html += renderToString(child);
+  }
+  html += `</${tag}>`;
+  return html;
+}
+function hydrate(component, container) {
+  const clientTree = component();
+  hydrateNode(container.firstElementChild, clientTree);
+  container.setAttribute("data-sibu-hydrated", "true");
+}
+function hydrateNode(serverNode, clientNode) {
+  if (!serverNode) return;
+  const serverChildren = Array.from(serverNode.children);
+  const clientChildren = Array.from(clientNode.children);
+  for (let i = 0; i < Math.min(serverChildren.length, clientChildren.length); i++) {
+    hydrateNode(serverChildren[i], clientChildren[i]);
+  }
+}
+function renderToDocument(component, options = {}) {
+  const content = renderToString(component());
+  const metaTags = (options.meta || []).map(
+    (attrs) => `<meta ${Object.entries(attrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ")} />`
+  ).join("\n    ");
+  const linkTags = (options.links || []).map(
+    (attrs) => `<link ${Object.entries(attrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ")} />`
+  ).join("\n    ");
+  const scriptTags = (options.scripts || []).map((src) => `<script src="${escapeAttr(src)}"></script>`).join("\n    ");
+  const bodyAttrs = options.bodyAttrs ? " " + Object.entries(options.bodyAttrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ") : "";
+  return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    ${options.title ? `<title>${escapeHtml(options.title)}</title>` : ""}
+    ${metaTags}
+    ${linkTags}
+    ${options.headExtra || ""}
+  </head>
+  <body${bodyAttrs}>
+    <div id="app">${content}</div>
+    ${scriptTags}
+  </body>
+</html>`;
+}
+async function* renderToStream(element) {
+  if (element instanceof DocumentFragment) {
+    for (const child of Array.from(element.childNodes)) {
+      yield* renderToStream(child);
+    }
+    return;
+  }
+  if (element.nodeType === 3) {
+    yield escapeHtml(element.textContent || "");
+    return;
+  }
+  if (element.nodeType === 8) {
+    yield `<!--${element.textContent || ""}-->`;
+    return;
+  }
+  if (!(element instanceof HTMLElement)) {
+    yield element.textContent || "";
+    return;
+  }
+  const tag = element.tagName.toLowerCase();
+  let openTag = `<${tag}`;
+  for (const attr of Array.from(element.attributes)) {
+    openTag += ` ${attr.name}="${escapeAttr(attr.value)}"`;
+  }
+  if (VOID_ELEMENTS.has(tag)) {
+    yield `${openTag} />`;
+    return;
+  }
+  yield `${openTag}>`;
+  for (const child of Array.from(element.childNodes)) {
+    yield* renderToStream(child);
+  }
+  yield `</${tag}>`;
+}
+async function collectStream(stream) {
+  let result = "";
+  for await (const chunk of stream) {
+    result += chunk;
+  }
+  return result;
+}
+function renderToReadableStream(element) {
+  const generator = renderToStream(element);
+  return new ReadableStream({
+    async pull(controller) {
+      const { value, done } = await generator.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    cancel() {
+      generator.return(void 0);
+    }
+  });
+}
+function island(id, component) {
+  const el = component();
+  el.setAttribute("data-sibu-island", id);
+  return el;
+}
+function hydrateIslands(container, islands) {
+  const markers = container.querySelectorAll("[data-sibu-island]");
+  for (const marker of Array.from(markers)) {
+    const id = marker.getAttribute("data-sibu-island");
+    const factory = islands[id];
+    if (!factory) continue;
+    const clientTree = factory();
+    hydrateNode(marker, clientTree);
+    marker.setAttribute("data-sibu-hydrated", "true");
+  }
+  container.setAttribute("data-sibu-hydrated", "partial");
+}
+function hydrateProgressively(container, islands, options) {
+  const markers = container.querySelectorAll("[data-sibu-island]");
+  const cleanups = [];
+  for (const marker of Array.from(markers)) {
+    const id = marker.getAttribute("data-sibu-island");
+    const factory = islands[id];
+    if (!factory) continue;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            const clientTree = factory();
+            hydrateNode(marker, clientTree);
+            marker.setAttribute("data-sibu-hydrated", "true");
+            observer.disconnect();
+            break;
+          }
+        }
+      },
+      { rootMargin: "200px", ...options }
+    );
+    observer.observe(marker);
+    cleanups.push(() => observer.disconnect());
+  }
+  container.setAttribute("data-sibu-hydrated", "progressive");
+  return () => {
+    for (const cleanup of cleanups) cleanup();
+  };
+}
+var suspenseIdCounter = 0;
+function resetSSRState() {
+  suspenseIdCounter = 0;
+}
+function ssrSuspense(props) {
+  const id = `sibu-sus-${suspenseIdCounter++}`;
+  const fallbackEl = props.fallback();
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-sibu-suspense-id", id);
+  wrapper.appendChild(fallbackEl);
+  const promise = props.content().then((resolvedEl) => ({
+    id,
+    html: renderToString(resolvedEl)
+  }));
+  return { element: wrapper, promise };
+}
+function suspenseSwapScript(id) {
+  const safeId = id.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+  return `<script>(function(){var t=document.getElementById("sibu-resolved-${safeId}");var f=document.querySelector('[data-sibu-suspense-id="${safeId}"]');if(t&&f){while(t.firstChild)f.appendChild(t.firstChild);t.remove();f.removeAttribute("data-sibu-suspense-id");}})()</script>`;
+}
+async function* renderToSuspenseStream(element, pendingBoundaries = []) {
+  yield* renderToStream(element);
+  if (pendingBoundaries.length > 0) {
+    const resolved = await Promise.all(pendingBoundaries);
+    for (const { id, html } of resolved) {
+      yield `<div hidden id="sibu-resolved-${id}">${html}</div>`;
+      yield suspenseSwapScript(id);
+    }
+  }
+}
+var SSR_DATA_ATTR = "__SIBU_SSR_DATA__";
+function serializeState(state) {
+  const json = JSON.stringify(state).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+  return `<script>window.${SSR_DATA_ATTR}=${json}</script>`;
+}
+function deserializeState() {
+  if (typeof window === "undefined") return void 0;
+  return window[SSR_DATA_ATTR];
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+export {
+  renderToString,
+  hydrate,
+  renderToDocument,
+  renderToStream,
+  collectStream,
+  renderToReadableStream,
+  island,
+  hydrateIslands,
+  hydrateProgressively,
+  resetSSRState,
+  ssrSuspense,
+  suspenseSwapScript,
+  renderToSuspenseStream,
+  serializeState,
+  deserializeState
+};