@jqhtml/core 2.2.222

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 JQHTML Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @jqhtml/core
+
+A jQuery-based component framework for people who think in systems, not pixels.
+
+```html
+<Define:User_Card class="card">
+  <h3><%= this.data.name %></h3>
+  <p><%= this.data.email %></p>
+</Define:User_Card>
+```
+
+Components have a simple lifecycle: `on_load()` fetches data, `on_render()` sets up the DOM, `on_ready()` fires when everything's ready. No virtual DOM, no complex state management - just jQuery under the hood.
+
+**vs React/Vue:** JQHTML is for when you want component structure without the SPA complexity. Great for server-rendered apps (Laravel, Rails, Django) where you need interactive islands, not a full frontend framework.
+
+## Status
+
+Alpha release. It works and I use it daily, but expect rough edges. Full documentation and framework plugins coming soon.
+
+If you try it in a project, I'd love to hear about it.
+
+---
+
+**hansonxyz** · [hanson.xyz](https://hanson.xyz/) · [github](https://github.com/hansonxyz)

package/dist/component-registry.d.ts

@@ -0,0 +1,64 @@
+/**
+ * JQHTML v2 Component Registry
+ *
+ * Global registry for component classes and templates
+ * Enables dynamic component instantiation and template association
+ */
+import { Jqhtml_Component } from './component.js';
+export type TemplateFunction = (this: Jqhtml_Component, data: Record<string, any>, args: Record<string, any>, content: any) => [any[], Jqhtml_Component];
+export interface TemplateDefinition {
+    name: string;
+    tag: string;
+    defaultAttributes?: Record<string, any>;
+    extends?: string;
+    render: TemplateFunction;
+}
+export type ComponentConstructor = new (args: Record<string, any>, element?: any) => Jqhtml_Component;
+/**
+ * Register a component class with optional template
+ */
+export declare function register_component(name: string, component_class: ComponentConstructor, template?: TemplateDefinition): void;
+export declare function register_component(component_class: ComponentConstructor): void;
+/**
+ * Get a component class by name
+ * If no class found, walks the template extends chain to find parent class
+ */
+export declare function get_component_class(name: string): ComponentConstructor | undefined;
+/**
+ * Register a template - name is extracted from template.name property
+ * Returns true if registered, false if duplicate
+ */
+export declare function register_template(template_def: TemplateDefinition): boolean;
+/**
+ * Get template for a component by name
+ */
+export declare function get_template(name: string): TemplateDefinition;
+/**
+ * Get template for a component class - walks up inheritance chain
+ */
+export declare function get_template_by_class(component_class: ComponentConstructor): TemplateDefinition;
+/**
+ * Create a component instance by name
+ * If no component class is registered, uses the default Component class
+ */
+export declare function create_component(name: string, element?: any, args?: Record<string, any>): Jqhtml_Component;
+/**
+ * Check if a component is registered
+ */
+export declare function has_component(name: string): boolean;
+/**
+ * Get all registered component names
+ */
+export declare function get_component_names(): string[];
+/**
+ * Get all registered template names
+ */
+export declare function get_registered_templates(): string[];
+/**
+ * List all registered components with their template status
+ */
+export declare function list_components(): Record<string, {
+    has_class: boolean;
+    has_template: boolean;
+}>;
+//# sourceMappingURL=component-registry.d.ts.map

package/dist/component-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-registry.d.ts","sourceRoot":"","sources":["../src/component-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGlD,MAAM,MAAM,gBAAgB,GAAG,CAC7B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,OAAO,EAAE,GAAG,KACT,CAAC,GAAG,EAAE,EAAE,gBAAgB,CAAC,CAAC;AAG/B,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAGD,MAAM,MAAM,oBAAoB,GAAG,KAAK,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,gBAAgB,CAAC;AAsCtG;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,oBAAoB,EACrC,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,IAAI,CAAC;AACR,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,oBAAoB,GAAG,IAAI,CAAC;AA4ChF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAqClF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,kBAAkB,GAAG,OAAO,CAoC3E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CA0C7D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,oBAAoB,GAAG,kBAAkB,CAwB/F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,GAAG,EACb,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAC7B,gBAAgB,CAGlB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAEnD;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC,CAsB/F"}

package/dist/component.d.ts

@@ -0,0 +1,336 @@
+/**
+ * JQHTML v2 Component Base Class
+ *
+ * Core component implementation following v2 specification:
+ * - 5-stage lifecycle coordinated by LifecycleManager
+ * - Direct jQuery manipulation (no virtual DOM)
+ * - Scoped IDs using _cid pattern
+ * - Event emission and CSS class hierarchy
+ */
+declare global {
+    interface Window {
+        JQHTML_DEBUG?: {
+            log: (componentName: string, phase: string, message: string, data?: any) => void;
+            updateTree: () => void;
+        };
+    }
+}
+export declare class Jqhtml_Component {
+    static template?: any;
+    $: any;
+    args: Record<string, any>;
+    data: Record<string, any>;
+    state: Record<string, any>;
+    _cid: string;
+    _ready_state: number;
+    private _lifecycle_manager;
+    private _instantiator;
+    private _dom_parent;
+    private _dom_children;
+    private _use_dom_fallback;
+    private _stopped;
+    private _booted;
+    private _data_before_render;
+    private _lifecycle_callbacks;
+    private _lifecycle_states;
+    private __loading;
+    private _did_first_render;
+    private _render_count;
+    private _args_on_last_render;
+    private _data_on_last_render;
+    private __initial_data_snapshot;
+    private __data_frozen;
+    private _reload_debounced?;
+    private next_reload_force_refresh;
+    constructor(element?: any, args?: Record<string, any>);
+    /**
+     * Boot - Start the full component lifecycle
+     * Called immediately after construction by instruction processor
+     */
+    /**
+     * Internal boot method - starts component lifecycle
+     * @private
+     */
+    _boot(): Promise<void>;
+    /**
+     * Internal render phase - Create DOM structure
+     * Called top-down (parent before children) when part of lifecycle
+     * This is an internal method - users should call render() instead
+     *
+     * @param id Optional scoped ID - if provided, delegates to child component's _render()
+     * @returns The current _render_count after incrementing (used to detect stale renders)
+     * @private
+     */
+    _render(id?: string | null): number;
+    /**
+     * Public render method - re-renders component and completes lifecycle
+     * This is what users should call when they want to update a component.
+     *
+     * Lifecycle sequence:
+     * 1. _render() - Updates DOM synchronously, calls on_render(), fires 'render' event
+     * 2. Async continuation (fire and forget):
+     *    - _wait_for_children_ready() - Waits for all children to reach ready state
+     *    - on_ready() - Calls user's ready hook
+     *    - trigger('ready') - Fires ready event
+     *
+     * Returns immediately after _render() completes - does NOT wait for children
+     */
+    render(id?: string | null): void;
+    /**
+     * Alias for render() - re-renders component with current data
+     * Provided for API consistency and clarity
+     */
+    redraw(id?: string | null): void;
+    /**
+     * Create phase - Quick setup, prepare UI
+     * Called bottom-up (children before parent)
+     */
+    create(): Promise<void>;
+    /**
+     * Load phase - Fetch data from APIs
+     * Called bottom-up, fully parallel
+     * NO DOM MODIFICATIONS ALLOWED IN THIS PHASE
+     * @private - Internal lifecycle method, not for external use
+     */
+    _load(): Promise<void>;
+    /**
+     * Ready phase - Component fully initialized
+     * Called bottom-up (children before parent)
+     * @private
+     */
+    _ready(): Promise<void>;
+    /**
+     * Public API: Wait for component to be fully ready
+     * Returns a promise that resolves when the component reaches ready state.
+     * Optionally accepts a callback that executes when ready.
+     *
+     * @example
+     * // Promise pattern
+     * await component.ready();
+     *
+     * @example
+     * // Callback pattern
+     * component.ready(() => {
+     *   console.log('Component is ready!');
+     * });
+     *
+     * @example
+     * // Both patterns work together
+     * await component.ready(() => console.log('Callback fired'));
+     *
+     * @param callback Optional callback to execute when ready
+     */
+    ready(callback?: () => void): Promise<void>;
+    /**
+     * Wait for all child components to reach ready state
+     * Ensures bottom-up ordering (children ready before parent)
+     * @private
+     */
+    private _wait_for_children_ready;
+    /**
+     * Reload component - re-fetch data and re-render (debounced)
+     *
+     * This is the public API that automatically debounces calls to _reload()
+     * Multiple rapid calls to reload() will be coalesced into a single execution
+     *
+     * @param always_render - If true (default), always re-render after on_load().
+     *                        If false, only re-render if data actually changed.
+     */
+    reload(always_render?: boolean): Promise<void>;
+    /**
+     * Refresh component - re-fetch data and re-render only if data changed (debounced)
+     *
+     * Similar to reload() but only re-renders if the data actually changed after on_load().
+     * Useful for checking server for updates without forcing unnecessary re-renders.
+     *
+     * Uses the same debouncing as reload() and plays nice with it - if reload() is called
+     * while refresh() is queued, reload() takes precedence and will always render.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Internal reload implementation - re-fetch data and re-render
+     *
+     * COMPLETE RELOAD PROCESS (Source of Truth):
+     *
+     * STEP 1: Cache check (if args changed since last render)
+     *   - Generate cache key from component name + current args
+     *   - If cached data exists and is non-empty:
+     *     - Unfreeze this.data (temporarily)
+     *     - Hydrate this.data with cached data
+     *     - Re-freeze this.data
+     *     - Render immediately (stale-while-revalidate)
+     *     - Set rendered_from_cache flag
+     *
+     * STEP 2: Call on_load() to fetch fresh data
+     *   - Unfreeze this.data
+     *   - Restore this.data to on_create() snapshot
+     *   - Call on_load() directly (no _load() wrapper)
+     *   - Freeze this.data after completion
+     *   - If data changed and non-empty: write to cache
+     *
+     * STEP 3: Conditionally re-render
+     *   - If didn't render from cache yet, OR data changed after on_load():
+     *     - Call render() to update DOM
+     *
+     * STEP 3.5: Wait for all children to be ready
+     *   - Bottom-up ordering (children ready before parent)
+     *   - Same as main lifecycle
+     *
+     * STEP 4: Call on_ready()
+     *   - Always call on_ready() after reload completes
+     *
+     * @private - Use reload() instead (debounced wrapper)
+     */
+    _reload(): Promise<void>;
+    /**
+     * Destroy the component and cleanup
+     * Called automatically by MutationObserver when component is removed from DOM
+     * Can also be called manually for explicit cleanup
+     */
+    /**
+     * Internal stop method - stops just this component (no children)
+     * Sets stopped flag, calls lifecycle hooks, but leaves DOM intact
+     * @private
+     */
+    _stop(): void;
+    /**
+     * Stop component lifecycle - stops all descendant components then self
+     * Leaves DOM intact, just stops lifecycle engine and fires cleanup hooks
+     */
+    stop(): void;
+    on_render(): void | Promise<void>;
+    on_create(): void | Promise<void>;
+    on_load(): Promise<void>;
+    on_ready(): Promise<void>;
+    on_stop(): void | Promise<void>;
+    /**
+     * Optional: Override cache key generation
+     *
+     * By default, cache keys are generated from component name + args.
+     * Override this method to provide a custom cache key for this component instance.
+     *
+     * If this method throws an error, caching will be disabled for this component.
+     *
+     * @returns Custom cache key string (will be prefixed with component name)
+     */
+    cache_id?(): string;
+    /**
+     * Should component re-render after load?
+     * By default, only re-renders if data has changed
+     * Override to control re-rendering behavior
+     */
+    /**
+     * Internal method to determine if component should re-render after on_load()
+     * @private
+     */
+    _should_rerender(): boolean;
+    /**
+     * Get component name for debugging
+     */
+    component_name(): string;
+    /**
+     * Register event callback
+     * Supports lifecycle events ('render', 'create', 'load', 'ready', 'stop') and custom events
+     * Lifecycle event callbacks fire after the lifecycle method completes
+     * If a lifecycle event has already occurred, the callback fires immediately AND registers for future occurrences
+     * Custom events only fire when explicitly triggered via .trigger()
+     */
+    on(event_name: string, callback: (component: Jqhtml_Component) => void): this;
+    /**
+     * Trigger a lifecycle event - fires all registered callbacks
+     * Marks event as occurred so future .on() calls fire immediately
+     */
+    trigger(event_name: string): void;
+    /**
+     * Check if any callbacks are registered for a given event
+     * Used to determine if cleanup logic needs to run
+     */
+    _on_registered(event_name: string): boolean;
+    /**
+     * Find element by scoped ID
+     *
+     * Searches for elements with id="local_id:THIS_COMPONENT_CID"
+     *
+     * Example:
+     *   Template: <button $sid="save_btn">Save</button>
+     *   Rendered: <button id="save_btn:abc123" data-sid="save_btn">Save</button>
+     *   Access:   this.$sid('save_btn')  // Returns jQuery element
+     *
+     * Performance: Uses native document.getElementById() when component is in DOM,
+     * falls back to jQuery.find() for components not yet attached to DOM.
+     *
+     * @param local_id The local ID (without _cid suffix)
+     * @returns jQuery element with id="local_id:_cid", or empty jQuery object if not found
+     */
+    $sid(local_id: string): any;
+    /**
+     * Get component instance by scoped ID
+     *
+     * Convenience method that finds element by scoped ID and returns the component instance.
+     *
+     * Example:
+     *   Template: <User_Card $sid="active_user" />
+     *   Access:   const user = this.sid('active_user');  // Returns User_Card instance
+     *             user.data.name  // Access component's data
+     *
+     * To get the scoped ID string itself:
+     *   this.$sid('active_user').attr('id')  // Returns "active_user:abc123xyz"
+     *
+     * @param local_id The local ID (without _cid suffix)
+     * @returns Component instance or null if not found or not a component
+     */
+    sid(local_id: string): Jqhtml_Component | null;
+    /**
+     * Get the component that instantiated this component (rendered it in their template)
+     * Returns null if component was created programmatically via $().component()
+     */
+    instantiator(): Jqhtml_Component | null;
+    /**
+     * Find descendant components by CSS selector
+     */
+    find(selector: string): Jqhtml_Component[];
+    /**
+     * Find closest ancestor component matching selector
+     */
+    closest(selector: string): Jqhtml_Component | null;
+    /**
+     * Get CSS class hierarchy for this component type
+     */
+    static get_class_hierarchy(): string[];
+    private _generate_cid;
+    /**
+     * Flatten instruction array - converts ['_content', [...]] markers to flat array
+     * Recursively flattens nested content from content() calls
+     */
+    private _flatten_instructions;
+    private _apply_css_classes;
+    private _apply_default_attributes;
+    private _set_attributes;
+    private _update_debug_attrs;
+    private _find_dom_parent;
+    /**
+     * Get DOM children (components in DOM subtree)
+     * Uses fast _dom_children registry when possible, falls back to DOM traversal for off-DOM components
+     * @private - Used internally for lifecycle coordination
+     */
+    private _get_dom_children;
+    private _log_lifecycle;
+    private _log_debug;
+    /**
+     * Creates a debounced function with exclusivity and promise fan-in
+     *
+     * When invoked, immediately runs the callback exclusively.
+     * For subsequent invocations, applies a delay before running the callback exclusively again.
+     * The delay starts after the current asynchronous operation resolves.
+     *
+     * If delay is 0, the function only prevents enqueueing multiple executions,
+     * but will still run them immediately in an exclusive sequential manner.
+     *
+     * The most recent invocation's parameters are used when the function executes.
+     * Returns a promise that resolves when the next exclusive execution completes.
+     *
+     * @private
+     */
+    private _create_debounced_function;
+}
+//# sourceMappingURL=component.d.ts.map

package/dist/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"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"}

