@qorejs/qore 0.6.0

package/dist/index.js

@@ -0,0 +1,1193 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+let activeEffect = null;
+let batchDepth = 0;
+const pendingEffects = /* @__PURE__ */ new Set();
+class EffectNode {
+  constructor(fn) {
+    __publicField(this, "deps", /* @__PURE__ */ new Set());
+    __publicField(this, "fn");
+    __publicField(this, "cleanup");
+    this.fn = fn;
+  }
+  run() {
+    for (const dep of this.deps) {
+      dep.subs.delete(this);
+    }
+    this.deps.clear();
+    if (this.cleanup) {
+      this.cleanup();
+      this.cleanup = void 0;
+    }
+    const prevEffect = activeEffect;
+    activeEffect = this;
+    try {
+      const result = this.fn();
+      if (typeof result === "function") {
+        this.cleanup = result;
+      }
+    } finally {
+      activeEffect = prevEffect;
+    }
+  }
+}
+class SignalNode {
+  constructor(initial) {
+    __publicField(this, "value");
+    __publicField(this, "subs", /* @__PURE__ */ new Set());
+    this.value = initial;
+  }
+  get() {
+    if (activeEffect) {
+      this.subs.add(activeEffect);
+      activeEffect.deps.add(this);
+    }
+    return this.value;
+  }
+  set(newValue) {
+    if (this.value === newValue) return;
+    this.value = newValue;
+    this.notify();
+  }
+  notify() {
+    const effectsToRun = Array.from(this.subs);
+    if (batchDepth > 0) {
+      effectsToRun.forEach((sub) => pendingEffects.add(sub));
+      return;
+    }
+    for (const effect2 of effectsToRun) {
+      effect2.run();
+    }
+  }
+}
+function signal(initial) {
+  const node = new SignalNode(initial);
+  const sig = (value) => {
+    if (value !== void 0) {
+      node.set(value);
+      return value;
+    }
+    return node.get();
+  };
+  sig.peek = () => {
+    const prev = activeEffect;
+    activeEffect = null;
+    try {
+      return node.get();
+    } finally {
+      activeEffect = prev;
+    }
+  };
+  return sig;
+}
+function computed(fn) {
+  let value;
+  let depsVersion = 0;
+  let lastReadVersion = 0;
+  const subs = /* @__PURE__ */ new Set();
+  const effectNode = new EffectNode(() => {
+    depsVersion++;
+    for (const sub of subs) {
+      if (batchDepth > 0) {
+        pendingEffects.add(sub);
+      } else {
+        sub.run();
+      }
+    }
+  });
+  const prevEffect = activeEffect;
+  activeEffect = effectNode;
+  try {
+    value = fn();
+  } finally {
+    activeEffect = prevEffect;
+  }
+  lastReadVersion = depsVersion;
+  const sig = (val) => {
+    if (val !== void 0) {
+      throw new Error("Computed signals are read-only");
+    }
+    if (activeEffect) {
+      subs.add(activeEffect);
+    }
+    if (depsVersion > lastReadVersion) {
+      const prev = activeEffect;
+      activeEffect = effectNode;
+      try {
+        value = fn();
+      } finally {
+        activeEffect = prev;
+      }
+      lastReadVersion = depsVersion;
+    }
+    return value;
+  };
+  sig.peek = () => {
+    if (depsVersion > lastReadVersion) {
+      const prev = activeEffect;
+      activeEffect = null;
+      try {
+        value = fn();
+      } finally {
+        activeEffect = prev;
+      }
+      lastReadVersion = depsVersion;
+    }
+    return value;
+  };
+  return sig;
+}
+function effect(fn) {
+  const node = new EffectNode(fn);
+  node.run();
+  return () => {
+    if (node.cleanup) {
+      node.cleanup();
+      node.cleanup = void 0;
+    }
+    for (const dep of node.deps) {
+      dep.subs.delete(node);
+    }
+    node.deps.clear();
+  };
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      const effects = Array.from(pendingEffects);
+      pendingEffects.clear();
+      for (const eff of effects) {
+        eff.run();
+      }
+    }
+  }
+}
+function Portal({ children, target }) {
+  const container = typeof target === "string" ? document.querySelector(target) : target;
+  if (!container) {
+    console.warn("Portal target not found:", String(target));
+    return null;
+  }
+  const renderToPortal = () => {
+    container.innerHTML = "";
+    const vnode = typeof children === "function" ? children() : children;
+    if (Array.isArray(vnode)) {
+      vnode.forEach((node) => {
+        if (node instanceof Node) {
+          container.appendChild(node);
+        } else if (typeof node === "string" || typeof node === "number") {
+          container.appendChild(document.createTextNode(String(node)));
+        }
+      });
+    } else if (vnode instanceof Node) {
+      container.appendChild(vnode);
+    } else if (vnode != null) {
+      container.appendChild(document.createTextNode(String(vnode)));
+    }
+  };
+  if (typeof children === "function") {
+    effect(renderToPortal);
+  } else {
+    renderToPortal();
+  }
+  return null;
+}
+function h(type, props = null, ...children) {
+  if (typeof type === "function") {
+    return type({ ...props, children: children.length > 0 ? children.flat() : void 0 });
+  }
+  const el = document.createElement(type);
+  if (props) {
+    for (const [key, value] of Object.entries(props)) {
+      if (key.startsWith("on") && typeof value === "function") {
+        el.addEventListener(key.slice(2).toLowerCase(), value);
+      } else if (key === "className") {
+        el.className = value;
+      } else if (key === "style" && typeof value === "object") {
+        Object.assign(el.style, value);
+      } else if (key === "ref" && typeof value === "function") {
+        value(el);
+      } else if (typeof value !== "function") {
+        el.setAttribute(key, value);
+      }
+    }
+  }
+  const flatChildren = children.flat(Infinity);
+  for (const child of flatChildren) {
+    if (child != null) {
+      if (typeof child === "string" || typeof child === "number") {
+        el.appendChild(document.createTextNode(String(child)));
+      } else if (child instanceof Node) {
+        el.appendChild(child);
+      }
+    }
+  }
+  return el;
+}
+function text(signalOrValue) {
+  const node = document.createTextNode("");
+  if (typeof signalOrValue === "function") {
+    effect(() => {
+      node.textContent = String(signalOrValue());
+    });
+  } else {
+    node.textContent = String(signalOrValue);
+  }
+  return node;
+}
+function render(root, fn) {
+  let cleanup;
+  const run = () => {
+    cleanup == null ? void 0 : cleanup();
+    root.innerHTML = "";
+    const vnode = fn();
+    if (vnode instanceof Node) {
+      root.appendChild(vnode);
+    } else {
+      root.appendChild(document.createTextNode(String(vnode)));
+    }
+  };
+  const stop = effect(run);
+  cleanup = stop;
+  return stop;
+}
+function show(condition, fn) {
+  return condition() ? fn() : null;
+}
+function For(items, fn) {
+  const list = items();
+  return list.map((item, i) => fn(item, () => i));
+}
+const Fragment = ({ children }) => children;
+const tag = (name) => (props = null, ...children) => h(name, props, ...children);
+const div = tag("div");
+const span = tag("span");
+const button = tag("button");
+const input = tag("input");
+const p = tag("p");
+const h1 = tag("h1");
+const h2 = tag("h2");
+const h3 = tag("h3");
+function renderToString$1(vnode) {
+  if (vnode == null) return "";
+  if (typeof vnode === "string" || typeof vnode === "number") {
+    return String(vnode);
+  }
+  if (Array.isArray(vnode)) {
+    return vnode.map((v) => renderToString$1(v)).join("");
+  }
+  if (typeof vnode === "function") {
+    return renderToString$1(vnode());
+  }
+  if (typeof vnode === "object" && "nodeType" in vnode) {
+    const node = vnode;
+    if (node.nodeType === 1) {
+      return node.outerHTML || "";
+    }
+    return node.textContent || "";
+  }
+  if (typeof vnode === "object") {
+    return "";
+  }
+  return String(vnode);
+}
+function renderToStream$1(root, fn, options) {
+  const { chunkSize = 1e3, onChunk } = options || {};
+  let aborted = false;
+  const processChunk = (html2) => {
+    if (aborted) return;
+    root.write(html2);
+    onChunk == null ? void 0 : onChunk(html2);
+  };
+  const vnode = fn();
+  const html = renderToString$1(vnode);
+  if (html.length <= chunkSize) {
+    processChunk(html);
+  } else {
+    for (let i = 0; i < html.length; i += chunkSize) {
+      if (aborted) break;
+      processChunk(html.slice(i, i + chunkSize));
+    }
+  }
+  return {
+    abort: () => {
+      aborted = true;
+    }
+  };
+}
+async function renderAsync(vnode) {
+  const resolved = await vnode;
+  if (resolved == null) return "";
+  if (typeof resolved === "string" || typeof resolved === "number") {
+    return String(resolved);
+  }
+  if (Array.isArray(resolved)) {
+    const results = await Promise.all(resolved.map((v) => renderAsync(v)));
+    return results.join("");
+  }
+  if (resolved instanceof Node) {
+    return resolved instanceof Element ? resolved.outerHTML : resolved.textContent || "";
+  }
+  if (typeof resolved === "function") {
+    return renderAsync(resolved());
+  }
+  return "";
+}
+async function renderToStreamAsync(renderer, fn) {
+  try {
+    const vnode = await fn();
+    const html = await renderAsync(vnode);
+    renderer.write(html);
+    renderer.end();
+  } catch (err) {
+    renderer.fail(err);
+  }
+}
+function stream(fn, options) {
+  const { container, parseMarkdown = false, onComplete, onError } = options;
+  let aborted = false;
+  let content = "";
+  container.innerHTML = "";
+  const output = document.createElement("div");
+  output.className = "stream-output";
+  container.appendChild(output);
+  const update = () => {
+    output.innerHTML = parseMarkdown ? doParseMarkdown(content) : content;
+  };
+  const write = (chunk) => {
+    if (aborted) return;
+    content += chunk;
+    update();
+  };
+  write.clear = () => {
+    content = "";
+    update();
+  };
+  write.done = () => {
+    if (!aborted) onComplete == null ? void 0 : onComplete();
+  };
+  Promise.resolve().then(() => fn(write)).catch((err) => {
+    if (!aborted) onError == null ? void 0 : onError(err);
+  });
+  return {
+    abort: () => {
+      aborted = true;
+    }
+  };
+}
+function doParseMarkdown(text2) {
+  return text2.replace(/^### (.*$)/gim, "<h3>$1</h3>").replace(/^## (.*$)/gim, "<h2>$1</h2>").replace(/^# (.*$)/gim, "<h1>$1</h1>").replace(/\*\*(.*)\*\*/gim, "<strong>$1</strong>").replace(/\*(.*)\*/gim, "<em>$1</em>").replace(/`([^`]+)`/gim, "<code>$1</code>").replace(/\n/gim, "<br>");
+}
+function streamText(text2, options) {
+  const { container, speed = 30, onComplete } = options;
+  return stream(async (write) => {
+    for (let i = 0; i < text2.length; i++) {
+      await new Promise((r) => setTimeout(r, speed));
+      write(text2[i]);
+    }
+    write.done();
+  }, { container, onComplete });
+}
+class StreamRenderer {
+  constructor() {
+    __publicField(this, "chunks", []);
+    __publicField(this, "callbacks", []);
+    __publicField(this, "resolved", false);
+    __publicField(this, "error", null);
+  }
+  /**
+   * Write an HTML chunk
+   */
+  write(chunk) {
+    this.chunks.push(chunk);
+    this.callbacks.forEach((cb) => cb(chunk));
+  }
+  /**
+   * Complete stream rendering
+   */
+  end() {
+    this.resolved = true;
+  }
+  /**
+   * Throw error
+   */
+  fail(err) {
+    this.error = err;
+    this.resolved = true;
+  }
+  /**
+   * Subscribe to stream output
+   */
+  subscribe(callback) {
+    this.callbacks.push(callback);
+    this.chunks.forEach((chunk) => callback(chunk));
+    return () => {
+      const idx = this.callbacks.indexOf(callback);
+      if (idx !== -1) this.callbacks.splice(idx, 1);
+    };
+  }
+  /**
+   * Get complete HTML
+   */
+  getHTML() {
+    return this.chunks.join("");
+  }
+  /**
+   * Async iterator - for use with for await...of
+   */
+  async *[Symbol.asyncIterator]() {
+    let index = 0;
+    while (index < this.chunks.length || !this.resolved) {
+      if (index < this.chunks.length) {
+        yield this.chunks[index++];
+      } else {
+        await new Promise((resolve) => {
+          const check = () => {
+            if (index < this.chunks.length || this.resolved) {
+              resolve(void 0);
+            } else {
+              setTimeout(check, 10);
+            }
+          };
+          check();
+        });
+      }
+    }
+    if (this.error) {
+      throw this.error;
+    }
+  }
+}
+function createStreamHTML() {
+  const renderer = new StreamRenderer();
+  return {
+    renderer,
+    html: () => renderer.getHTML(),
+    stream: () => renderer[Symbol.asyncIterator]()
+  };
+}
+function Suspense({ fallback, children, onError }) {
+  const state = signal("pending");
+  const errorSig = signal(null);
+  return () => {
+    const s = state();
+    const err = errorSig();
+    if (s === "error") {
+      onError == null ? void 0 : onError(err);
+      return fallback;
+    }
+    if (s === "pending") {
+      return fallback;
+    }
+    return children();
+  };
+}
+function createSuspense({ fallback, children, onError }) {
+  const state = signal("pending");
+  const errorSig = signal(null);
+  const component = () => {
+    const s = state();
+    const err = errorSig();
+    if (s === "error") {
+      onError == null ? void 0 : onError(err);
+      return fallback;
+    }
+    if (s === "pending") {
+      return fallback;
+    }
+    return children();
+  };
+  return {
+    component,
+    setState: (newState, error) => {
+      state(newState);
+      if (error) errorSig(error);
+    },
+    getState: () => state()
+  };
+}
+function lazy(importFn) {
+  let loadedComponent = null;
+  let loadPromise = null;
+  const load = async () => {
+    if (loadedComponent) return loadedComponent;
+    if (loadPromise) return loadPromise;
+    loadPromise = importFn().then((mod) => {
+      loadedComponent = mod.default;
+      return loadedComponent;
+    });
+    return loadPromise;
+  };
+  return () => {
+    return {
+      load,
+      component: loadedComponent
+    };
+  };
+}
+function asyncComponent(importFn, fallback) {
+  const lazyFactory = lazy(importFn);
+  const state = signal("pending");
+  const component = signal(null);
+  lazyFactory().load().then((comp) => {
+    component(comp);
+    state("resolved");
+  }).catch((err) => {
+    console.error("Async component load failed:", err);
+    state("error");
+  });
+  return () => {
+    if (state() === "pending") {
+      return fallback;
+    }
+    if (state() === "error") {
+      return fallback;
+    }
+    const comp = component();
+    return comp ? comp() : fallback;
+  };
+}
+function createUpdate(id, html, type = "replace") {
+  return { id, html, type };
+}
+function applyUpdate(container, update) {
+  const { id, html, type } = update;
+  const element = container.querySelector(`[data-stream-id="${id}"]`);
+  switch (type) {
+    case "replace":
+      if (element) {
+        element.outerHTML = html;
+      } else {
+        const temp = document.createElement("div");
+        temp.innerHTML = html;
+        const newEl = temp.firstElementChild;
+        if (newEl) {
+          newEl.setAttribute("data-stream-id", id);
+          container.appendChild(newEl);
+        }
+      }
+      break;
+    case "append":
+      if (element) {
+        element.insertAdjacentHTML("beforeend", html);
+      }
+      break;
+    case "prepend":
+      if (element) {
+        element.insertAdjacentHTML("afterbegin", html);
+      }
+      break;
+    case "remove":
+      if (element) {
+        element.remove();
+      }
+      break;
+  }
+}
+function renderToStream(container, stream2) {
+  let aborted = false;
+  (async () => {
+    try {
+      for await (const chunk of stream2) {
+        if (aborted) break;
+        try {
+          const update = JSON.parse(chunk);
+          applyUpdate(container, update);
+        } catch {
+          container.insertAdjacentHTML("beforeend", chunk);
+        }
+      }
+    } catch (err) {
+      console.error("Stream rendering error:", err);
+    }
+  })();
+  return {
+    abort: () => {
+      aborted = true;
+    }
+  };
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function renderToString(vnode) {
+  if (vnode == null || vnode === false) return "";
+  if (typeof vnode === "string") {
+    return escapeHtml(vnode);
+  }
+  if (typeof vnode === "number") {
+    return String(vnode);
+  }
+  if (Array.isArray(vnode)) {
+    return vnode.map((v) => renderToString(v)).join("");
+  }
+  if (typeof vnode === "function") {
+    try {
+      const result = vnode();
+      return renderToString(result);
+    } catch (err) {
+      console.error("Component render error:", err);
+      return "<!-- Error -->";
+    }
+  }
+  return "";
+}
+function renderComponentToString(component) {
+  return renderToString(component());
+}
+function createPrefetchContext() {
+  const promises = [];
+  const errors = [];
+  return {
+    promises,
+    errors,
+    add: (promise) => {
+      promises.push(
+        promise.catch((err) => {
+          errors.push(err);
+          return null;
+        })
+      );
+    },
+    waitAll: async () => {
+      await Promise.all(promises);
+    }
+  };
+}
+async function prefetchAndRender(prefetchFn, renderFn) {
+  const ctx = createPrefetchContext();
+  ctx.add(prefetchFn());
+  await ctx.waitAll();
+  if (ctx.errors.length > 0) {
+    console.error("Prefetch errors:", ctx.errors);
+    return "<!-- Prefetch Error -->";
+  }
+  const data = await ctx.promises[0];
+  const component = renderFn(data);
+  return renderToString(component());
+}
+async function renderWithSuspense(component, options) {
+  const { fallback = "<!-- Loading -->", timeoutMs = 3e4 } = options || {};
+  const timeout = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error("SSR timeout")), timeoutMs);
+  });
+  const render2 = Promise.resolve().then(() => {
+    try {
+      return renderToString(component());
+    } catch (err) {
+      console.error("Suspense render error:", err);
+      return fallback;
+    }
+  });
+  try {
+    return await Promise.race([render2, timeout]);
+  } catch (err) {
+    console.error("Suspense timeout:", err);
+    return fallback;
+  }
+}
+async function renderSSR(component, options) {
+  const { includeState = false, state, timeoutMs } = options || {};
+  const errors = [];
+  let html;
+  try {
+    html = await renderWithSuspense(component, { timeoutMs });
+  } catch (err) {
+    errors.push(err);
+    html = "<!-- SSR Error -->";
+  }
+  const result = {
+    html,
+    errors
+  };
+  if (includeState && state) {
+    result.state = `<script>window.__QORE_STATE__ = ${JSON.stringify(state)}<\/script>`;
+  }
+  return result;
+}
+function VirtualList(props) {
+  const {
+    items,
+    itemHeight,
+    containerHeight,
+    renderItem,
+    overscan = 5,
+    onScroll,
+    onRangeChange,
+    className = "virtual-list",
+    getKey = (item, index) => index
+  } = props;
+  const isDynamicHeight = typeof itemHeight === "function";
+  const scrollTop = signal(0);
+  const totalHeight = computed(() => {
+    if (!isDynamicHeight) {
+      return items.length * itemHeight;
+    }
+    let height = 0;
+    for (let i = 0; i < items.length; i++) {
+      height += itemHeight(items[i], i);
+    }
+    return height;
+  });
+  const getItemHeight = (index) => {
+    if (!isDynamicHeight) {
+      return itemHeight;
+    }
+    return itemHeight(items[index], index);
+  };
+  const getItemOffset = (index) => {
+    if (!isDynamicHeight) {
+      return index * itemHeight;
+    }
+    let offset = 0;
+    for (let i = 0; i < index; i++) {
+      offset += getItemHeight(i);
+    }
+    return offset;
+  };
+  const findStartIndex = (scrollPos) => {
+    if (!isDynamicHeight) {
+      return Math.max(0, Math.floor(scrollPos / itemHeight));
+    }
+    let offset = 0;
+    for (let i = 0; i < items.length; i++) {
+      const height = getItemHeight(i);
+      if (offset + height > scrollPos) {
+        return i;
+      }
+      offset += height;
+    }
+    return items.length - 1;
+  };
+  const findEndIndex = (startIndex, scrollPos) => {
+    const viewportEnd = scrollPos + containerHeight;
+    if (!isDynamicHeight) {
+      return Math.min(
+        items.length - 1,
+        Math.ceil(viewportEnd / itemHeight)
+      );
+    }
+    let offset = getItemOffset(startIndex);
+    for (let i = startIndex; i < items.length; i++) {
+      const height = getItemHeight(i);
+      if (offset > viewportEnd) {
+        return i;
+      }
+      offset += height;
+    }
+    return items.length - 1;
+  };
+  const visibleRange = computed(() => {
+    const scrollPos = scrollTop();
+    let startIndex = findStartIndex(scrollPos);
+    let endIndex = findEndIndex(startIndex, scrollPos);
+    startIndex = Math.max(0, startIndex - overscan);
+    endIndex = Math.min(items.length - 1, endIndex + overscan);
+    return { startIndex, endIndex };
+  });
+  effect(() => {
+    const { startIndex, endIndex } = visibleRange();
+    onRangeChange == null ? void 0 : onRangeChange(startIndex, endIndex);
+  });
+  const handleScroll = (e) => {
+    const target = e.target;
+    const newScrollTop = target.scrollTop;
+    scrollTop(newScrollTop);
+    onScroll == null ? void 0 : onScroll(newScrollTop);
+  };
+  return () => {
+    const { startIndex, endIndex } = visibleRange();
+    const visibleItems = items.slice(startIndex, endIndex + 1);
+    const topSpacerHeight = getItemOffset(startIndex);
+    const bottomSpacerHeight = totalHeight() - getItemOffset(endIndex + 1);
+    return h("div", {
+      class: className,
+      style: {
+        height: containerHeight + "px",
+        overflowY: "auto",
+        position: "relative"
+      },
+      onscroll: handleScroll
+    }, [
+      // Top spacer
+      h("div", {
+        style: {
+          height: topSpacerHeight + "px",
+          flexShrink: 0
+        }
+      }),
+      // Visible items
+      ...visibleItems.map((item, i) => {
+        const index = startIndex + i;
+        const key = getKey(item, index);
+        const height = getItemHeight(index);
+        return h("div", {
+          key,
+          "data-index": index,
+          style: {
+            height: height + "px",
+            flexShrink: 0
+          }
+        }, [
+          renderItem(item, index)
+        ]);
+      }),
+      // Bottom spacer
+      h("div", {
+        style: {
+          height: Math.max(0, bottomSpacerHeight) + "px",
+          flexShrink: 0
+        }
+      })
+    ]);
+  };
+}
+function InfiniteList(props) {
+  const {
+    items,
+    itemHeight,
+    containerHeight,
+    renderItem,
+    onLoadMore,
+    hasMore,
+    loading = false,
+    loadingComponent = h("div", { class: "loading" }, "Loading..."),
+    endComponent = h("div", { class: "end" }, "No more items"),
+    ...listProps
+  } = props;
+  const isLoading = signal(loading);
+  const nearEnd = signal(false);
+  effect(() => {
+    if (nearEnd() && hasMore && !isLoading()) {
+      isLoading(true);
+      onLoadMore().finally(() => {
+        isLoading(false);
+      });
+    }
+  });
+  return () => {
+    const allItems = [...items];
+    if (isLoading()) {
+      allItems.push({ __loading: true });
+    }
+    if (!hasMore && !isLoading()) {
+      allItems.push({ __end: true });
+    }
+    const augmentedRenderItem = (item, index) => {
+      if (item.__loading) {
+        return loadingComponent;
+      }
+      if (item.__end) {
+        return endComponent;
+      }
+      return renderItem(item, index);
+    };
+    return h(VirtualList, {
+      ...listProps,
+      items: allItems,
+      itemHeight,
+      containerHeight,
+      renderItem: augmentedRenderItem,
+      onRangeChange: (start, end) => {
+        var _a;
+        const threshold = Math.floor(allItems.length * 0.8);
+        nearEnd(end >= threshold);
+        (_a = listProps.onRangeChange) == null ? void 0 : _a.call(listProps, start, end);
+      }
+    });
+  };
+}
+function FixedVirtualList(props) {
+  return VirtualList(props);
+}
+function VirtualGrid(props) {
+  const {
+    items,
+    itemWidth,
+    itemHeight,
+    containerWidth,
+    containerHeight,
+    renderItem,
+    gap = 0,
+    overscan = 2,
+    className = "virtual-grid"
+  } = props;
+  const columns = Math.floor(containerWidth / (itemWidth + gap));
+  const rows = Math.ceil(items.length / columns);
+  const scrollTop = signal(0);
+  const visibleRange = computed(() => {
+    const scrollPos = scrollTop();
+    const startRow = Math.max(0, Math.floor(scrollPos / itemHeight) - overscan);
+    const endRow = Math.min(rows - 1, Math.ceil((scrollPos + containerHeight) / itemHeight) + overscan);
+    return {
+      startRow,
+      endRow,
+      startIndex: startRow * columns,
+      endIndex: Math.min(items.length - 1, (endRow + 1) * columns - 1)
+    };
+  });
+  const handleScroll = (e) => {
+    const target = e.target;
+    scrollTop(target.scrollTop);
+  };
+  return () => {
+    const { startRow, startIndex, endIndex } = visibleRange();
+    const visibleItems = items.slice(startIndex, endIndex + 1);
+    const topSpacerHeight = startRow * itemHeight;
+    const bottomSpacerHeight = (rows - startRow - Math.ceil(visibleItems.length / columns)) * itemHeight;
+    return h("div", {
+      class: className,
+      style: {
+        width: containerWidth + "px",
+        height: containerHeight + "px",
+        overflowY: "auto",
+        position: "relative"
+      },
+      onscroll: handleScroll
+    }, [
+      h("div", {
+        style: {
+          height: topSpacerHeight + "px"
+        }
+      }),
+      h("div", {
+        style: {
+          display: "flex",
+          flexWrap: "wrap",
+          gap: gap + "px"
+        }
+      }, [
+        ...visibleItems.map((item, i) => {
+          const index = startIndex + i;
+          return h("div", {
+            key: index,
+            "data-index": index,
+            style: {
+              width: itemWidth + "px",
+              height: itemHeight + "px",
+              flexShrink: 0
+            }
+          }, [
+            renderItem(item, index)
+          ]);
+        })
+      ]),
+      h("div", {
+        style: {
+          height: Math.max(0, bottomSpacerHeight) + "px"
+        }
+      })
+    ]);
+  };
+}
+function createErrorBoundary() {
+  const state = signal({ hasError: false, error: null });
+  const handleError = (error) => {
+    state({ hasError: true, error });
+  };
+  const reset = () => {
+    state({ hasError: false, error: null });
+  };
+  return {
+    state,
+    handleError,
+    reset,
+    hasError: () => state().hasError,
+    error: () => state().error
+  };
+}
+function setupGlobalErrorHandler(onError) {
+  const handler = (event) => {
+    const error = event instanceof ErrorEvent ? event.error || new Error(event.message) : event.reason || new Error("Unhandled promise rejection");
+    onError(error);
+  };
+  window.addEventListener("error", handler);
+  window.addEventListener("unhandledrejection", handler);
+  return () => {
+    window.removeEventListener("error", handler);
+    window.removeEventListener("unhandledrejection", handler);
+  };
+}
+async function tryCatch(fn, onError) {
+  try {
+    return await fn();
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    onError == null ? void 0 : onError(err);
+    return null;
+  }
+}
+async function retry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    delay = 1e3,
+    backoff = 2,
+    onError
+  } = options;
+  let lastError = null;
+  let currentDelay = delay;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      onError == null ? void 0 : onError(lastError, attempt);
+      if (attempt < maxRetries) {
+        await new Promise((resolve) => setTimeout(resolve, currentDelay));
+        currentDelay *= backoff;
+      }
+    }
+  }
+  throw lastError;
+}
+function withErrorBoundary(Component, options = {}) {
+  return (props) => {
+    var _a;
+    const boundary = createErrorBoundary();
+    try {
+      return Component(props);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      boundary.handleError(err);
+      (_a = options.onError) == null ? void 0 : _a.call(options, err);
+      if (options.fallback) {
+        return options.fallback(err, boundary.reset);
+      }
+      return null;
+    }
+  };
+}
+function debounce(fn, delay) {
+  let timer = null;
+  return (...args) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), delay);
+  };
+}
+function throttle(fn, interval) {
+  let last = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (now - last >= interval) {
+      last = now;
+      fn(...args);
+    }
+  };
+}
+function cx(...classes) {
+  const result = [];
+  for (const cls of classes) {
+    if (!cls) continue;
+    if (typeof cls === "string") {
+      result.push(cls);
+    } else if (typeof cls === "object") {
+      for (const [key, value] of Object.entries(cls)) {
+        if (value) result.push(key);
+      }
+    }
+  }
+  return result.join(" ");
+}
+function style(...styles) {
+  const result = {};
+  for (const s of styles) {
+    if (!s) continue;
+    Object.assign(result, s);
+  }
+  return result;
+}
+function on(el, type, handler, options) {
+  el.addEventListener(type, handler, options);
+  return () => el.removeEventListener(type, handler, options);
+}
+const onEvent = {
+  click: (handler) => ({ onClick: handler }),
+  change: (handler) => ({ onChange: handler }),
+  input: (handler) => ({ onInput: handler }),
+  submit: (handler) => ({ onSubmit: handler }),
+  keydown: (handler) => ({ onKeyDown: handler }),
+  keyup: (handler) => ({ onKeyUp: handler }),
+  focus: (handler) => ({ onFocus: handler }),
+  blur: (handler) => ({ onBlur: handler }),
+  mouseenter: (handler) => ({ onMouseEnter: handler }),
+  mouseleave: (handler) => ({ onMouseLeave: handler })
+};
+function preventDefault(handler) {
+  return (e) => {
+    e.preventDefault();
+    handler(e);
+  };
+}
+function stopPropagation(handler) {
+  return (e) => {
+    e.stopPropagation();
+    handler(e);
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  FixedVirtualList,
+  For,
+  Fragment,
+  InfiniteList,
+  Portal,
+  StreamRenderer,
+  Suspense,
+  VirtualGrid,
+  VirtualList,
+  applyUpdate,
+  asyncComponent,
+  batch,
+  button,
+  computed,
+  createErrorBoundary,
+  createPrefetchContext,
+  createStreamHTML,
+  createSuspense,
+  createUpdate,
+  cx,
+  debounce,
+  div,
+  effect,
+  h,
+  h1,
+  h2,
+  h3,
+  input,
+  lazy,
+  on,
+  onEvent,
+  p,
+  prefetchAndRender,
+  preventDefault,
+  render,
+  renderAsync,
+  renderComponentToString,
+  renderSSR,
+  renderToStreamAsync,
+  renderToStream$1 as renderToStreamDOM,
+  renderToStream as renderToStreamIncremental,
+  renderToString$1 as renderToString,
+  retry,
+  setupGlobalErrorHandler,
+  show,
+  signal,
+  sleep,
+  span,
+  stopPropagation,
+  stream,
+  streamText,
+  style,
+  text,
+  throttle,
+  tryCatch,
+  withErrorBoundary
+};
+//# sourceMappingURL=index.js.map