sibujs 1.5.0 → 2.0.0

package/dist/chunk-MYRV7VDM.js

@@ -1,742 +0,0 @@
-import {
-  div,
-  span
-} from "./chunk-P3XWXJZU.js";
-import {
-  sanitizeUrl
-} from "./chunk-CMBFNA7L.js";
-import {
-  effect
-} from "./chunk-VQNQZCWJ.js";
-import {
-  batch,
-  signal
-} from "./chunk-NZIIMDWI.js";
-
-// src/platform/head.ts
-var HEAD_URL_ATTRS = /* @__PURE__ */ new Set(["href", "src"]);
-function sanitizeHeadAttr(key, value) {
-  if (HEAD_URL_ATTRS.has(key)) return sanitizeUrl(value);
-  return value;
-}
-function isDangerousMetaRefresh(metaProps) {
-  const httpEquiv = metaProps["http-equiv"];
-  if (typeof httpEquiv !== "string") return false;
-  if (httpEquiv.toLowerCase() !== "refresh") return false;
-  const content = metaProps.content;
-  if (typeof content !== "string") return false;
-  const normalized = content.replace(/[\x00-\x20\x7f-\x9f]+/g, "").toLowerCase();
-  return normalized.includes("url=javascript:") || normalized.includes("url=data:") || normalized.includes("url=vbscript:") || normalized.includes("url=blob:");
-}
-var SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-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 isSafeHeadAttr(name) {
-  if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
-  if (isEventHandlerAttr(name)) return false;
-  return true;
-}
-function escapeScriptJsonLocal(json) {
-  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function Head(props) {
-  const anchor = document.createComment("sibu-head");
-  const managedElements = [];
-  const effectCleanups = [];
-  const cleanup = () => {
-    for (const el of managedElements) {
-      if (el.parentNode) el.parentNode.removeChild(el);
-    }
-    managedElements.length = 0;
-    for (const cleanupFn of effectCleanups) cleanupFn();
-    effectCleanups.length = 0;
-  };
-  const apply = () => {
-    cleanup();
-    if (props.title) {
-      if (typeof props.title === "function") {
-        const cleanupFn = effect(() => {
-          document.title = props.title();
-        });
-        effectCleanups.push(cleanupFn);
-      } else {
-        document.title = props.title;
-      }
-    }
-    if (props.meta) {
-      for (const metaProps of props.meta) {
-        if (isDangerousMetaRefresh(metaProps)) continue;
-        const el = document.createElement("meta");
-        for (const [key, value] of Object.entries(metaProps)) {
-          if (!isSafeHeadAttr(key)) continue;
-          if (typeof value === "function") {
-            const cleanupFn = effect(() => {
-              el.setAttribute(key, sanitizeHeadAttr(key, value()));
-            });
-            effectCleanups.push(cleanupFn);
-          } else {
-            el.setAttribute(key, sanitizeHeadAttr(key, value));
-          }
-        }
-        document.head.appendChild(el);
-        managedElements.push(el);
-      }
-    }
-    if (props.link) {
-      for (const linkProps of props.link) {
-        const el = document.createElement("link");
-        for (const [key, value] of Object.entries(linkProps)) {
-          if (!isSafeHeadAttr(key)) continue;
-          el.setAttribute(key, sanitizeHeadAttr(key, value));
-        }
-        document.head.appendChild(el);
-        managedElements.push(el);
-      }
-    }
-    if (props.script) {
-      for (const scriptProps of props.script) {
-        const el = document.createElement("script");
-        for (const [key, value] of Object.entries(scriptProps)) {
-          if (!isSafeHeadAttr(key)) continue;
-          el.setAttribute(key, sanitizeHeadAttr(key, value));
-        }
-        document.head.appendChild(el);
-        managedElements.push(el);
-      }
-    }
-    if (props.base) {
-      const existing = document.head.querySelector("base");
-      if (existing) existing.remove();
-      const el = document.createElement("base");
-      if (props.base.href) {
-        const safeHref = sanitizeUrl(props.base.href);
-        if (safeHref) el.href = safeHref;
-      }
-      if (props.base.target) el.target = props.base.target;
-      document.head.appendChild(el);
-      managedElements.push(el);
-    }
-  };
-  apply();
-  return anchor;
-}
-function setStructuredData(data) {
-  const existing = document.head.querySelector('script[type="application/ld+json"][data-sibu]');
-  if (existing) existing.remove();
-  const script = document.createElement("script");
-  script.type = "application/ld+json";
-  script.setAttribute("data-sibu", "true");
-  script.textContent = escapeScriptJsonLocal(JSON.stringify(data));
-  document.head.appendChild(script);
-}
-function setCanonical(url) {
-  let link = document.head.querySelector('link[rel="canonical"]');
-  if (!link) {
-    link = document.createElement("link");
-    link.rel = "canonical";
-    document.head.appendChild(link);
-  }
-  link.href = sanitizeUrl(url);
-}
-
-// src/platform/worker.ts
-function worker(workerFn2) {
-  const [result, setResult] = signal(null);
-  const [error, setError] = signal(null);
-  const [loading, setLoading] = signal(false);
-  let worker2 = null;
-  try {
-    if (typeof Worker === "undefined") {
-      throw new Error("Web Workers are not supported in this environment");
-    }
-    const fnBody = workerFn2.toString();
-    const blob = new Blob([`self.onmessage = ${fnBody};`], { type: "application/javascript" });
-    const url = URL.createObjectURL(blob);
-    worker2 = new Worker(url);
-    URL.revokeObjectURL(url);
-    worker2.onmessage = (e) => {
-      setResult(e.data);
-      setLoading(false);
-    };
-    worker2.onerror = (e) => {
-      setError(new Error(e.message || "Worker error"));
-      setLoading(false);
-    };
-  } catch (err) {
-    setError(err instanceof Error ? err : new Error(String(err)));
-  }
-  function post(data) {
-    if (!worker2) return;
-    setLoading(true);
-    setError(null);
-    setResult(null);
-    worker2.postMessage(data);
-  }
-  function terminate() {
-    if (!worker2) return;
-    worker2.terminate();
-    worker2 = null;
-    setLoading(false);
-  }
-  return { post, result, error, loading, terminate };
-}
-function workerFn(fn) {
-  const [loading, setLoading] = signal(false);
-  let worker2 = null;
-  try {
-    if (typeof Worker === "undefined") {
-      throw new Error("Web Workers are not supported in this environment");
-    }
-    const fnStr = fn.toString();
-    const blob = new Blob(
-      [
-        `self.onmessage = function(e) {
-  var fn = ${fnStr};
-  var result = fn.apply(null, e.data);
-  postMessage(result);
-};`
-      ],
-      { type: "application/javascript" }
-    );
-    const url = URL.createObjectURL(blob);
-    worker2 = new Worker(url);
-    URL.revokeObjectURL(url);
-  } catch {
-  }
-  function run(...args) {
-    return new Promise((resolve, reject) => {
-      if (!worker2) {
-        reject(new Error("Worker is not available"));
-        return;
-      }
-      setLoading(true);
-      worker2.onmessage = (e) => {
-        setLoading(false);
-        resolve(e.data);
-      };
-      worker2.onerror = (e) => {
-        setLoading(false);
-        reject(new Error(e.message || "Worker error"));
-      };
-      worker2.postMessage(args);
-    });
-  }
-  function terminate() {
-    if (!worker2) return;
-    worker2.terminate();
-    worker2 = null;
-    setLoading(false);
-  }
-  return { run, loading, terminate };
-}
-function createWorkerPool(workerFn2, poolSize) {
-  const size = poolSize || typeof navigator !== "undefined" && navigator.hardwareConcurrency || 4;
-  const workers = [];
-  let currentIndex = 0;
-  let alive = true;
-  try {
-    if (typeof Worker === "undefined") {
-      throw new Error("Web Workers are not supported in this environment");
-    }
-    const fnBody = workerFn2.toString();
-    const blob = new Blob([`self.onmessage = ${fnBody};`], { type: "application/javascript" });
-    const url = URL.createObjectURL(blob);
-    for (let i = 0; i < size; i++) {
-      workers.push(new Worker(url));
-    }
-    URL.revokeObjectURL(url);
-  } catch {
-  }
-  function execute(data) {
-    return new Promise((resolve, reject) => {
-      if (!alive || workers.length === 0) {
-        reject(new Error("Worker pool is not available"));
-        return;
-      }
-      const worker2 = workers[currentIndex % workers.length];
-      currentIndex++;
-      worker2.onmessage = (e) => {
-        resolve(e.data);
-      };
-      worker2.onerror = (e) => {
-        reject(new Error(e.message || "Worker error"));
-      };
-      worker2.postMessage(data);
-    });
-  }
-  function terminate() {
-    alive = false;
-    for (const w of workers) {
-      w.terminate();
-    }
-    workers.length = 0;
-  }
-  return { execute, terminate };
-}
-
-// src/platform/wasm.ts
-var moduleCache = /* @__PURE__ */ new Map();
-var instanceCache = /* @__PURE__ */ new Map();
-function wasm(source, config = {}) {
-  const [instance, setInstance] = signal(null);
-  const [loading, setLoading] = signal(true);
-  const [error, setError] = signal(null);
-  const cacheKey = config.cacheKey || (typeof source === "string" ? source : void 0);
-  async function load() {
-    setLoading(true);
-    setError(null);
-    setInstance(null);
-    try {
-      const wasmInstance = await loadWasmModule(source, config.imports, cacheKey);
-      setInstance(wasmInstance.exports);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error(String(err)));
-    } finally {
-      setLoading(false);
-    }
-  }
-  load();
-  return {
-    instance,
-    loading,
-    error,
-    ready: () => instance() !== null,
-    reload: load
-  };
-}
-async function loadWasmModule(source, imports, cacheKey) {
-  const key = cacheKey || (typeof source === "string" ? source : void 0);
-  if (key) {
-    const cachedInstance = instanceCache.get(key);
-    if (cachedInstance) {
-      return cachedInstance;
-    }
-  }
-  let module;
-  const cachedModule = key ? moduleCache.get(key) : void 0;
-  if (cachedModule) {
-    module = cachedModule;
-  } else {
-    let bytes;
-    if (typeof source === "string") {
-      if (typeof WebAssembly.instantiateStreaming === "function") {
-        const response2 = fetch(source);
-        const result = await WebAssembly.instantiateStreaming(response2, imports || {});
-        if (key) {
-          moduleCache.set(key, result.module);
-          instanceCache.set(key, result.instance);
-        }
-        return result.instance;
-      }
-      const response = await fetch(source);
-      bytes = await response.arrayBuffer();
-    } else if (source instanceof Uint8Array) {
-      bytes = source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
-    } else {
-      bytes = source;
-    }
-    module = await WebAssembly.compile(bytes);
-    if (key) moduleCache.set(key, module);
-  }
-  const instance = await WebAssembly.instantiate(module, imports || {});
-  if (key) instanceCache.set(key, instance);
-  return instance;
-}
-async function preloadWasm(url) {
-  if (moduleCache.has(url)) return;
-  let module;
-  if (typeof WebAssembly.compileStreaming === "function") {
-    module = await WebAssembly.compileStreaming(fetch(url));
-  } else {
-    const response = await fetch(url);
-    const bytes = await response.arrayBuffer();
-    module = await WebAssembly.compile(bytes);
-  }
-  moduleCache.set(url, module);
-}
-function createWasmBridge(instance) {
-  const exports = instance.exports;
-  const memory = exports.memory || instance.exports.memory;
-  return {
-    exports: instance.exports,
-    memory,
-    alloc(size) {
-      if (!exports.malloc) throw new Error("WASM module does not export malloc");
-      return exports.malloc(size);
-    },
-    free(ptr) {
-      if (!exports.free) throw new Error("WASM module does not export free");
-      exports.free(ptr);
-    },
-    writeString(str) {
-      const encoder = new TextEncoder();
-      const bytes = encoder.encode(str);
-      if (!exports.malloc) throw new Error("WASM module does not export malloc");
-      const ptr = exports.malloc(bytes.length);
-      new Uint8Array(memory.buffer, ptr, bytes.length).set(bytes);
-      return { ptr, len: bytes.length };
-    },
-    readString(ptr, len) {
-      const decoder = new TextDecoder();
-      return decoder.decode(new Uint8Array(memory.buffer, ptr, len));
-    },
-    writeArray(arr) {
-      if (!exports.malloc) throw new Error("WASM module does not export malloc");
-      const ptr = exports.malloc(arr.length * 8);
-      new Float64Array(memory.buffer, ptr, arr.length).set(Array.from(arr));
-      return { ptr, len: arr.length };
-    },
-    readF64Array(ptr, len) {
-      return new Float64Array(memory.buffer, ptr, len);
-    }
-  };
-}
-function clearWasmCache() {
-  moduleCache.clear();
-  instanceCache.clear();
-}
-function isWasmCached(key) {
-  return moduleCache.has(key);
-}
-
-// src/platform/microfrontend.ts
-var moduleCache2 = /* @__PURE__ */ new Map();
-function createMicroApp(config) {
-  const host = config.container ?? document.createElement("div");
-  host.setAttribute("data-micro-app", config.name);
-  let root;
-  if (config.shadow) {
-    root = host.attachShadow({ mode: "open" });
-  } else {
-    root = host;
-  }
-  let mounted = false;
-  function mount(component) {
-    if (root instanceof ShadowRoot) {
-      root.innerHTML = "";
-    } else {
-      while (root.firstChild) {
-        root.removeChild(root.firstChild);
-      }
-    }
-    const el = component();
-    root.appendChild(el);
-    mounted = true;
-  }
-  function unmount() {
-    if (!mounted) return;
-    if (root instanceof ShadowRoot) {
-      root.innerHTML = "";
-    } else {
-      while (root.firstChild) {
-        root.removeChild(root.firstChild);
-      }
-    }
-    mounted = false;
-  }
-  return { mount, unmount, element: host };
-}
-function loadRemoteModule(url) {
-  const cached = moduleCache2.get(url);
-  if (cached) return cached;
-  const promise = import(
-    /* @vite-ignore */
-    url
-  );
-  moduleCache2.set(url, promise);
-  promise.catch(() => {
-    moduleCache2.delete(url);
-  });
-  return promise;
-}
-function defineRemoteComponent(name, loader) {
-  let cached = null;
-  return function RemoteComponent() {
-    if (cached) {
-      return cached();
-    }
-    const container = div({
-      class: "sibu-remote",
-      "data-remote-component": name
-    });
-    container.appendChild(span({ class: "sibu-remote-loading", nodes: "Loading..." }));
-    loader().then((mod) => {
-      cached = mod.default;
-      const rendered = cached();
-      container.replaceChildren(rendered);
-    }).catch((err) => {
-      const message = err instanceof Error ? err.message : String(err);
-      container.replaceChildren(
-        div({
-          class: "sibu-remote-error",
-          nodes: `Failed to load remote component "${name}": ${message}`
-        })
-      );
-    });
-    return container;
-  };
-}
-function createSharedScope(initialState) {
-  const signals = /* @__PURE__ */ new Map();
-  const subscribers = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(initialState)) {
-    const [get2, set2] = signal(initialState[key]);
-    signals.set(key, { get: get2, set: set2 });
-    subscribers.set(key, /* @__PURE__ */ new Set());
-  }
-  function ensureSignal(key) {
-    if (!signals.has(key)) {
-      const [get2, set2] = signal(void 0);
-      signals.set(key, { get: get2, set: set2 });
-      subscribers.set(key, /* @__PURE__ */ new Set());
-    }
-  }
-  function get(key) {
-    ensureSignal(key);
-    return signals.get(key)?.get();
-  }
-  function set(key, value) {
-    ensureSignal(key);
-    signals.get(key)?.set(value);
-    const subs = subscribers.get(key);
-    if (subs) {
-      for (const cb of subs) {
-        cb(value);
-      }
-    }
-  }
-  function subscribe(key, callback) {
-    ensureSignal(key);
-    const subs = subscribers.get(key);
-    if (!subs) {
-      return () => {
-      };
-    }
-    subs.add(callback);
-    return () => {
-      subs.delete(callback);
-    };
-  }
-  return { get, set, subscribe };
-}
-
-// src/platform/serviceWorker.ts
-function serviceWorker(scriptUrl, options) {
-  const [registration, setRegistration] = signal(null);
-  const [isReady, setIsReady] = signal(false);
-  const [isUpdateAvailable, setIsUpdateAvailable] = signal(false);
-  const [error, setError] = signal(null);
-  if ("serviceWorker" in navigator) {
-    navigator.serviceWorker.register(scriptUrl, options).then((reg) => {
-      setRegistration(reg);
-      setIsReady(true);
-      reg.addEventListener("updatefound", () => {
-        const newWorker = reg.installing;
-        if (newWorker) {
-          newWorker.addEventListener("statechange", () => {
-            if (newWorker.state === "installed" && navigator.serviceWorker.controller) {
-              setIsUpdateAvailable(true);
-            }
-          });
-        }
-      });
-    }).catch((err) => {
-      setError(err instanceof Error ? err : new Error(String(err)));
-    });
-  }
-  async function update() {
-    const reg = registration();
-    if (reg) {
-      await reg.update();
-    }
-  }
-  async function unregister() {
-    const reg = registration();
-    if (reg) {
-      const result = await reg.unregister();
-      if (result) {
-        setRegistration(null);
-        setIsReady(false);
-      }
-      return result;
-    }
-    return false;
-  }
-  return { registration, isReady, isUpdateAvailable, error, update, unregister };
-}
-
-// src/platform/staticSiteGenerator.ts
-async function generateStaticSite(options) {
-  const { routes, renderFn } = options;
-  const pages = [];
-  const errors = [];
-  for (const route of routes) {
-    try {
-      const html = await renderFn(route);
-      pages.push({ path: route, html });
-    } catch (err) {
-      errors.push({
-        path: route,
-        error: err instanceof Error ? err : new Error(String(err))
-      });
-    }
-  }
-  return { pages, errors };
-}
-
-// src/platform/incrementalRegeneration.ts
-function createISR(options) {
-  const { revalidateAfter, fetcher, initialData } = options;
-  const [data, setData] = signal(initialData);
-  const [timestamp, setTimestamp] = signal(initialData !== void 0 ? Date.now() : 0);
-  const isStale = () => {
-    const ts = timestamp();
-    if (ts === 0) return true;
-    return Date.now() - ts >= revalidateAfter;
-  };
-  const revalidate = async () => {
-    const result = await fetcher();
-    setData(result);
-    setTimestamp(Date.now());
-  };
-  if (initialData === void 0) {
-    revalidate();
-  }
-  const intervalId = setInterval(() => {
-    revalidate();
-  }, revalidateAfter);
-  const dispose = () => {
-    clearInterval(intervalId);
-  };
-  return { data, isStale, revalidate, dispose };
-}
-
-// src/platform/routeActions.ts
-function createAction(actionFn) {
-  const [data, setData] = signal(void 0);
-  const [error, setError] = signal(void 0);
-  const [loading, setLoading] = signal(false);
-  const submit = async (input) => {
-    batch(() => {
-      setLoading(true);
-      setError(void 0);
-    });
-    try {
-      const result = await actionFn(input);
-      batch(() => {
-        setData(result);
-        setLoading(false);
-      });
-      return result;
-    } catch (err) {
-      const actionError = err instanceof Error ? err : new Error(String(err));
-      batch(() => {
-        setError(actionError);
-        setLoading(false);
-      });
-      throw actionError;
-    }
-  };
-  return { data, error, loading, submit };
-}
-
-// src/platform/scrollRestoration.ts
-function scrollRestoration(options) {
-  const mode = options?.mode ?? "auto";
-  const positions = /* @__PURE__ */ new Map();
-  let popstateHandler = null;
-  let currentKey = null;
-  const save = (key) => {
-    positions.set(key, {
-      x: window.scrollX,
-      y: window.scrollY
-    });
-    currentKey = key;
-  };
-  const restore = (key) => {
-    const pos = positions.get(key);
-    if (pos) {
-      window.scrollTo(pos.x, pos.y);
-    }
-    currentKey = key;
-  };
-  const getPosition = (key) => {
-    return positions.get(key);
-  };
-  if (mode === "auto") {
-    popstateHandler = () => {
-      if (currentKey) {
-        save(currentKey);
-      }
-    };
-    window.addEventListener("popstate", popstateHandler);
-  }
-  const dispose = () => {
-    if (popstateHandler) {
-      window.removeEventListener("popstate", popstateHandler);
-      popstateHandler = null;
-    }
-    positions.clear();
-  };
-  return { save, restore, getPosition, dispose };
-}
-
-// src/platform/routeMiddleware.ts
-function composeMiddleware(...fns) {
-  return async (context, next) => {
-    let index = -1;
-    const dispatch = async (i) => {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      if (i < fns.length) {
-        await fns[i](context, () => dispatch(i + 1));
-      } else {
-        await next();
-      }
-    };
-    await dispatch(0);
-  };
-}
-function createMiddlewareChain() {
-  const middlewares = [];
-  const use = (fn) => {
-    middlewares.push(fn);
-  };
-  const run = async (context) => {
-    const composed = composeMiddleware(...middlewares);
-    await composed(context, () => {
-    });
-  };
-  return { use, run };
-}
-
-export {
-  Head,
-  setStructuredData,
-  setCanonical,
-  worker,
-  workerFn,
-  createWorkerPool,
-  wasm,
-  loadWasmModule,
-  preloadWasm,
-  createWasmBridge,
-  clearWasmCache,
-  isWasmCached,
-  createMicroApp,
-  loadRemoteModule,
-  defineRemoteComponent,
-  createSharedScope,
-  serviceWorker,
-  generateStaticSite,
-  createISR,
-  createAction,
-  scrollRestoration,
-  composeMiddleware,
-  createMiddlewareChain
-};