package/dist/debug-entry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * JQHTML Debug Module
+ *
+ * Optional debugging utilities for development
+ * Import separately to keep production bundles small:
+ *
+ * import { showDebugOverlay } from '@jqhtml/core/debug';
+ */
+export { DebugOverlay, showDebugOverlay, hideDebugOverlay } from './debug-overlay.js';
+export type { DebugOverlayOptions } from './debug-overlay.js';
+export { logLifecycle, applyDebugDelay, logDispatch, logInstruction, logDataChange, isSequentialProcessing, handleComponentError, devWarn } from './debug.js';
+export interface DebugSettings {
+    verbose?: boolean;
+    logCreationReady?: boolean;
+    logFullLifecycle?: boolean;
+    logDispatch?: boolean;
+    logDispatchVerbose?: boolean;
+    delayAfterComponent?: number;
+    delayAfterRender?: number;
+    delayAfterRerender?: number;
+    sequentialProcessing?: boolean;
+    flashComponents?: boolean;
+    flashDuration?: number;
+    flashColors?: {
+        create?: string;
+        render?: string;
+        ready?: string;
+    };
+    showComponentTree?: boolean;
+    profilePerformance?: boolean;
+    breakOnError?: boolean;
+    traceDataFlow?: boolean;
+    logInstructionProcessing?: boolean;
+    highlightSlowRenders?: number;
+}
+//# sourceMappingURL=debug-entry.d.ts.map

