sibujs 1.2.0 → 1.3.0

package/dist/introspect-BumjnBKr.d.cts

@@ -0,0 +1,477 @@
+import { R as ReactiveSignal } from './signal-BnWpq6WB.cjs';
+
+/**
+ * Enable debug mode — enables verbose logging.
+ */
+declare function enableDebug(): void;
+/**
+ * Disable debug mode.
+ */
+declare function disableDebug(): void;
+/**
+ * Check if debug mode is active.
+ */
+declare function isDebugEnabled(): boolean;
+/**
+ * Log a debug message (only when debug mode is enabled).
+ */
+declare function debugLog(component: string, action: string, data?: unknown): void;
+/**
+ * perfTracker tracks render timing for a component.
+ */
+declare function perfTracker(label: string): {
+    startMeasure: () => void;
+    endMeasure: () => number;
+    getAverageTime: () => number;
+    getRenderCount: () => number;
+};
+/**
+ * measureRender wraps a component and measures its render time.
+ */
+declare function measureRender<P>(label: string, component: (props: P) => HTMLElement): (props: P) => HTMLElement;
+/**
+ * Get all collected performance data.
+ */
+declare function getPerformanceReport(): Record<string, {
+    count: number;
+    average: number;
+    min: number;
+    max: number;
+    total: number;
+}>;
+/**
+ * Clear all performance data.
+ */
+declare function clearPerformanceData(): void;
+declare function trackCleanup(component: string, cleanup: () => void): void;
+declare function runCleanups(component: string): void;
+declare function checkLeaks(): Record<string, number>;
+
+/**
+ * Sibu DevTools Bridge
+ *
+ * Architecture (browser-extension bus style):
+ *
+ *   Sibu App                    Chrome Extension
+ *   ┌──────────┐               ┌──────────────┐
+ *   │ signal  │──emit──▶│    │  Content      │
+ *   │ derived │        │    │  Script       │
+ *   │ effect  │        ▼    │   │            │
+ *   │ mount     │   __SIBU_   │   ▼            │
+ *   └──────────┘   DEVTOOLS_  │  Background   │
+ *                  GLOBAL_    │   │            │
+ *                  HOOK__     │   ▼            │
+ *                    │        │  DevTools      │
+ *                    │        │  Panel         │
+ *                    ▼        └──────────────┘
+ *                 Bridge
+ *              (postMessage)
+ *
+ * The hook is injected by the content script BEFORE the app loads.
+ * When initDevTools() is called, the bridge connects to the existing hook
+ * or creates one. Events are buffered until the panel connects.
+ */
+type DevToolsEvent = {
+    type: "state-change";
+    component: string;
+    key: string;
+    oldValue: unknown;
+    newValue: unknown;
+    timestamp: number;
+} | {
+    type: "mount";
+    component: string;
+    element: HTMLElement;
+    timestamp: number;
+} | {
+    type: "unmount";
+    component: string;
+    timestamp: number;
+} | {
+    type: "render";
+    component: string;
+    duration: number;
+    timestamp: number;
+} | {
+    type: "error";
+    component: string;
+    error: Error;
+    timestamp: number;
+};
+interface DevToolsConfig {
+    maxEvents?: number;
+    enabled?: boolean;
+    maxSignals?: number;
+}
+interface ComponentEntry {
+    element: HTMLElement;
+    state?: Record<string, unknown>;
+}
+declare function getActiveDevTools(): ReturnType<typeof initDevTools> | null;
+/**
+ * Initialize Sibu DevTools.
+ * Connects to __SIBU_DEVTOOLS_GLOBAL_HOOK__ and starts tracking signals,
+ * computed values, effects, and components.
+ */
+declare function initDevTools(config?: DevToolsConfig): {
+    record: (event: DevToolsEvent) => void;
+    getEvents: (filter?: {
+        type?: string;
+        component?: string;
+    }) => DevToolsEvent[];
+    clearEvents: () => void;
+    registerComponent: (name: string, element: HTMLElement, state?: Record<string, unknown>) => void;
+    unregisterComponent: (name: string) => void;
+    getComponents: () => Map<string, ComponentEntry>;
+    getSignals: () => Array<{
+        id: number;
+        name: string;
+        type: string;
+        value: unknown;
+        subscriberCount: number;
+    }>;
+    isEnabled: () => boolean;
+    setEnabled: (v: boolean) => void;
+    snapshot: () => Record<string, unknown>;
+    highlightElement: (name: string) => void;
+    destroy: () => void;
+};
+declare function devState<T>(name: string, initial: T): [() => T, (value: T | ((prev: T) => T)) => void];
+
+/**
+ * Hot Module Replacement utilities for SibuJS.
+ * Preserves component state during development reloads.
+ *
+ * During development the HMR runtime keeps a global store of component state
+ * keyed by a developer-supplied ID.  When a module is hot-reloaded the new
+ * component implementation can re-use the preserved state so that the user
+ * does not lose context (form values, scroll position, etc.).
+ *
+ * The utilities integrate with bundlers that expose a `module.hot` or
+ * `import.meta.hot` API (Webpack, Vite, Parcel, etc.).
+ */
+/**
+ * Create an HMR-aware state that persists across module reloads.
+ * During development, state is stored in a global map keyed by a unique `id`.
+ * On the first load the `initial` value is used; on subsequent hot reloads
+ * the previously stored value is restored.
+ *
+ * @param id       Unique identifier for this state (should be stable across reloads)
+ * @param initial  Initial value used on the very first load
+ * @returns A `[getter, setter]` tuple compatible with `signal`
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = hmrState("MyCounter.count", 0);
+ * // After a hot reload, `count()` will still return the last known value.
+ * ```
+ */
+declare function hmrState<T>(id: string, initial: T): [() => T, (value: T | ((prev: T) => T)) => void];
+/**
+ * Register a component for HMR updates.
+ * When the module is hot-reloaded the component is re-rendered with preserved
+ * state by swapping out the old DOM element for the new one produced by the
+ * updated component function.
+ *
+ * @param id          Stable identifier for the component
+ * @param component   Factory function that returns the component's root element
+ * @param container   Optional container element – if provided the initial element
+ *                    is automatically appended to it
+ * @returns An object with `update` (swap implementation) and `dispose` (clean up)
+ *
+ * @example
+ * ```ts
+ * const hmr = registerHMR("MyWidget", () => MyWidget());
+ *
+ * // On hot update:
+ * hmr.update(() => MyWidgetV2());
+ *
+ * // On full teardown:
+ * hmr.dispose();
+ * ```
+ */
+declare function registerHMR(id: string, component: () => HTMLElement, container?: HTMLElement): {
+    /** Update the component implementation (called on hot reload) */
+    update: (newComponent: () => HTMLElement) => void;
+    /** Dispose the HMR registration */
+    dispose: () => void;
+};
+/**
+ * Create an HMR boundary.
+ * Components within the boundary are hot-reloaded independently.  The boundary
+ * keeps track of accept/dispose callbacks and can wrap a component factory so
+ * that hot updates are handled transparently.
+ *
+ * @param id  Stable boundary identifier
+ * @returns Boundary helpers: `wrap`, `accept`, `dispose`
+ *
+ * @example
+ * ```ts
+ * const boundary = createHMRBoundary("settings-panel");
+ *
+ * const el = boundary.wrap(() => SettingsPanel());
+ * document.body.appendChild(el);
+ *
+ * boundary.accept(() => console.log("Hot update accepted"));
+ * boundary.dispose(() => console.log("Cleaning up old version"));
+ * ```
+ */
+declare function createHMRBoundary(id: string): {
+    /** Wrap a component for HMR support */
+    wrap: (component: () => HTMLElement) => HTMLElement;
+    /** Accept a hot update */
+    accept: (callback?: () => void) => void;
+    /** Dispose callback */
+    dispose: (callback: () => void) => void;
+};
+/**
+ * Clear all HMR state (useful for a full page refresh or test teardown).
+ */
+declare function clearHMRState(): void;
+/**
+ * Check if HMR is available in the current environment.
+ * Returns `true` when any of the common bundler HMR APIs are detected
+ * (`module.hot` for Webpack, `import.meta.hot` for Vite, or the SibuJS
+ * custom hook).
+ */
+declare function isHMRAvailable(): boolean;
+
+/**
+ * Source map and debugging utilities for SibuJS.
+ * Provides enhanced error reporting with component context and stack traces.
+ *
+ * These utilities do not parse `.map` files at runtime; instead they enrich
+ * errors with SibuJS-specific component context so that developers can quickly
+ * identify *which* component failed and *what* props were in play, regardless
+ * of whether source maps are available in the browser.
+ */
+/**
+ * Enhanced error class with component context.
+ *
+ * Extends the native `Error` to carry the component name and the props that
+ * were active when the error was thrown.  The `cause` property (ES2022) is
+ * also forwarded so that the original error is preserved.
+ *
+ * @example
+ * ```ts
+ * throw new SibuError("Render failed", {
+ *   component: "UserCard",
+ *   props: { userId: 42 },
+ *   cause: originalError,
+ * });
+ * ```
+ */
+declare class SibuError extends Error {
+    component?: string;
+    props?: Record<string, unknown>;
+    constructor(message: string, options?: {
+        component?: string;
+        props?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Create a component error reporter that captures stack traces and maps them
+ * to component context.
+ *
+ * The reporter collects errors into an internal list, optionally logs them
+ * to the console, and forwards them to a user-supplied `onError` handler.
+ *
+ * @param options Configuration options
+ * @returns Reporter API
+ *
+ * @example
+ * ```ts
+ * const reporter = createErrorReporter({
+ *   onError: (err) => analytics.track("component_error", err),
+ *   logToConsole: true,
+ *   maxErrors: 200,
+ * });
+ *
+ * reporter.report(new Error("oops"), { component: "Dashboard" });
+ * console.log(reporter.getErrors());
+ * ```
+ */
+declare function createErrorReporter(options?: {
+    /** Custom error handler */
+    onError?: (error: SibuError) => void;
+    /** Whether to log to console (default `true`) */
+    logToConsole?: boolean;
+    /** Max errors to retain */
+    maxErrors?: number;
+}): {
+    /** Report an error with component context */
+    report: (error: Error, context?: {
+        component?: string;
+        props?: Record<string, unknown>;
+    }) => void;
+    /** Get all reported errors */
+    getErrors: () => SibuError[];
+    /** Clear error history */
+    clear: () => void;
+    /** Get error count by component */
+    getErrorsByComponent: () => Map<string, SibuError[]>;
+};
+/**
+ * Wrap a component factory with error tracking.
+ * Catches errors during rendering and reports them via the supplied reporter
+ * (or a default one).  If the component throws, a fallback `<div>` with the
+ * error message is returned so the rest of the page is not broken.
+ *
+ * @param name       Human-readable component name
+ * @param component  Factory function that returns an `HTMLElement`
+ * @param reporter   Optional error reporter (a default is created if omitted)
+ * @returns A wrapped factory function with identical signature
+ *
+ * @example
+ * ```ts
+ * const SafeWidget = withErrorTracking("Widget", () => Widget(), reporter);
+ * document.body.appendChild(SafeWidget());
+ * ```
+ */
+declare function withErrorTracking(name: string, component: () => HTMLElement, reporter?: ReturnType<typeof createErrorReporter>): () => HTMLElement;
+/**
+ * Format an error with enhanced stack trace information.
+ * Adds component context markers to stack traces so that the developer can
+ * immediately see which SibuJS component is involved.
+ *
+ * @param error    The error to format
+ * @param context  Optional context to include in the formatted output
+ * @returns A formatted multi-line string suitable for `console.error`
+ *
+ * @example
+ * ```ts
+ * try {
+ *   render();
+ * } catch (e) {
+ *   console.error(formatError(e, { component: "App" }));
+ * }
+ * ```
+ */
+declare function formatError(error: Error, context?: {
+    component?: string;
+}): string;
+
+/**
+ * Registers a reactive value for DevTools inspection.
+ * Uses an effect internally to track changes — the formatter is called
+ * on every update, and the latest snapshot is stored for DevTools.
+ *
+ * @param value Reactive getter (e.g., a signal)
+ * @param formatter Optional function to convert value to a display label
+ * @returns Dispose function to stop tracking
+ */
+declare function debugValue<T>(value: () => T, formatter?: (value: T) => string): () => void;
+/**
+ * Returns all currently registered debug values.
+ */
+declare function getDebugValues(): Array<{
+    value: unknown;
+    label: string;
+}>;
+/**
+ * Clears all registered debug values.
+ */
+declare function clearDebugValues(): void;
+
+interface ProfilerResult {
+    renderCount: () => number;
+    lastRenderTime: () => number;
+    averageRenderTime: () => number;
+    totalRenderTime: () => number;
+    reset: () => void;
+}
+/**
+ * Creates a component profiler that tracks render counts and timings.
+ * Uses performance.now() for high-resolution timing.
+ * All outputs are reactive via signal.
+ */
+declare function createProfiler(_name: string): ProfilerResult;
+/**
+ * Starts a render measurement for the given profiler.
+ * Returns a stop function that records the elapsed time.
+ */
+declare function startMeasure(profiler: ProfilerResult): () => void;
+
+interface DevtoolsOverlayOptions {
+    enabled?: boolean;
+    position?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+}
+/**
+ * Creates an in-browser devtools overlay manager.
+ * Manages panels and visibility state reactively.
+ * Does NOT create actual DOM elements — that's the consumer's job.
+ */
+declare function createDevtoolsOverlay(options?: DevtoolsOverlayOptions): {
+    isEnabled: () => boolean;
+    toggle: () => void;
+    addPanel: (name: string, render: () => string) => void;
+    removePanel: (name: string) => void;
+    getPanels: () => Array<{
+        name: string;
+        render: () => string;
+    }>;
+    dispose: () => void;
+};
+
+/**
+ * DevTools introspection utilities for SibuJS.
+ *
+ * These functions allow dev tools to inspect the reactive dependency graph
+ * at runtime. They are designed to be zero-cost when not used — no overhead
+ * is added to the hot path. Information is read from tags already placed
+ * on signals/getters by signal, derived, etc.
+ */
+
+/** Info about a reactive node in the dependency graph */
+interface ReactiveNodeInfo {
+    /** Debug name if provided (e.g., signal(0, { name: "count" })) */
+    name: string | undefined;
+    /** Internal signal reference */
+    signal: ReactiveSignal;
+    /** Number of subscribers */
+    subscriberCount: number;
+}
+/**
+ * Get the debug name of a signal getter function.
+ * Returns undefined if no name was provided.
+ *
+ * @example
+ * const [count] = signal(0, { name: "count" });
+ * getSignalName(count); // "count"
+ */
+declare function getSignalName(getter: () => unknown): string | undefined;
+/**
+ * Get the number of active subscribers for a signal getter.
+ *
+ * @example
+ * const [count] = signal(0);
+ * effect(() => count()); // +1 subscriber
+ * getSubscriberCount(count); // 1
+ */
+declare function getSubscriberCount(getter: () => unknown): number;
+/**
+ * Get the dependency list of an effect or computed subscriber function.
+ * Returns signal references that the subscriber depends on.
+ *
+ * Note: This reads the _deps Set that track.ts maintains on subscriber functions.
+ */
+declare function getDependencies(subscriberFn: () => void): ReactiveSignal[];
+/**
+ * Inspect a signal getter — returns name, signal ref, and subscriber count.
+ */
+declare function inspectSignal(getter: () => unknown): ReactiveNodeInfo | null;
+/**
+ * Walk the full reactive graph starting from a signal getter.
+ * Returns a tree of signal → subscribers → their signals → etc.
+ * Useful for devtools visualization.
+ *
+ * Set maxDepth to limit traversal (default: 10).
+ */
+declare function walkDependencyGraph(getter: () => unknown, maxDepth?: number): {
+    name: string | undefined;
+    subscribers: number;
+    downstream: ReturnType<typeof walkDependencyGraph>[];
+};
+
+export { measureRender as A, perfTracker as B, registerHMR as C, type DevToolsEvent as D, runCleanups as E, startMeasure as F, trackCleanup as G, walkDependencyGraph as H, withErrorTracking as I, type ProfilerResult as P, type ReactiveNodeInfo as R, SibuError as S, type DevtoolsOverlayOptions as a, clearDebugValues as b, checkLeaks as c, clearHMRState as d, clearPerformanceData as e, createDevtoolsOverlay as f, createErrorReporter as g, createHMRBoundary as h, createProfiler as i, debugLog as j, debugValue as k, devState as l, disableDebug as m, enableDebug as n, formatError as o, getActiveDevTools as p, getDebugValues as q, getDependencies as r, getPerformanceReport as s, getSignalName as t, getSubscriberCount as u, hmrState as v, initDevTools as w, inspectSignal as x, isDebugEnabled as y, isHMRAvailable as z };