sibujs 1.0.2 → 1.0.4

package/dist/chunk-ANRSGGFC.js

@@ -1,725 +0,0 @@
-import {
-  renderToString
-} from "./chunk-UATXXETW.js";
-
-// src/plugins/modular.ts
-function createModuleRegistry() {
-  const modules = /* @__PURE__ */ new Map();
-  function resolveInternal(name, stack) {
-    const entry = modules.get(name);
-    if (!entry) {
-      throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
-    }
-    if (entry.loaded) {
-      return entry.value;
-    }
-    if (stack.has(name)) {
-      const cycle = [...stack, name].join(" -> ");
-      throw new Error(`[ModuleRegistry] Circular dependency detected: ${cycle}`);
-    }
-    stack.add(name);
-    for (const dep of entry.deps) {
-      resolveInternal(dep, stack);
-    }
-    stack.delete(name);
-    entry.value = entry.factory();
-    entry.loaded = true;
-    return entry.value;
-  }
-  return {
-    /** Register a module with its factory function and optional dependencies */
-    register(name, factory, deps = []) {
-      modules.set(name, { factory, deps, loaded: false });
-    },
-    /** Resolve a module, loading its dependencies first */
-    resolve(name) {
-      return resolveInternal(name, /* @__PURE__ */ new Set());
-    },
-    /** Check if a module is registered */
-    has(name) {
-      return modules.has(name);
-    },
-    /** List all registered module names */
-    list() {
-      return Array.from(modules.keys());
-    },
-    /** Get the full dependency graph (transitive) for a module */
-    deps(name) {
-      const entry = modules.get(name);
-      if (!entry) {
-        throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
-      }
-      const visited = /* @__PURE__ */ new Set();
-      const result = [];
-      function walk(modName) {
-        const mod = modules.get(modName);
-        if (!mod) return;
-        for (const dep of mod.deps) {
-          if (!visited.has(dep)) {
-            visited.add(dep);
-            walk(dep);
-            result.push(dep);
-          }
-        }
-      }
-      walk(name);
-      return result;
-    },
-    /** Reset all loaded modules back to unloaded state (useful for testing) */
-    reset() {
-      for (const entry of modules.values()) {
-        entry.loaded = false;
-        entry.value = void 0;
-      }
-    }
-  };
-}
-function createBundle(modules) {
-  const cache = /* @__PURE__ */ new Map();
-  const bundle = {};
-  for (const key of Object.keys(modules)) {
-    Object.defineProperty(bundle, key, {
-      get() {
-        if (cache.has(key)) {
-          return cache.get(key);
-        }
-        const value = modules[key]();
-        cache.set(key, value);
-        return value;
-      },
-      enumerable: true,
-      configurable: false
-    });
-  }
-  return bundle;
-}
-function lazyModule(loader) {
-  let cached;
-  let loadedFlag = false;
-  const handle = {
-    get loaded() {
-      return loadedFlag;
-    },
-    async get() {
-      if (loadedFlag && cached !== void 0) {
-        return cached;
-      }
-      cached = await loader();
-      loadedFlag = true;
-      return cached;
-    }
-  };
-  return handle;
-}
-var packageInfo = {
-  name: "sibu",
-  version: "1.0.0",
-  entryPoints: {
-    main: "./index.ts",
-    core: "./src/core/html.ts",
-    hooks: "./src/core/signals/signal.ts",
-    router: "./src/plugins/router.ts",
-    i18n: "./src/plugins/i18n.ts",
-    testing: "./src/testing/index.ts",
-    ssr: "./src/core/ssr.ts"
-  },
-  /**
-   * Generate a package.json `exports` map for Node.js subpath exports.
-   * Maps each entry point to its import, require, and types paths.
-   */
-  generateExportsMap() {
-    const exportsMap = {};
-    for (const [name, sourcePath] of Object.entries(this.entryPoints)) {
-      const distPath = sourcePath.replace(/^\.\//, "./dist/").replace(/\.ts$/, "");
-      const subpath = name === "main" ? "." : `./${name}`;
-      exportsMap[subpath] = {
-        import: `${distPath}.mjs`,
-        require: `${distPath}.cjs`,
-        types: `${distPath}.d.ts`
-      };
-    }
-    return exportsMap;
-  }
-};
-
-// src/plugins/ecosystem.ts
-function createTestHarness() {
-  let container;
-  return {
-    /** Set up a clean DOM container before each test */
-    setup() {
-      container = document.createElement("div");
-      container.setAttribute("data-sibu-test", "true");
-      document.body.appendChild(container);
-      return container;
-    },
-    /** Tear down the DOM container after each test */
-    teardown() {
-      if (container?.parentNode) {
-        container.parentNode.removeChild(container);
-      }
-    },
-    /** Render a component into the test container */
-    render(component) {
-      const el = typeof component === "function" ? component() : component;
-      container.appendChild(el);
-      return el;
-    },
-    /** Get the test container */
-    getContainer() {
-      return container;
-    },
-    /** Wait for reactive updates to settle */
-    async flush() {
-      await new Promise((r) => setTimeout(r, 0));
-      await new Promise((r) => requestAnimationFrame(() => r()));
-    },
-    /** Query within the container */
-    query(selector) {
-      return container.querySelector(selector);
-    },
-    /** Query all matching elements within the container */
-    queryAll(selector) {
-      return Array.from(container.querySelectorAll(selector));
-    },
-    /** Simulate a click event */
-    click(el) {
-      el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
-    },
-    /** Simulate input value change */
-    input(el, value) {
-      el.value = value;
-      el.dispatchEvent(new Event("input", { bubbles: true }));
-    }
-  };
-}
-var bundlerMetadata = {
-  name: "sibu",
-  sideEffects: false,
-  modules: {
-    core: ["html", "mount", "each", "slots", "fragment", "catch", "portal", "directives"],
-    hooks: ["signal", "effect", "derived", "watch", "store", "ref", "memo", "memoFn", "array", "deepSignal"],
-    plugins: ["router", "i18n"],
-    components: ["ErrorBoundary", "Loading"],
-    ssr: ["ssr"],
-    advanced: ["globalStore", "machine", "optimistic", "timeTravel", "scheduler", "plugin"]
-  },
-  /** Generate import map for module resolution */
-  generateImportMap(base = "/node_modules/sibu/") {
-    const map = {};
-    for (const [category, modules] of Object.entries(this.modules)) {
-      for (const mod of modules) {
-        const dir = category === "hooks" ? "core" : category;
-        map[`sibu/${mod}`] = `${base}src/${dir}/${mod}.js`;
-      }
-    }
-    return map;
-  }
-};
-function healthCheck() {
-  const checks = [];
-  const hasDOM = typeof document !== "undefined";
-  checks.push({
-    name: "DOM Environment",
-    passed: hasDOM,
-    message: hasDOM ? "DOM is available" : "No DOM environment (SSR mode)"
-  });
-  const hasRAF = typeof requestAnimationFrame !== "undefined";
-  checks.push({
-    name: "requestAnimationFrame",
-    passed: hasRAF,
-    message: hasRAF ? "Available" : "Not available (polyfill may be needed)"
-  });
-  const hasMO = typeof MutationObserver !== "undefined";
-  checks.push({
-    name: "MutationObserver",
-    passed: hasMO,
-    message: hasMO ? "Available" : "Not available (lifecycle hooks may not work)"
-  });
-  const allPassed = checks.every((c) => c.passed);
-  return {
-    status: allPassed ? "ok" : "warning",
-    checks
-  };
-}
-var env = {
-  /** True when running in a browser with a DOM */
-  isBrowser: typeof window !== "undefined" && typeof document !== "undefined",
-  /** True when running in Node.js */
-  isNode: typeof process !== "undefined" && !!process.versions?.node,
-  /** True when running inside a Web Worker */
-  isWorker: typeof self !== "undefined" && typeof self.importScripts === "function",
-  /** True when running inside Deno */
-  isDeno: typeof globalThis.Deno !== "undefined",
-  /** True when running inside Bun */
-  isBun: typeof globalThis.Bun !== "undefined",
-  /** True when no window object is available (server-side rendering) */
-  isSSR: typeof window === "undefined",
-  /** True when NODE_ENV is not "production" */
-  isDev: typeof process !== "undefined" && process.env?.NODE_ENV !== "production",
-  /** True when NODE_ENV is "test" or VITEST is set */
-  isTest: typeof process !== "undefined" && (process.env?.NODE_ENV === "test" || process.env?.VITEST === "true")
-};
-
-// src/plugins/versioning.ts
-var VERSION = "1.0.0";
-function parseSemVer(version) {
-  const trimmed = version.trim().replace(/^v/i, "");
-  const prereleaseIndex = trimmed.indexOf("-");
-  let main;
-  let prerelease;
-  if (prereleaseIndex !== -1) {
-    main = trimmed.slice(0, prereleaseIndex);
-    prerelease = trimmed.slice(prereleaseIndex + 1);
-  } else {
-    main = trimmed;
-  }
-  const parts = main.split(".");
-  const major = parseInt(parts[0], 10);
-  const minor = parseInt(parts[1] || "0", 10);
-  const patch = parseInt(parts[2] || "0", 10);
-  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
-    throw new Error(`[Versioning] Invalid semver string: "${version}"`);
-  }
-  const result = { major, minor, patch };
-  if (prerelease !== void 0) {
-    result.prerelease = prerelease;
-  }
-  return result;
-}
-function compareSemVer(a, b) {
-  const va = typeof a === "string" ? parseSemVer(a) : a;
-  const vb = typeof b === "string" ? parseSemVer(b) : b;
-  if (va.major !== vb.major) return va.major > vb.major ? 1 : -1;
-  if (va.minor !== vb.minor) return va.minor > vb.minor ? 1 : -1;
-  if (va.patch !== vb.patch) return va.patch > vb.patch ? 1 : -1;
-  if (va.prerelease === void 0 && vb.prerelease === void 0) return 0;
-  if (va.prerelease === void 0) return 1;
-  if (vb.prerelease === void 0) return -1;
-  const aParts = va.prerelease.split(".");
-  const bParts = vb.prerelease.split(".");
-  const len = Math.max(aParts.length, bParts.length);
-  for (let i = 0; i < len; i++) {
-    if (i >= aParts.length) return -1;
-    if (i >= bParts.length) return 1;
-    const aId = aParts[i];
-    const bId = bParts[i];
-    const aNum = parseInt(aId, 10);
-    const bNum = parseInt(bId, 10);
-    const aIsNum = !Number.isNaN(aNum) && String(aNum) === aId;
-    const bIsNum = !Number.isNaN(bNum) && String(bNum) === bId;
-    if (aIsNum && bIsNum) {
-      if (aNum !== bNum) return aNum > bNum ? 1 : -1;
-    } else if (aIsNum) {
-      return -1;
-    } else if (bIsNum) {
-      return 1;
-    } else {
-      if (aId < bId) return -1;
-      if (aId > bId) return 1;
-    }
-  }
-  return 0;
-}
-function satisfies(version, range) {
-  const v = parseSemVer(version);
-  const trimmed = range.trim();
-  if (trimmed.includes("||")) {
-    return trimmed.split("||").some((part) => satisfies(version, part.trim()));
-  }
-  if (/\s+/.test(trimmed) && !trimmed.startsWith("^") && !trimmed.startsWith("~")) {
-    const parts = trimmed.split(/\s+/);
-    return parts.every((part) => satisfies(version, part));
-  }
-  if (trimmed.startsWith("^")) {
-    const target2 = parseSemVer(trimmed.slice(1));
-    if (v.major !== target2.major) return false;
-    if (target2.major === 0) {
-      if (v.minor !== target2.minor) return false;
-      if (target2.minor === 0) {
-        return v.patch === target2.patch;
-      }
-      return v.patch >= target2.patch;
-    }
-    return compareSemVer(v, target2) >= 0;
-  }
-  if (trimmed.startsWith("~")) {
-    const target2 = parseSemVer(trimmed.slice(1));
-    return v.major === target2.major && v.minor === target2.minor && v.patch >= target2.patch;
-  }
-  if (trimmed.startsWith(">=")) {
-    const target2 = parseSemVer(trimmed.slice(2));
-    return compareSemVer(v, target2) >= 0;
-  }
-  if (trimmed.startsWith("<=")) {
-    const target2 = parseSemVer(trimmed.slice(2));
-    return compareSemVer(v, target2) <= 0;
-  }
-  if (trimmed.startsWith(">") && !trimmed.startsWith(">=")) {
-    const target2 = parseSemVer(trimmed.slice(1));
-    return compareSemVer(v, target2) > 0;
-  }
-  if (trimmed.startsWith("<") && !trimmed.startsWith("<=")) {
-    const target2 = parseSemVer(trimmed.slice(1));
-    return compareSemVer(v, target2) < 0;
-  }
-  const exactStr = trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
-  const target = parseSemVer(exactStr);
-  return compareSemVer(v, target) === 0;
-}
-function createMigrationRunner(config) {
-  const storageKey = config.storageKey || "__sibu_migration_version__";
-  const sortedMigrations = [...config.migrations].sort((a, b) => compareSemVer(a.version, b.version));
-  function getStorage() {
-    try {
-      return typeof localStorage !== "undefined" ? localStorage : null;
-    } catch {
-      return null;
-    }
-  }
-  return {
-    /** Get the last applied migration version from storage */
-    getAppliedVersion() {
-      const storage = getStorage();
-      if (!storage) return null;
-      return storage.getItem(storageKey);
-    },
-    /** Get pending migrations that haven't been applied */
-    getPending() {
-      const appliedVersion = this.getAppliedVersion();
-      if (!appliedVersion) {
-        return sortedMigrations.filter((m) => compareSemVer(m.version, config.currentVersion) <= 0);
-      }
-      return sortedMigrations.filter(
-        (m) => compareSemVer(m.version, appliedVersion) > 0 && compareSemVer(m.version, config.currentVersion) <= 0
-      );
-    },
-    /** Run all pending migrations in order */
-    async migrate() {
-      const pending = this.getPending();
-      const applied = [];
-      const errors = [];
-      for (const migration of pending) {
-        try {
-          await migration.up();
-          applied.push(migration.version);
-          const storage = getStorage();
-          if (storage) {
-            storage.setItem(storageKey, migration.version);
-          }
-        } catch (e) {
-          errors.push({
-            version: migration.version,
-            error: e instanceof Error ? e : new Error(String(e))
-          });
-          break;
-        }
-      }
-      return { applied, errors };
-    },
-    /** Rollback to a specific version */
-    async rollback(targetVersion) {
-      const appliedVersion = this.getAppliedVersion();
-      const rolledBack = [];
-      if (!appliedVersion) {
-        return { rolledBack };
-      }
-      const toRollback = sortedMigrations.filter((m) => compareSemVer(m.version, targetVersion) > 0 && compareSemVer(m.version, appliedVersion) <= 0).reverse();
-      for (const migration of toRollback) {
-        if (!migration.down) {
-          throw new Error(
-            `[Versioning] Migration ${migration.version} ("${migration.description}") does not have a down() function and cannot be rolled back.`
-          );
-        }
-        await migration.down();
-        rolledBack.push(migration.version);
-      }
-      const storage = getStorage();
-      if (storage) {
-        if (targetVersion === "0.0.0") {
-          storage.removeItem(storageKey);
-        } else {
-          storage.setItem(storageKey, targetVersion);
-        }
-      }
-      return { rolledBack };
-    }
-  };
-}
-function checkCompatibility(frameworkVersion, requiredRange) {
-  const compatible = satisfies(frameworkVersion, requiredRange);
-  if (compatible) {
-    return {
-      compatible: true,
-      message: `Framework version ${frameworkVersion} is compatible with required range "${requiredRange}".`
-    };
-  }
-  const fv = parseSemVer(frameworkVersion);
-  const rangeTarget = extractRangeTarget(requiredRange);
-  let message = `Framework version ${frameworkVersion} is NOT compatible with required range "${requiredRange}".`;
-  if (rangeTarget) {
-    const tv = parseSemVer(rangeTarget);
-    if (fv.major < tv.major) {
-      message += ` A major upgrade is required (${fv.major}.x -> ${tv.major}.x).`;
-    } else if (fv.major > tv.major) {
-      message += " The framework version is ahead of the required range. Consider updating the dependency requirement.";
-    }
-  }
-  return { compatible, message };
-}
-function extractRangeTarget(range) {
-  const match = range.match(/[\d]+\.[\d]+\.[\d]+(?:-[\w.]+)?/);
-  return match ? match[0] : null;
-}
-
-// src/plugins/startup.ts
-function preloadCritical(resources) {
-  if (typeof document === "undefined") return;
-  for (const resource of resources) {
-    const existing = document.querySelector(`link[rel="preload"][href="${resource.href}"]`);
-    if (existing) continue;
-    const link = document.createElement("link");
-    link.rel = "preload";
-    link.href = resource.href;
-    link.setAttribute("as", resource.as);
-    if (resource.type) {
-      link.type = resource.type;
-    }
-    if (resource.crossOrigin) {
-      link.crossOrigin = resource.crossOrigin;
-    }
-    document.head.appendChild(link);
-  }
-}
-function prerenderRoutes(routes, options) {
-  const maxCacheSize = options?.maxCacheSize ?? 50;
-  const cacheTTL = options?.cacheTTL ?? 0;
-  const cache = /* @__PURE__ */ new Map();
-  function isValid(entry) {
-    if (cacheTTL === 0) return true;
-    return Date.now() - entry.timestamp < cacheTTL;
-  }
-  function evictOldest() {
-    if (cache.size < maxCacheSize) return;
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) cache.delete(oldestKey);
-  }
-  for (const route of routes) {
-    evictOldest();
-    const html = renderToString(route.component());
-    cache.set(route.path, { html, timestamp: Date.now() });
-  }
-  return {
-    /** Get cached HTML for a route, or undefined if not cached or expired */
-    get(path) {
-      const entry = cache.get(path);
-      if (!entry) return void 0;
-      if (!isValid(entry)) {
-        cache.delete(path);
-        return void 0;
-      }
-      return entry.html;
-    },
-    /** Check if a route has been prerendered and is still valid */
-    has(path) {
-      const entry = cache.get(path);
-      if (!entry) return false;
-      if (!isValid(entry)) {
-        cache.delete(path);
-        return false;
-      }
-      return true;
-    },
-    /** Invalidate a cached route */
-    invalidate(path) {
-      cache.delete(path);
-    },
-    /** Clear all cached routes */
-    clear() {
-      cache.clear();
-    },
-    /** Get cache statistics */
-    stats() {
-      if (cacheTTL > 0) {
-        for (const [key, entry] of cache) {
-          if (!isValid(entry)) {
-            cache.delete(key);
-          }
-        }
-      }
-      return {
-        size: cache.size,
-        routes: Array.from(cache.keys())
-      };
-    }
-  };
-}
-function createSSRCache(config) {
-  const maxSize = config?.maxSize ?? 100;
-  const defaultTTL = config?.defaultTTL ?? 6e4;
-  const cache = /* @__PURE__ */ new Map();
-  let hits = 0;
-  let misses = 0;
-  function isValid(entry) {
-    if (entry.ttl === 0) return true;
-    return Date.now() - entry.timestamp < entry.ttl;
-  }
-  function evictOldest() {
-    if (cache.size < maxSize) return;
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) cache.delete(oldestKey);
-  }
-  return {
-    /** Get cached HTML for a key, or undefined if not cached or expired */
-    get(key) {
-      const entry = cache.get(key);
-      if (!entry) {
-        misses++;
-        return void 0;
-      }
-      if (!isValid(entry)) {
-        cache.delete(key);
-        misses++;
-        return void 0;
-      }
-      hits++;
-      return entry.html;
-    },
-    /** Cache an HTML string with an optional TTL override */
-    set(key, html, ttl) {
-      evictOldest();
-      cache.set(key, {
-        html,
-        timestamp: Date.now(),
-        ttl: ttl ?? defaultTTL
-      });
-    },
-    /** Check if a key exists in the cache and is still valid */
-    has(key) {
-      const entry = cache.get(key);
-      if (!entry) return false;
-      if (!isValid(entry)) {
-        cache.delete(key);
-        return false;
-      }
-      return true;
-    },
-    /** Invalidate a cached entry */
-    invalidate(key) {
-      cache.delete(key);
-    },
-    /** Clear all cached entries and reset statistics */
-    clear() {
-      cache.clear();
-      hits = 0;
-      misses = 0;
-    },
-    /** Get cache statistics including hit/miss counts */
-    stats() {
-      return { size: cache.size, hits, misses };
-    }
-  };
-}
-function deferNonCritical(tasks) {
-  if (tasks.length === 0) return;
-  const schedule = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : (cb) => setTimeout(cb, 1);
-  const queue = [...tasks];
-  let index = 0;
-  function processNext(deadline) {
-    while (index < queue.length) {
-      if (deadline && deadline.timeRemaining() < 1) {
-        schedule(processNext);
-        return;
-      }
-      try {
-        queue[index]();
-      } catch (e) {
-        if (typeof console !== "undefined") {
-          console.error("[Startup] Deferred task failed:", e);
-        }
-      }
-      index++;
-    }
-  }
-  schedule(processNext);
-}
-function createBootSequence() {
-  const criticalTasks = [];
-  const deferredTasks = [];
-  return {
-    /** Add a critical task that runs immediately during boot */
-    critical(name, task) {
-      criticalTasks.push({ name, task });
-    },
-    /** Add a deferred task that runs after all critical tasks complete */
-    defer(name, task) {
-      deferredTasks.push({ name, task });
-    },
-    /** Execute the boot sequence: critical tasks first, then deferred */
-    async boot() {
-      const timing = {};
-      const errors = [];
-      for (const entry of criticalTasks) {
-        const start = Date.now();
-        try {
-          await entry.task();
-        } catch (e) {
-          errors.push({
-            name: entry.name,
-            error: e instanceof Error ? e : new Error(String(e))
-          });
-        }
-        timing[entry.name] = Date.now() - start;
-      }
-      for (const entry of deferredTasks) {
-        const start = Date.now();
-        try {
-          await entry.task();
-        } catch (e) {
-          errors.push({
-            name: entry.name,
-            error: e instanceof Error ? e : new Error(String(e))
-          });
-        }
-        timing[entry.name] = Date.now() - start;
-      }
-      return { timing, errors };
-    }
-  };
-}
-
-export {
-  createModuleRegistry,
-  createBundle,
-  lazyModule,
-  packageInfo,
-  createTestHarness,
-  bundlerMetadata,
-  healthCheck,
-  env,
-  VERSION,
-  parseSemVer,
-  compareSemVer,
-  satisfies,
-  createMigrationRunner,
-  checkCompatibility,
-  preloadCritical,
-  prerenderRoutes,
-  createSSRCache,
-  deferNonCritical,
-  createBootSequence
-};