package/dist/debug-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-entry.d.ts","sourceRoot":"","sources":["../src/debug-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG9D,OAAO,EACL,YAAY,EACZ,eAAe,EACf,WAAW,EACX,cAAc,EACd,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,OAAO,EACR,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,aAAa;IAE5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAG7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAG/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE;QACZ,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IAGF,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B"}

package/dist/debug-overlay.d.ts

@@ -0,0 +1,61 @@
+/**
+ * JQHTML Debug Overlay
+ *
+ * Independent debug controls using pure jQuery DOM manipulation.
+ * Does NOT use JQHTML components so it works even when components are broken.
+ */
+export interface DebugOverlayOptions {
+    position?: 'top' | 'bottom';
+    theme?: 'dark' | 'light';
+    compact?: boolean;
+    showStatus?: boolean;
+    autoHide?: boolean;
+}
+export declare class DebugOverlay {
+    private static instance;
+    private $container;
+    private $statusIndicator;
+    private options;
+    private $;
+    constructor(options?: DebugOverlayOptions);
+    /**
+     * Static method to show debug overlay (singleton pattern)
+     */
+    static show(options?: DebugOverlayOptions): DebugOverlay;
+    /**
+     * Static method to hide debug overlay
+     */
+    static hide(): void;
+    /**
+     * Static method to toggle debug overlay visibility
+     */
+    static toggle(): void;
+    /**
+     * Static method to destroy debug overlay
+     */
+    static destroy(): void;
+    /**
+     * Display the debug overlay
+     */
+    private display;
+    /**
+     * Hide the debug overlay
+     */
+    hide(): void;
+    /**
+     * Remove the debug overlay completely
+     */
+    destroy(): void;
+    /**
+     * Update the status indicator
+     */
+    updateStatus(mode: string): void;
+    private createOverlay;
+    private createStatusIndicator;
+    private addStyles;
+    private toggle;
+    private executeAction;
+}
+export declare function showDebugOverlay(options?: DebugOverlayOptions): DebugOverlay;
+export declare function hideDebugOverlay(): void;
+//# sourceMappingURL=debug-overlay.d.ts.map

