sibujs 1.0.2 → 1.0.4

package/dist/chunk-JLOASJXU.js

@@ -1,654 +0,0 @@
-import {
-  signal
-} from "./chunk-K7JUDY3C.js";
-
-// src/performance/scheduler.ts
-var Priority = {
-  IMMEDIATE: 0,
-  USER_BLOCKING: 1,
-  NORMAL: 2,
-  LOW: 3,
-  IDLE: 4
-};
-var taskIdCounter = 0;
-var taskQueue = [];
-var isProcessing = false;
-var frameId = null;
-function insertTask(task) {
-  let i = taskQueue.length;
-  while (i > 0 && taskQueue[i - 1].priority > task.priority) {
-    i--;
-  }
-  taskQueue.splice(i, 0, task);
-}
-function processQueue() {
-  if (isProcessing || taskQueue.length === 0) return;
-  isProcessing = true;
-  const startTime = performance.now();
-  const timeSlice = 5;
-  while (taskQueue.length > 0) {
-    const task = taskQueue[0];
-    if (task.cancelled) {
-      taskQueue.shift();
-      continue;
-    }
-    if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
-      break;
-    }
-    taskQueue.shift();
-    try {
-      task.callback();
-    } catch (e) {
-      console.error("[Scheduler] Task error:", e);
-    }
-  }
-  isProcessing = false;
-  if (taskQueue.length > 0) {
-    scheduleFrame();
-  }
-}
-function scheduleFrame() {
-  if (frameId !== null) return;
-  const nextTask = taskQueue.find((t) => !t.cancelled);
-  if (!nextTask) return;
-  if (nextTask.priority <= Priority.USER_BLOCKING) {
-    queueMicrotask(() => {
-      frameId = null;
-      processQueue();
-    });
-    frameId = -1;
-  } else if (nextTask.priority === Priority.IDLE) {
-    if (typeof requestIdleCallback !== "undefined") {
-      frameId = requestIdleCallback(() => {
-        frameId = null;
-        processQueue();
-      });
-    } else {
-      frameId = setTimeout(() => {
-        frameId = null;
-        processQueue();
-      }, 50);
-    }
-  } else {
-    frameId = requestAnimationFrame(() => {
-      frameId = null;
-      processQueue();
-    });
-  }
-}
-function scheduleUpdate(priority, callback) {
-  const task = {
-    id: taskIdCounter++,
-    priority,
-    callback,
-    cancelled: false
-  };
-  if (priority === Priority.IMMEDIATE) {
-    try {
-      callback();
-    } catch (e) {
-      console.error("[Scheduler] Immediate task error:", e);
-    }
-    return () => {
-    };
-  }
-  insertTask(task);
-  scheduleFrame();
-  return () => {
-    task.cancelled = true;
-  };
-}
-function flushScheduler() {
-  while (taskQueue.length > 0) {
-    const task = taskQueue.shift();
-    if (!task) break;
-    if (!task.cancelled) {
-      task.callback();
-    }
-  }
-  isProcessing = false;
-  frameId = null;
-}
-function pendingTasks() {
-  return taskQueue.filter((t) => !t.cancelled).length;
-}
-function yieldToMain() {
-  if (typeof globalThis !== "undefined" && "scheduler" in globalThis && typeof globalThis.scheduler?.yield === "function") {
-    return globalThis.scheduler.yield();
-  }
-  return new Promise((resolve) => {
-    setTimeout(resolve, 0);
-  });
-}
-async function processInChunks(items, processor, chunkSize = 50) {
-  for (let i = 0; i < items.length; i++) {
-    processor(items[i], i);
-    if (i > 0 && i % chunkSize === 0) {
-      await yieldToMain();
-    }
-  }
-}
-
-// src/performance/concurrent.ts
-function startTransition(callback) {
-  scheduleUpdate(Priority.NORMAL, callback);
-}
-function deferredValue(getter) {
-  const [deferred, setDeferred] = signal(getter());
-  const sync = () => {
-    const current = getter();
-    setDeferred(current);
-  };
-  scheduleUpdate(Priority.LOW, sync);
-  return () => {
-    scheduleUpdate(Priority.LOW, sync);
-    return deferred();
-  };
-}
-function transitionState() {
-  const [isPending, setIsPending] = signal(false);
-  function transition(callback) {
-    setIsPending(true);
-    scheduleUpdate(Priority.NORMAL, () => {
-      callback();
-      scheduleUpdate(Priority.NORMAL, () => {
-        setIsPending(false);
-      });
-    });
-  }
-  return [isPending, transition];
-}
-var idCounter = 0;
-var idPrefix = "sibu";
-function resetIdCounter() {
-  idCounter = 0;
-}
-function setIdPrefix(prefix) {
-  idPrefix = prefix;
-}
-function uniqueId(suffix) {
-  const id = `${idPrefix}-${idCounter++}`;
-  return suffix ? `${id}-${suffix}` : id;
-}
-
-// src/performance/domRecycler.ts
-var DOMPool = class {
-  constructor(maxSize = 50) {
-    this.pools = /* @__PURE__ */ new Map();
-    this.maxSize = maxSize;
-  }
-  /**
-   * Get a recycled element or create a new one.
-   */
-  acquire(tag) {
-    const pool = this.pools.get(tag);
-    if (pool && pool.length > 0) {
-      const el = pool.pop();
-      return el;
-    }
-    return document.createElement(tag);
-  }
-  /**
-   * Return an element to the pool for reuse.
-   * Clears attributes, children, and event listeners.
-   */
-  release(element) {
-    const tag = element.tagName.toLowerCase();
-    let pool = this.pools.get(tag);
-    if (!pool) {
-      pool = [];
-      this.pools.set(tag, pool);
-    }
-    if (pool.length >= this.maxSize) return;
-    element.innerHTML = "";
-    element.className = "";
-    element.removeAttribute("style");
-    element.removeAttribute("id");
-    const attrs = Array.from(element.attributes);
-    for (const attr of attrs) {
-      element.removeAttribute(attr.name);
-    }
-    const clean = element.cloneNode(false);
-    pool.push(clean);
-  }
-  /**
-   * Clear all pools.
-   */
-  clear() {
-    this.pools.clear();
-  }
-  /**
-   * Get pool statistics.
-   */
-  stats() {
-    const result = {};
-    for (const [tag, pool] of this.pools) {
-      result[tag] = pool.length;
-    }
-    return result;
-  }
-};
-var domPool = new DOMPool();
-var preloadedResources = /* @__PURE__ */ new Set();
-function preloadResource(url, type = "fetch") {
-  if (preloadedResources.has(url)) return;
-  preloadedResources.add(url);
-  const link = document.createElement("link");
-  link.rel = "preload";
-  link.href = url;
-  switch (type) {
-    case "script":
-      link.setAttribute("as", "script");
-      break;
-    case "style":
-      link.setAttribute("as", "style");
-      break;
-    case "image":
-      link.setAttribute("as", "image");
-      break;
-    default:
-      link.setAttribute("as", "fetch");
-      link.setAttribute("crossorigin", "anonymous");
-  }
-  document.head.appendChild(link);
-}
-function prefetch(url) {
-  if (preloadedResources.has(url)) return;
-  preloadedResources.add(url);
-  const link = document.createElement("link");
-  link.rel = "prefetch";
-  link.href = url;
-  document.head.appendChild(link);
-}
-function preloadImage(src) {
-  return new Promise((resolve, reject) => {
-    const img = new Image();
-    img.onload = () => resolve(img);
-    img.onerror = reject;
-    img.src = src;
-  });
-}
-
-// src/performance/bundleOptimize.ts
-function pure(fn) {
-  return fn();
-}
-function conditional(condition, loader) {
-  if (condition) return loader();
-  return void 0;
-}
-var Features = {
-  SSR: typeof window === "undefined",
-  DEV: typeof process !== "undefined" && process.env?.NODE_ENV !== "production",
-  BROWSER: typeof window !== "undefined"
-};
-function devOnly(fn) {
-  if (typeof process !== "undefined" && process.env?.NODE_ENV !== "production") {
-    fn();
-  }
-}
-function noSideEffect(fn) {
-  return fn;
-}
-
-// src/performance/compiled.ts
-function staticTemplate(html) {
-  const template = document.createElement("template");
-  template.innerHTML = html.trim();
-  return template.content.firstElementChild;
-}
-function cloneTemplate(template) {
-  return template.content.cloneNode(true);
-}
-function precompile(templateHtml, hydrate) {
-  const tpl = document.createElement("template");
-  tpl.innerHTML = templateHtml.trim();
-  return (props) => {
-    const el = tpl.content.firstElementChild?.cloneNode(true);
-    hydrate(el, props);
-    return el;
-  };
-}
-function hoistable(value) {
-  return value;
-}
-function block(factory) {
-  return factory();
-}
-
-// src/performance/normalize.ts
-function normalizedStore(schema) {
-  const idKey = schema.idKey || "id";
-  const [getState, setState] = signal({
-    ids: [],
-    entities: {}
-  });
-  function add(entity) {
-    const id = String(entity[idKey]);
-    setState((prev) => {
-      const ids = prev.ids.includes(id) ? prev.ids : [...prev.ids, id];
-      return {
-        ids,
-        entities: { ...prev.entities, [id]: entity }
-      };
-    });
-  }
-  function addMany(entities) {
-    setState((prev) => {
-      const nextIds = [...prev.ids];
-      const nextEntities = { ...prev.entities };
-      for (const entity of entities) {
-        const id = String(entity[idKey]);
-        if (!nextIds.includes(id)) {
-          nextIds.push(id);
-        }
-        nextEntities[id] = entity;
-      }
-      return { ids: nextIds, entities: nextEntities };
-    });
-  }
-  function get(id) {
-    const state = getState();
-    return state.entities[id];
-  }
-  function getAll() {
-    const state = getState();
-    return state.ids.map((id) => state.entities[id]);
-  }
-  function update(id, partial) {
-    setState((prev) => {
-      const existing = prev.entities[id];
-      if (!existing) return prev;
-      return {
-        ids: prev.ids,
-        entities: {
-          ...prev.entities,
-          [id]: { ...existing, ...partial }
-        }
-      };
-    });
-  }
-  function remove(id) {
-    setState((prev) => {
-      if (!prev.entities[id]) return prev;
-      const { [id]: _, ...remainingEntities } = prev.entities;
-      return {
-        ids: prev.ids.filter((existingId) => existingId !== id),
-        entities: remainingEntities
-      };
-    });
-  }
-  function select(predicate) {
-    const state = getState();
-    return state.ids.map((id) => state.entities[id]).filter(predicate);
-  }
-  return { add, addMany, get, getAll, update, remove, select, getState };
-}
-function normalize(data, schema) {
-  const entities = {};
-  const idKey = schema.idKey || "id";
-  function ensureTable(name) {
-    if (!entities[name]) {
-      entities[name] = {};
-    }
-    return entities[name];
-  }
-  function normalizeEntity(entity, entitySchema) {
-    const entityIdKey = entitySchema.idKey || "id";
-    const id = String(entity[entityIdKey]);
-    const table = ensureTable(entitySchema.name);
-    const flat = { ...entity };
-    if (entitySchema.relations) {
-      for (const [field, relationType] of Object.entries(entitySchema.relations)) {
-        const value = entity[field];
-        if (value == null) continue;
-        const relSchema = { name: relationType, idKey };
-        if (Array.isArray(value)) {
-          flat[field] = value.map((item) => normalizeEntity(item, relSchema));
-        } else if (typeof value === "object") {
-          flat[field] = normalizeEntity(value, relSchema);
-        }
-      }
-    }
-    table[id] = flat;
-    return id;
-  }
-  if (Array.isArray(data)) {
-    const result2 = data.map((item) => normalizeEntity(item, schema));
-    return { result: result2, entities };
-  }
-  const result = normalizeEntity(data, schema);
-  return { result, entities };
-}
-function denormalize(id, entities, schema) {
-  const table = entities[schema.name];
-  if (!table) return void 0;
-  const entity = table[id];
-  if (!entity) return void 0;
-  const idKey = schema.idKey || "id";
-  const result = { ...entity };
-  if (schema.relations) {
-    for (const [field, relationType] of Object.entries(schema.relations)) {
-      const value = entity[field];
-      if (value == null) continue;
-      const relSchema = { name: relationType, idKey };
-      if (Array.isArray(value)) {
-        result[field] = value.map((relId) => denormalize(relId, entities, relSchema));
-      } else if (typeof value === "string") {
-        result[field] = denormalize(value, entities, relSchema);
-      }
-    }
-  }
-  return result;
-}
-
-// src/performance/chunkLoader.ts
-function createChunkRegistry(config = {}) {
-  const {
-    maxCacheSize = 50,
-    cacheTTL = 0,
-    retries = 2,
-    retryDelay = 1e3,
-    timeout = 1e4,
-    onLoadStart,
-    onLoadEnd,
-    onLoadError
-  } = config;
-  const cache = /* @__PURE__ */ new Map();
-  const pending = /* @__PURE__ */ new Map();
-  const preloaded = /* @__PURE__ */ new Set();
-  function evict() {
-    if (cache.size < maxCacheSize) return;
-    let oldest = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldest = key;
-      }
-    }
-    if (oldest) cache.delete(oldest);
-  }
-  function isValid(entry) {
-    if (cacheTTL === 0) return true;
-    return Date.now() - entry.timestamp < cacheTTL;
-  }
-  async function loadWithRetry(id, loader, attempt = 0) {
-    try {
-      const result = await (timeout > 0 ? Promise.race([
-        loader(),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Chunk '${id}' loading timed out after ${timeout}ms`)), timeout)
-        )
-      ]) : loader());
-      return result;
-    } catch (err) {
-      if (attempt < retries) {
-        await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
-        return loadWithRetry(id, loader, attempt + 1);
-      }
-      throw err;
-    }
-  }
-  return {
-    /**
-     * Load a chunk by ID. Uses cache if available, otherwise loads via the provided loader.
-     */
-    async load(id, loader) {
-      const cached = cache.get(id);
-      if (cached && isValid(cached)) {
-        cached.accessCount++;
-        return cached.value;
-      }
-      const pendingLoad = pending.get(id);
-      if (pendingLoad) return pendingLoad;
-      onLoadStart?.(id);
-      const loadPromise = loadWithRetry(id, loader).then((value) => {
-        evict();
-        cache.set(id, { value, timestamp: Date.now(), accessCount: 1 });
-        pending.delete(id);
-        onLoadEnd?.(id);
-        return value;
-      }).catch((err) => {
-        pending.delete(id);
-        const error = err instanceof Error ? err : new Error(String(err));
-        onLoadError?.(id, error);
-        throw error;
-      });
-      pending.set(id, loadPromise);
-      return loadPromise;
-    },
-    /**
-     * Preload a chunk without blocking. Silently caches for later use.
-     */
-    preload(id, loader) {
-      if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
-      preloaded.add(id);
-      this.load(id, loader).catch(() => {
-      });
-    },
-    /**
-     * Preload multiple chunks in parallel.
-     */
-    preloadAll(entries) {
-      for (const entry of entries) {
-        this.preload(entry.id, entry.loader);
-      }
-    },
-    /**
-     * Check if a chunk is cached and valid.
-     */
-    has(id) {
-      const entry = cache.get(id);
-      return !!entry && isValid(entry);
-    },
-    /**
-     * Get a cached chunk synchronously. Returns undefined if not cached.
-     */
-    get(id) {
-      const entry = cache.get(id);
-      if (entry && isValid(entry)) {
-        entry.accessCount++;
-        return entry.value;
-      }
-      return void 0;
-    },
-    /**
-     * Invalidate a cached chunk.
-     */
-    invalidate(id) {
-      cache.delete(id);
-    },
-    /**
-     * Clear all cached chunks.
-     */
-    clear() {
-      cache.clear();
-      preloaded.clear();
-    },
-    /**
-     * Get cache statistics.
-     */
-    stats() {
-      return {
-        size: cache.size,
-        maxSize: maxCacheSize,
-        pending: pending.size,
-        preloaded: preloaded.size
-      };
-    }
-  };
-}
-function lazyChunk(id, loader, registry, fallback) {
-  return () => {
-    const cached = registry.get(id);
-    if (cached) return cached();
-    const container = document.createElement("div");
-    container.setAttribute("data-chunk", id);
-    if (fallback) {
-      container.appendChild(fallback());
-    }
-    registry.load(id, async () => {
-      const mod = await loader();
-      return typeof mod === "function" ? mod : mod.default;
-    }).then((component) => {
-      container.innerHTML = "";
-      container.appendChild(component());
-    }).catch((err) => {
-      container.innerHTML = "";
-      const errorEl = document.createElement("div");
-      errorEl.textContent = `Failed to load chunk '${id}': ${err.message}`;
-      container.appendChild(errorEl);
-    });
-    return container;
-  };
-}
-function preloadModule(url) {
-  if (typeof document === "undefined") return;
-  const existing = document.querySelector(`link[href="${url}"][rel="modulepreload"]`);
-  if (existing) return;
-  const link = document.createElement("link");
-  link.rel = "modulepreload";
-  link.href = url;
-  document.head.appendChild(link);
-}
-function preloadModules(urls) {
-  urls.forEach(preloadModule);
-}
-
-export {
-  Priority,
-  scheduleUpdate,
-  flushScheduler,
-  pendingTasks,
-  yieldToMain,
-  processInChunks,
-  startTransition,
-  deferredValue,
-  transitionState,
-  resetIdCounter,
-  setIdPrefix,
-  uniqueId,
-  DOMPool,
-  domPool,
-  preloadResource,
-  prefetch,
-  preloadImage,
-  pure,
-  conditional,
-  Features,
-  devOnly,
-  noSideEffect,
-  staticTemplate,
-  cloneTemplate,
-  precompile,
-  hoistable,
-  block,
-  normalizedStore,
-  normalize,
-  denormalize,
-  createChunkRegistry,
-  lazyChunk,
-  preloadModule,
-  preloadModules
-};

package/dist/chunk-JRWAHOMS.js

@@ -1,41 +0,0 @@
-import {
-  isSSR
-} from "./chunk-CHJ27IGK.js";
-import {
-  devAssert,
-  track
-} from "./chunk-5KBEED6D.js";
-
-// src/core/signals/effect.ts
-var _g = globalThis;
-function effect(effectFn, options) {
-  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
-  if (isSSR()) return () => {
-  };
-  const onError = options?.onError;
-  const wrappedFn = onError ? () => {
-    try {
-      effectFn();
-    } catch (err) {
-      onError(err);
-    }
-  } : effectFn;
-  let cleanupHandle = () => {
-  };
-  const subscriber = () => {
-    cleanupHandle();
-    cleanupHandle = track(wrappedFn, subscriber);
-  };
-  cleanupHandle = track(wrappedFn, subscriber);
-  const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook) hook.emit("effect:create", { effectFn });
-  return () => {
-    const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (h) h.emit("effect:destroy", { effectFn });
-    cleanupHandle();
-  };
-}
-
-export {
-  effect
-};