package/dist/debug-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-overlay.d.ts","sourceRoot":"","sources":["../src/debug-overlay.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA8BH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IACpD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,CAAC,CAAM;gBAEH,OAAO,GAAE,mBAAwB;IAgB7C;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY;IAQxD;;OAEG;IACH,MAAM,CAAC,IAAI,IAAI,IAAI;IAMnB;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,IAAI;IAYrB;;OAEG;IACH,MAAM,CAAC,OAAO,IAAI,IAAI;IAOtB;;OAEG;IACH,OAAO,CAAC,OAAO;IAYf;;OAEG;IACH,IAAI,IAAI,IAAI;IASZ;;OAEG;IACH,OAAO,IAAI,IAAI;IAWf;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAOhC,OAAO,CAAC,aAAa;IAiDrB,OAAO,CAAC,qBAAqB;IAqB7B,OAAO,CAAC,SAAS;IAoGjB,OAAO,CAAC,MAAM;IAed,OAAO,CAAC,aAAa;CAoEtB;AAGD,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,CAE5E;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/dist/debug.d.ts

@@ -0,0 +1,19 @@
+/**
+ * JQHTML Debug Module
+ *
+ * Provides comprehensive debugging capabilities for JQHTML components
+ */
+import type { Jqhtml_Component } from './component.js';
+/**
+ * Development warning helper
+ * Warnings are suppressed in production builds or when JQHTML_SUPPRESS_WARNINGS is set
+ */
+export declare function devWarn(message: string): void;
+export declare function logLifecycle(component: Jqhtml_Component, phase: string, status: 'start' | 'complete'): void;
+export declare function applyDebugDelay(phase: 'component' | 'render' | 'rerender'): void;
+export declare function logInstruction(type: string, data: any): void;
+export declare function logDataChange(component: Jqhtml_Component, property: string, oldValue: any, newValue: any): void;
+export declare function logDispatch(url: string, route: any, params: any, verbose?: boolean): void;
+export declare function isSequentialProcessing(): boolean;
+export declare function handleComponentError(component: Jqhtml_Component, phase: string, error: Error): void;
+//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAQvD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAY7C;AAuDD,wBAAgB,YAAY,CAAC,SAAS,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAmD3G;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,QAAQ,GAAG,UAAU,GAAG,IAAI,CAqBhF;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI,CAK5D;AAGD,wBAAgB,aAAa,CAAC,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG,IAAI,CAM/G;AAUD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAE,OAAe,GAAG,IAAI,CAoBhG;AAGD,wBAAgB,sBAAsB,IAAI,OAAO,CAGhD;AAGD,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAQnG"}