9ebcc359ae
Implement JQHTML function cache ID system and fix bundle compilation Implement underscore prefix for system tables Fix JS syntax linter to support decorators and grant exception to Task system SPA: Update planning docs and wishlists with remaining features SPA: Document Navigation API abandonment and future enhancements Implement SPA browser integration with History API (Phase 1) Convert contacts view page to SPA action Convert clients pages to SPA actions and document conversion procedure SPA: Merge GET parameters and update documentation Implement SPA route URL generation in JavaScript and PHP Implement SPA bootstrap controller architecture Add SPA routing manual page (rsx:man spa) Add SPA routing documentation to CLAUDE.md Phase 4 Complete: Client-side SPA routing implementation Update get_routes() consumers for unified route structure Complete SPA Phase 3: PHP-side route type detection and is_spa flag Restore unified routes structure and Manifest_Query class Refactor route indexing and add SPA infrastructure Phase 3 Complete: SPA route registration in manifest Implement SPA Phase 2: Extract router code and test decorators Rename Jqhtml_Component to Component and complete SPA foundation setup 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2209 lines
210 KiB
JavaScript
Executable File
2209 lines
210 KiB
JavaScript
Executable File
/* === storage/rsx-build/bundles/npm_Bootstrap5_Bundle_6459e8ed0f60bda4f121420766012d53.js === */
|
|
(() => {
|
|
// node_modules/@jqhtml/core/dist/index.js
|
|
var LifecycleManager = class _LifecycleManager {
|
|
static get_instance() {
|
|
if (!_LifecycleManager.instance) {
|
|
_LifecycleManager.instance = new _LifecycleManager();
|
|
}
|
|
return _LifecycleManager.instance;
|
|
}
|
|
constructor() {
|
|
this.active_components = /* @__PURE__ */ new Set();
|
|
}
|
|
/**
|
|
* Boot a component - run its full lifecycle
|
|
* Called when component is created
|
|
*/
|
|
async boot_component(component) {
|
|
this.active_components.add(component);
|
|
try {
|
|
await component.create();
|
|
if (component._stopped)
|
|
return;
|
|
component.trigger("create");
|
|
let render_id = component._render();
|
|
if (component._stopped)
|
|
return;
|
|
await component.load();
|
|
if (component._stopped)
|
|
return;
|
|
if (component.should_rerender()) {
|
|
render_id = component._render();
|
|
if (component._stopped)
|
|
return;
|
|
}
|
|
if (component._render_count !== render_id) {
|
|
return;
|
|
}
|
|
await component.ready();
|
|
if (component._stopped)
|
|
return;
|
|
await component.trigger("ready");
|
|
} catch (error) {
|
|
console.error(`Error booting component ${component.component_name()}:`, error);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Unregister a component (called on destroy)
|
|
*/
|
|
unregister_component(component) {
|
|
this.active_components.delete(component);
|
|
}
|
|
/**
|
|
* Wait for all active components to reach ready state
|
|
*/
|
|
async wait_for_ready() {
|
|
const ready_promises = [];
|
|
for (const component of this.active_components) {
|
|
if (component._ready_state < 4) {
|
|
ready_promises.push(new Promise((resolve) => {
|
|
component.on("ready", () => resolve());
|
|
}));
|
|
}
|
|
}
|
|
await Promise.all(ready_promises);
|
|
}
|
|
};
|
|
var component_classes = /* @__PURE__ */ new Map();
|
|
var component_templates = /* @__PURE__ */ new Map();
|
|
var warned_components = /* @__PURE__ */ new Set();
|
|
var DEFAULT_TEMPLATE = {
|
|
name: "Component",
|
|
// Default name
|
|
tag: "div",
|
|
render: function(data, args, content) {
|
|
const _output = [];
|
|
if (args._inner_html) {
|
|
_output.push(args._inner_html);
|
|
return [_output, this];
|
|
}
|
|
if (content && typeof content === "function") {
|
|
const result = content(this);
|
|
if (Array.isArray(result) && result.length === 2) {
|
|
_output.push(...result[0]);
|
|
} else if (typeof result === "string") {
|
|
_output.push(result);
|
|
}
|
|
}
|
|
return [_output, this];
|
|
}
|
|
};
|
|
function register_component(nameOrClass, component_class, template) {
|
|
if (typeof nameOrClass === "string") {
|
|
const name = nameOrClass;
|
|
if (!component_class) {
|
|
throw new Error("Component class is required when registering by name");
|
|
}
|
|
if (!/^[A-Z]/.test(name)) {
|
|
throw new Error(`Component name '${name}' must start with a capital letter. Convention is First_Letter_With_Underscores.`);
|
|
}
|
|
component_classes.set(name, component_class);
|
|
if (template) {
|
|
if (template.name !== name) {
|
|
throw new Error(`Template name '${template.name}' must match component name '${name}'`);
|
|
}
|
|
register_template(template);
|
|
}
|
|
} else {
|
|
const component_class2 = nameOrClass;
|
|
const name = component_class2.name;
|
|
if (!name || name === "Component") {
|
|
throw new Error("Component class must have a name when registering without explicit name");
|
|
}
|
|
component_classes.set(name, component_class2);
|
|
}
|
|
}
|
|
function get_component_class(name) {
|
|
const directClass = component_classes.get(name);
|
|
if (directClass) {
|
|
return directClass;
|
|
}
|
|
const template = component_templates.get(name);
|
|
if (template && template.extends) {
|
|
const visited = /* @__PURE__ */ new Set([name]);
|
|
let currentTemplateName = template.extends;
|
|
while (currentTemplateName && !visited.has(currentTemplateName)) {
|
|
visited.add(currentTemplateName);
|
|
const parentClass = component_classes.get(currentTemplateName);
|
|
if (parentClass) {
|
|
if (window.jqhtml?.debug?.enabled) {
|
|
console.log(`[JQHTML] Component '${name}' using class from parent '${currentTemplateName}' via extends chain`);
|
|
}
|
|
return parentClass;
|
|
}
|
|
const parentTemplate = component_templates.get(currentTemplateName);
|
|
if (parentTemplate && parentTemplate.extends) {
|
|
currentTemplateName = parentTemplate.extends;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function register_template(template_def) {
|
|
const name = template_def.name;
|
|
if (!name) {
|
|
throw new Error("Template must have a name property");
|
|
}
|
|
if (!/^[A-Z]/.test(name)) {
|
|
throw new Error(`Template name '${name}' must start with a capital letter. Convention is First_Letter_With_Underscores.`);
|
|
}
|
|
if (component_templates.has(name)) {
|
|
console.warn(`[JQHTML] Template '${name}' already registered, skipping duplicate registration`);
|
|
return false;
|
|
}
|
|
component_templates.set(name, template_def);
|
|
if (window.jqhtml?.debug?.enabled) {
|
|
console.log(`[JQHTML] Successfully registered template: ${name}`);
|
|
}
|
|
const component_class = component_classes.get(name);
|
|
if (component_class) {
|
|
component_class._jqhtml_metadata = {
|
|
tag: template_def.tag,
|
|
defaultAttributes: template_def.defaultAttributes || {}
|
|
};
|
|
}
|
|
return true;
|
|
}
|
|
function get_template(name) {
|
|
const template = component_templates.get(name);
|
|
if (!template) {
|
|
const component_class = component_classes.get(name);
|
|
if (component_class) {
|
|
const inherited_template = get_template_by_class(component_class);
|
|
if (inherited_template !== DEFAULT_TEMPLATE) {
|
|
if (window.jqhtml?.debug?.enabled) {
|
|
console.log(`[JQHTML] Component '${name}' has no template, using template from prototype chain`);
|
|
}
|
|
return inherited_template;
|
|
}
|
|
if (window.jqhtml?.debug?.enabled && !warned_components.has(name)) {
|
|
warned_components.add(name);
|
|
console.log(`[JQHTML] No template found for class: ${name}, using default div template`);
|
|
}
|
|
} else {
|
|
if (name !== "_Jqhtml_Component" && name !== "Redrawable" && !warned_components.has(name)) {
|
|
warned_components.add(name);
|
|
console.warn(`[JQHTML] Creating ${name} with defaults - no template or class defined`);
|
|
}
|
|
}
|
|
if (window.jqhtml?.debug?.verbose) {
|
|
const registered = Array.from(component_templates.keys());
|
|
console.log(`[JQHTML] Looking for template '${name}' in: [${registered.join(", ")}]`);
|
|
}
|
|
return DEFAULT_TEMPLATE;
|
|
}
|
|
return template;
|
|
}
|
|
function get_template_by_class(component_class) {
|
|
if (component_class.template) {
|
|
return component_class.template;
|
|
}
|
|
let currentClass = component_class;
|
|
while (currentClass && currentClass.name !== "Object") {
|
|
let normalizedName = currentClass.name;
|
|
if (normalizedName === "_Jqhtml_Component" || normalizedName === "_Base_Jqhtml_Component") {
|
|
normalizedName = "Component";
|
|
}
|
|
const template = component_templates.get(normalizedName);
|
|
if (template) {
|
|
return template;
|
|
}
|
|
currentClass = Object.getPrototypeOf(currentClass);
|
|
}
|
|
return DEFAULT_TEMPLATE;
|
|
}
|
|
function create_component(name, element, args = {}) {
|
|
const ComponentClass = get_component_class(name) || Component;
|
|
return new ComponentClass(element, args);
|
|
}
|
|
function has_component(name) {
|
|
return component_classes.has(name);
|
|
}
|
|
function get_component_names() {
|
|
return Array.from(component_classes.keys());
|
|
}
|
|
function get_registered_templates() {
|
|
return Array.from(component_templates.keys());
|
|
}
|
|
function list_components() {
|
|
const result = {};
|
|
for (const name of component_classes.keys()) {
|
|
result[name] = {
|
|
has_class: true,
|
|
has_template: component_templates.has(name)
|
|
};
|
|
}
|
|
for (const name of component_templates.keys()) {
|
|
if (!result[name]) {
|
|
result[name] = {
|
|
has_class: false,
|
|
has_template: true
|
|
};
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var _cid_increment = "aa";
|
|
function uid() {
|
|
const current = _cid_increment;
|
|
const chars = _cid_increment.split("");
|
|
let carry = true;
|
|
for (let i = chars.length - 1; i >= 0 && carry; i--) {
|
|
const char = chars[i];
|
|
if (char >= "a" && char < "z") {
|
|
chars[i] = String.fromCharCode(char.charCodeAt(0) + 1);
|
|
carry = false;
|
|
} else if (char === "z") {
|
|
chars[i] = "0";
|
|
carry = false;
|
|
} else if (char >= "0" && char < "9") {
|
|
chars[i] = String.fromCharCode(char.charCodeAt(0) + 1);
|
|
carry = false;
|
|
} else if (char === "9") {
|
|
chars[i] = "a";
|
|
carry = true;
|
|
}
|
|
}
|
|
if (carry) {
|
|
chars.unshift("a");
|
|
}
|
|
if (chars[0] >= "0" && chars[0] <= "9") {
|
|
chars[0] = "a";
|
|
chars.unshift("a");
|
|
}
|
|
_cid_increment = chars.join("");
|
|
return current;
|
|
}
|
|
function process_instructions(instructions, target, context, slots) {
|
|
const html = [];
|
|
const tagElements = {};
|
|
const components = {};
|
|
for (const instruction of instructions) {
|
|
process_instruction_to_html(instruction, html, tagElements, components, context, slots);
|
|
}
|
|
target[0].innerHTML = html.join("");
|
|
for (const [tid, tagData] of Object.entries(tagElements)) {
|
|
const el = target[0].querySelector(`[data-tid="${tid}"]`);
|
|
if (el) {
|
|
const element = $(el);
|
|
el.removeAttribute("data-tid");
|
|
apply_attributes(element, tagData.attrs, context);
|
|
}
|
|
}
|
|
for (const [cid, compData] of Object.entries(components)) {
|
|
const el = target[0].querySelector(`[data-cid="${cid}"]`);
|
|
if (el) {
|
|
const element = $(el);
|
|
el.removeAttribute("data-cid");
|
|
initialize_component(element, compData);
|
|
}
|
|
}
|
|
}
|
|
function process_instruction_to_html(instruction, html, tagElements, components, context, slots) {
|
|
if (typeof instruction === "string") {
|
|
html.push(instruction);
|
|
} else if ("tag" in instruction) {
|
|
process_tag_to_html(instruction, html, tagElements, components, context);
|
|
} else if ("comp" in instruction) {
|
|
process_component_to_html(instruction, html, components, context);
|
|
} else if ("slot" in instruction) {
|
|
process_slot_to_html(instruction, html, tagElements, components, context, slots);
|
|
} else if ("rawtag" in instruction) {
|
|
process_rawtag_to_html(instruction, html);
|
|
}
|
|
}
|
|
function process_tag_to_html(instruction, html, tagElements, components, context) {
|
|
const [tagName, attrs, selfClosing] = instruction.tag;
|
|
const needsTracking = Object.keys(attrs).some((key) => key === "$id" || key.startsWith("$") || key.startsWith("@") || key.startsWith("on") || key.startsWith("data-bind-") || key.startsWith("data-on-"));
|
|
html.push(`<${tagName}`);
|
|
let tid = null;
|
|
if (needsTracking) {
|
|
tid = uid();
|
|
html.push(` data-tid="${tid}"`);
|
|
tagElements[tid] = { attrs, context };
|
|
}
|
|
for (const [key, value] of Object.entries(attrs)) {
|
|
if (!key.startsWith("$") && !key.startsWith("on") && !key.startsWith("@") && !key.startsWith("data-bind-") && !key.startsWith("data-on-") && (typeof value === "string" || typeof value === "number")) {
|
|
if (key === "id" && tid) {
|
|
html.push(` id="${value}:${context._cid}"`);
|
|
} else {
|
|
html.push(` ${key}="${value}"`);
|
|
}
|
|
}
|
|
}
|
|
if (selfClosing) {
|
|
html.push(" />");
|
|
} else {
|
|
html.push(">");
|
|
}
|
|
}
|
|
function process_component_to_html(instruction, html, components, context) {
|
|
const [componentName, props, contentFn] = instruction.comp;
|
|
const cid = uid();
|
|
get_component_class(componentName) || Component;
|
|
const template = get_template(componentName);
|
|
const tagName = props._tag || template.tag || "div";
|
|
html.push(`<${tagName} data-cid="${cid}"`);
|
|
if (props["data-id"]) {
|
|
const baseId = props["data-id"];
|
|
html.push(` id="${props["id"]}" data-id="${baseId}"`);
|
|
} else if (props["id"]) {
|
|
html.push(` id="${props["id"]}"`);
|
|
}
|
|
html.push("></" + tagName + ">");
|
|
components[cid] = {
|
|
name: componentName,
|
|
props,
|
|
contentFn,
|
|
context
|
|
};
|
|
}
|
|
function process_slot_to_html(instruction, html, tagElements, components, context, parentSlots) {
|
|
const [slotName] = instruction.slot;
|
|
if (parentSlots && slotName in parentSlots) {
|
|
const parentSlot = parentSlots[slotName];
|
|
const [, slotProps, contentFn] = parentSlot.slot;
|
|
const [content] = contentFn.call(context, slotProps);
|
|
for (const item of content) {
|
|
process_instruction_to_html(item, html, tagElements, components, context);
|
|
}
|
|
} else if (slotName === "default" && instruction.slot[2]) {
|
|
const [, , defaultFn] = instruction.slot;
|
|
const [content] = defaultFn.call(context, {});
|
|
for (const item of content) {
|
|
process_instruction_to_html(item, html, tagElements, components, context);
|
|
}
|
|
}
|
|
}
|
|
function process_rawtag_to_html(instruction, html) {
|
|
const [tagName, attrs, rawContent] = instruction.rawtag;
|
|
html.push(`<${tagName}`);
|
|
for (const [key, value] of Object.entries(attrs)) {
|
|
if (typeof value === "string" || typeof value === "number") {
|
|
const escaped_value = String(value).replace(/"/g, """);
|
|
html.push(` ${key}="${escaped_value}"`);
|
|
} else if (typeof value === "boolean" && value) {
|
|
html.push(` ${key}`);
|
|
}
|
|
}
|
|
html.push(">");
|
|
const escaped_content = rawContent.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
|
html.push(escaped_content);
|
|
html.push(`</${tagName}>`);
|
|
}
|
|
function apply_attributes(element, attrs, context) {
|
|
for (const [key, value] of Object.entries(attrs)) {
|
|
if (key === "$id" || key === "id") {
|
|
continue;
|
|
} else if (key.startsWith("$")) {
|
|
const dataKey = key.substring(1);
|
|
element.data(dataKey, value);
|
|
context.args[dataKey] = value;
|
|
if (typeof value == "string" || typeof value == "number") {
|
|
const attrValue = typeof value === "string" ? value.trim() : value;
|
|
element.attr(`data-${dataKey}`, attrValue);
|
|
}
|
|
} else if (key.startsWith("data-on-")) {
|
|
const eventName = key.substring(8);
|
|
if (typeof value === "function") {
|
|
element.on(eventName, function(e) {
|
|
value.bind(context)(e, element);
|
|
});
|
|
} else {
|
|
console.warn("(JQHTML) Tried to assign a non function to on event handler " + key);
|
|
}
|
|
} else if (key.startsWith("on")) {
|
|
const eventName = key.substring(2);
|
|
if (typeof value === "function") {
|
|
element.on(eventName, function(e) {
|
|
value.bind(context)(e, element);
|
|
});
|
|
} else {
|
|
console.warn("(JQHTML) Tried to assign a non function to on event handler " + key);
|
|
}
|
|
} else if (key.startsWith("data-")) {
|
|
const attrValue = typeof value === "string" ? value.trim() : value;
|
|
element.attr(key, attrValue);
|
|
const dataKey = key.substring(5);
|
|
element.data(dataKey, value);
|
|
context.args[dataKey] = value;
|
|
} else if (key === "class") {
|
|
const existingClasses = element.attr("class");
|
|
if (window.jqhtml?.debug?.enabled) {
|
|
console.log(`[InstructionProcessor] Merging class attribute:`, {
|
|
existing: existingClasses,
|
|
new: value
|
|
});
|
|
}
|
|
if (!existingClasses) {
|
|
const attrValue = typeof value === "string" ? value.trim() : value;
|
|
element.attr("class", attrValue);
|
|
} else {
|
|
const existing = existingClasses.split(/\s+/).filter((c) => c);
|
|
const newClasses = String(value).split(/\s+/).filter((c) => c);
|
|
for (const newClass of newClasses) {
|
|
if (!existing.includes(newClass)) {
|
|
existing.push(newClass);
|
|
}
|
|
}
|
|
element.attr("class", existing.join(" "));
|
|
}
|
|
if (window.jqhtml?.debug?.enabled) {
|
|
console.log(`[InstructionProcessor] Class after merge:`, element.attr("class"));
|
|
}
|
|
} else if (key === "style") {
|
|
const existingStyle = element.attr("style");
|
|
if (!existingStyle) {
|
|
const attrValue = typeof value === "string" ? value.trim() : value;
|
|
element.attr("style", attrValue);
|
|
} else {
|
|
const styleMap = {};
|
|
existingStyle.split(";").forEach((rule) => {
|
|
const [prop, val] = rule.split(":").map((s) => s.trim());
|
|
if (prop && val) {
|
|
styleMap[prop] = val;
|
|
}
|
|
});
|
|
String(value).split(";").forEach((rule) => {
|
|
const [prop, val] = rule.split(":").map((s) => s.trim());
|
|
if (prop && val) {
|
|
styleMap[prop] = val;
|
|
}
|
|
});
|
|
const mergedStyle = Object.entries(styleMap).map(([prop, val]) => `${prop}: ${val}`).join("; ");
|
|
element.attr("style", mergedStyle);
|
|
}
|
|
} else {
|
|
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
|
|
const attrValue = typeof value === "string" ? value.trim() : String(value);
|
|
element.attr(key, attrValue);
|
|
} else if (typeof value === "object") {
|
|
console.warn(`(JQHTML) Unexpected value for '${key}' on`, element);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async function initialize_component(element, compData) {
|
|
const { name, props, contentFn, context } = compData;
|
|
const ComponentClass = get_component_class(name) || Component;
|
|
const invocationAttrs = {};
|
|
for (const [key, value] of Object.entries(props)) {
|
|
if (!key.startsWith("_")) {
|
|
invocationAttrs[key] = value;
|
|
}
|
|
}
|
|
if (window.jqhtml?.debug?.enabled) {
|
|
console.log(`[InstructionProcessor] Applying invocation attributes for ${name}:`, invocationAttrs);
|
|
}
|
|
apply_attributes(element, invocationAttrs, context);
|
|
const options = {};
|
|
if (contentFn) {
|
|
options._innerhtml_function = contentFn;
|
|
}
|
|
if (ComponentClass.name !== name) {
|
|
options._component_name = name;
|
|
}
|
|
const instance = new ComponentClass(element, options);
|
|
instance._instantiator = context;
|
|
await instance.boot();
|
|
}
|
|
function extract_slots(instructions) {
|
|
const slots = {};
|
|
for (const instruction of instructions) {
|
|
if (typeof instruction === "object" && "slot" in instruction) {
|
|
const [name] = instruction.slot;
|
|
slots[name] = instruction;
|
|
}
|
|
}
|
|
return slots;
|
|
}
|
|
var performanceMetrics = /* @__PURE__ */ new Map();
|
|
function devWarn(message) {
|
|
if (typeof window !== "undefined" && window.JQHTML_SUPPRESS_WARNINGS) {
|
|
return;
|
|
}
|
|
if (typeof process !== "undefined" && process.env && false) {
|
|
return;
|
|
}
|
|
console.warn(`[JQHTML Dev Warning] ${message}`);
|
|
}
|
|
function getJqhtml$1() {
|
|
if (typeof window !== "undefined" && window.jqhtml) {
|
|
return window.jqhtml;
|
|
}
|
|
if (typeof globalThis !== "undefined" && globalThis.jqhtml) {
|
|
return globalThis.jqhtml;
|
|
}
|
|
throw new Error("FATAL: window.jqhtml is not defined. The JQHTML runtime must be loaded before using debug features. Import and initialize @jqhtml/core before attempting to use debug functionality.");
|
|
}
|
|
function flashComponent(component, eventType) {
|
|
const jqhtml2 = getJqhtml$1();
|
|
if (!jqhtml2?.debug?.flashComponents)
|
|
return;
|
|
const duration = jqhtml2.debug.flashDuration || 500;
|
|
const colors = jqhtml2.debug.flashColors || {};
|
|
const color = colors[eventType] || (eventType === "create" ? "#3498db" : eventType === "render" ? "#27ae60" : "#9b59b6");
|
|
const originalBorder = component.$.css("border");
|
|
component.$.css({
|
|
"border": `2px solid ${color}`,
|
|
"transition": `border ${duration}ms ease-out`
|
|
});
|
|
setTimeout(() => {
|
|
component.$.css("border", originalBorder || "");
|
|
}, duration);
|
|
}
|
|
function logLifecycle(component, phase, status) {
|
|
const jqhtml2 = getJqhtml$1();
|
|
if (!jqhtml2?.debug)
|
|
return;
|
|
const shouldLog = jqhtml2.debug.logFullLifecycle || jqhtml2.debug.logCreationReady && (phase === "create" || phase === "ready");
|
|
if (!shouldLog)
|
|
return;
|
|
const componentName = component.constructor.name;
|
|
const timestamp = (/* @__PURE__ */ new Date()).toISOString();
|
|
const prefix = `[JQHTML ${timestamp}]`;
|
|
if (status === "start") {
|
|
console.log(`${prefix} ${componentName}#${component._cid} \u2192 ${phase} starting...`);
|
|
if (jqhtml2.debug.profilePerformance) {
|
|
performanceMetrics.set(`${component._cid}_${phase}`, Date.now());
|
|
}
|
|
} else {
|
|
let message = `${prefix} ${componentName}#${component._cid} \u2713 ${phase} complete`;
|
|
if (jqhtml2.debug.profilePerformance) {
|
|
const startTime = performanceMetrics.get(`${component._cid}_${phase}`);
|
|
if (startTime) {
|
|
const duration = Date.now() - startTime;
|
|
message += ` (${duration}ms)`;
|
|
if (phase === "render" && jqhtml2.debug.highlightSlowRenders && duration > jqhtml2.debug.highlightSlowRenders) {
|
|
console.warn(`${prefix} SLOW RENDER: ${componentName}#${component._cid} took ${duration}ms`);
|
|
component.$.css("outline", "2px dashed red");
|
|
}
|
|
}
|
|
}
|
|
console.log(message);
|
|
if (jqhtml2.debug.flashComponents && (phase === "create" || phase === "render" || phase === "ready")) {
|
|
flashComponent(component, phase);
|
|
}
|
|
}
|
|
if (jqhtml2.debug.showComponentTree) {
|
|
updateComponentTree();
|
|
}
|
|
}
|
|
function applyDebugDelay(phase) {
|
|
const jqhtml2 = getJqhtml$1();
|
|
if (!jqhtml2?.debug)
|
|
return;
|
|
let delayMs = 0;
|
|
switch (phase) {
|
|
case "component":
|
|
delayMs = jqhtml2.debug.delayAfterComponent || 0;
|
|
break;
|
|
case "render":
|
|
delayMs = jqhtml2.debug.delayAfterRender || 0;
|
|
break;
|
|
case "rerender":
|
|
delayMs = jqhtml2.debug.delayAfterRerender || 0;
|
|
break;
|
|
}
|
|
if (delayMs > 0) {
|
|
console.log(`[JQHTML Debug] Applying ${delayMs}ms delay after ${phase}`);
|
|
}
|
|
}
|
|
function updateComponentTree() {
|
|
console.log("[JQHTML Tree] Component hierarchy updated");
|
|
}
|
|
var Component = class _Jqhtml_Component {
|
|
constructor(element, args = {}) {
|
|
this.data = {};
|
|
this._ready_state = 0;
|
|
this._instantiator = null;
|
|
this._dom_parent = null;
|
|
this._dom_children = /* @__PURE__ */ new Set();
|
|
this._use_dom_fallback = false;
|
|
this._stopped = false;
|
|
this._booted = false;
|
|
this._data_before_render = null;
|
|
this._lifecycle_callbacks = /* @__PURE__ */ new Map();
|
|
this._lifecycle_states = /* @__PURE__ */ new Set();
|
|
this.__loading = false;
|
|
this._did_first_render = false;
|
|
this._render_count = 0;
|
|
this._cid = this._generate_cid();
|
|
this._lifecycle_manager = LifecycleManager.get_instance();
|
|
if (element) {
|
|
this.$ = $(element);
|
|
} else {
|
|
const div = document.createElement("div");
|
|
this.$ = $(div);
|
|
}
|
|
const dataAttrs = {};
|
|
if (this.$.length > 0) {
|
|
const dataset = this.$[0].dataset || {};
|
|
for (const key in dataset) {
|
|
if (key !== "cid" && key !== "tid" && key !== "componentName" && key !== "readyState") {
|
|
const dataValue = this.$.data(key);
|
|
if (dataValue !== void 0 && dataValue !== dataset[key]) {
|
|
dataAttrs[key] = dataValue;
|
|
} else {
|
|
dataAttrs[key] = dataset[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let template_for_args;
|
|
if (args._component_name) {
|
|
template_for_args = get_template(args._component_name);
|
|
} else {
|
|
template_for_args = get_template_by_class(this.constructor);
|
|
}
|
|
const defineArgs = template_for_args?.defineArgs || {};
|
|
this.args = { ...defineArgs, ...dataAttrs, ...args };
|
|
for (const [key, value] of Object.entries(this.args)) {
|
|
if (key === "cid" || key === "tid" || key === "componentName" || key === "readyState" || key.startsWith("_")) {
|
|
continue;
|
|
}
|
|
if (typeof value === "string" || typeof value === "number") {
|
|
try {
|
|
const currentAttr = this.$.attr(`data-${key}`);
|
|
if (currentAttr != value) {
|
|
this.$.attr(`data-${key}`, String(value));
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
this.$.data("_component", this);
|
|
this._apply_css_classes();
|
|
this._apply_default_attributes();
|
|
this._set_attributes();
|
|
this._find_dom_parent();
|
|
this._log_lifecycle("construct", "complete");
|
|
}
|
|
/**
|
|
* Boot - Start the full component lifecycle
|
|
* Called immediately after construction by instruction processor
|
|
*/
|
|
async boot() {
|
|
if (this._booted)
|
|
return;
|
|
this._booted = true;
|
|
await this._lifecycle_manager.boot_component(this);
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
// Lifecycle Methods (called by LifecycleManager)
|
|
// -------------------------------------------------------------------------
|
|
/**
|
|
* 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 = null) {
|
|
this._render_count++;
|
|
const current_render_id = this._render_count;
|
|
if (this._stopped)
|
|
return current_render_id;
|
|
if (id) {
|
|
const $element = this.$id(id);
|
|
if ($element.length === 0) {
|
|
throw new Error(`[JQHTML] render("${id}") - no such id.
|
|
Component "${this.component_name()}" has no child element with $id="${id}".`);
|
|
}
|
|
const child = $element.data("_component");
|
|
if (!child) {
|
|
throw new Error(`[JQHTML] render("${id}") - element is not a component or does not have $redrawable attribute set.
|
|
Element with $id="${id}" exists but is not initialized as a component.
|
|
Add $redrawable attribute or make it a proper component.`);
|
|
}
|
|
return child._render();
|
|
}
|
|
if (this.__loading) {
|
|
throw new Error(`[JQHTML] Component "${this.component_name()}" attempted to call render() during on_load().
|
|
on_load() should ONLY modify this.data. DOM updates happen automatically after on_load() completes.
|
|
|
|
Fix: Remove the this.render() call from on_load().
|
|
The framework will automatically re-render if this.data changes during on_load().`);
|
|
}
|
|
this._log_lifecycle("render", "start");
|
|
if (!$.contains(document.documentElement, this.$[0])) {
|
|
this._use_dom_fallback = true;
|
|
} else {
|
|
this._use_dom_fallback = false;
|
|
}
|
|
if (this._did_first_render) {
|
|
this.$.find(".Component").each(function() {
|
|
const child = $(this).data("_component");
|
|
if (child && !child._stopped) {
|
|
child._stop();
|
|
}
|
|
});
|
|
this.$[0].innerHTML = "";
|
|
} else {
|
|
this._did_first_render = true;
|
|
}
|
|
this.$.removeClass("_Component_Stopped");
|
|
if (this._data_before_render === null) {
|
|
this._data_before_render = JSON.stringify(this.data);
|
|
}
|
|
this._dom_children.clear();
|
|
let template_def;
|
|
if (this.args._component_name) {
|
|
template_def = get_template(this.args._component_name);
|
|
} else {
|
|
template_def = get_template_by_class(this.constructor);
|
|
}
|
|
if (template_def && template_def.render) {
|
|
const jqhtml2 = {
|
|
escape_html: (str) => {
|
|
const div = document.createElement("div");
|
|
div.textContent = String(str);
|
|
return div.innerHTML;
|
|
}
|
|
};
|
|
const defaultContent = () => "";
|
|
let [instructions, context] = template_def.render.bind(this)(
|
|
this.data,
|
|
this.args,
|
|
this.args._innerhtml_function || defaultContent,
|
|
// Content function with fallback
|
|
jqhtml2
|
|
// Utilities object
|
|
);
|
|
if (instructions && typeof instructions === "object" && instructions._slots && !Array.isArray(instructions)) {
|
|
const componentName = template_def.name || this.args._component_name || this.constructor.name;
|
|
console.log(`[JQHTML] Slot-only template detected for ${componentName}`);
|
|
let parentTemplate = null;
|
|
let parentTemplateName = null;
|
|
if (template_def.extends) {
|
|
console.log(`[JQHTML] Using explicit extends: ${template_def.extends}`);
|
|
parentTemplate = get_template(template_def.extends);
|
|
parentTemplateName = template_def.extends;
|
|
}
|
|
if (!parentTemplate) {
|
|
let currentClass = Object.getPrototypeOf(this.constructor);
|
|
while (currentClass && currentClass.name !== "Object" && currentClass.name !== "Component") {
|
|
const className = currentClass.name;
|
|
console.log(`[JQHTML] Checking parent: ${className}`);
|
|
try {
|
|
const classTemplate = get_template(className);
|
|
if (classTemplate && classTemplate.name !== "Component") {
|
|
console.log(`[JQHTML] Found parent template: ${className}`);
|
|
parentTemplate = classTemplate;
|
|
parentTemplateName = className;
|
|
break;
|
|
}
|
|
} catch (error) {
|
|
console.warn(`[JQHTML] Error finding parent template ${className}:`, error);
|
|
}
|
|
currentClass = Object.getPrototypeOf(currentClass);
|
|
}
|
|
}
|
|
if (parentTemplate) {
|
|
try {
|
|
const childSlots = instructions._slots;
|
|
const contentFunction = (slotName, data) => {
|
|
if (childSlots[slotName] && typeof childSlots[slotName] === "function") {
|
|
const [slotInstructions, slotContext] = childSlots[slotName](data);
|
|
return [slotInstructions, slotContext];
|
|
}
|
|
return "";
|
|
};
|
|
const [parentInstructions, parentContext] = parentTemplate.render.bind(this)(
|
|
this.data,
|
|
this.args,
|
|
contentFunction,
|
|
// Pass content function that invokes child slots
|
|
jqhtml2
|
|
);
|
|
console.log(`[JQHTML] Parent template invoked successfully`);
|
|
instructions = parentInstructions;
|
|
context = parentContext;
|
|
} catch (error) {
|
|
console.warn(`[JQHTML] Error invoking parent template ${parentTemplateName}:`, error);
|
|
instructions = [];
|
|
}
|
|
} else {
|
|
console.warn(`[JQHTML] No parent template found for ${this.constructor.name}, rendering empty`);
|
|
instructions = [];
|
|
}
|
|
}
|
|
const flattenedInstructions = this._flatten_instructions(instructions);
|
|
process_instructions(flattenedInstructions, this.$, this);
|
|
}
|
|
this._update_debug_attrs();
|
|
this._log_lifecycle("render", "complete");
|
|
const renderResult = this.on_render();
|
|
if (renderResult && typeof renderResult.then === "function") {
|
|
console.warn(`[JQHTML] Component "${this.component_name()}" returned a Promise from on_render(). on_render() must be synchronous code. Remove 'async' from the function declaration.`);
|
|
}
|
|
this.trigger("render");
|
|
const isRerender = this._ready_state >= 3;
|
|
applyDebugDelay(isRerender ? "rerender" : "render");
|
|
return current_render_id;
|
|
}
|
|
/**
|
|
* 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 = null) {
|
|
if (this._stopped)
|
|
return;
|
|
if (id) {
|
|
const $element = this.$id(id);
|
|
if ($element.length === 0) {
|
|
throw new Error(`[JQHTML] render("${id}") - no such id.
|
|
Component "${this.component_name()}" has no child element with $id="${id}".`);
|
|
}
|
|
const child = $element.data("_component");
|
|
if (!child) {
|
|
throw new Error(`[JQHTML] render("${id}") - element is not a component or does not have $redrawable attribute set.
|
|
Element with $id="${id}" exists but is not initialized as a component.
|
|
Add $redrawable attribute or make it a proper component.`);
|
|
}
|
|
return child.render();
|
|
}
|
|
const render_id = this._render();
|
|
(async () => {
|
|
await this._wait_for_children_ready();
|
|
if (this._render_count !== render_id) {
|
|
return;
|
|
}
|
|
await this.on_ready();
|
|
await this.trigger("ready");
|
|
})();
|
|
}
|
|
/**
|
|
* Alias for render() - re-renders component with current data
|
|
* Provided for API consistency and clarity
|
|
*/
|
|
redraw(id = null) {
|
|
return this.render(id);
|
|
}
|
|
/**
|
|
* Create phase - Quick setup, prepare UI
|
|
* Called bottom-up (children before parent)
|
|
*/
|
|
async create() {
|
|
if (this._stopped || this._ready_state >= 1)
|
|
return;
|
|
this._log_lifecycle("create", "start");
|
|
const result = this.on_create();
|
|
if (result && typeof result.then === "function") {
|
|
console.warn(`[JQHTML] Component "${this.component_name()}" returned a Promise from on_create(). on_create() must be synchronous code. Remove 'async' from the function declaration.`);
|
|
await result;
|
|
}
|
|
this._ready_state = 1;
|
|
this._update_debug_attrs();
|
|
this._log_lifecycle("create", "complete");
|
|
this.trigger("create");
|
|
}
|
|
/**
|
|
* Load phase - Fetch data from APIs
|
|
* Called bottom-up, fully parallel
|
|
* NO DOM MODIFICATIONS ALLOWED IN THIS PHASE
|
|
*/
|
|
async load() {
|
|
if (this._stopped || this._ready_state >= 2)
|
|
return;
|
|
this._log_lifecycle("load", "start");
|
|
const argsBeforeLoad = JSON.stringify(this.args);
|
|
const propertiesBeforeLoad = new Set(Object.keys(this));
|
|
this.__loading = true;
|
|
try {
|
|
await this.on_load();
|
|
} finally {
|
|
this.__loading = false;
|
|
}
|
|
const argsAfterLoad = JSON.stringify(this.args);
|
|
const propertiesAfterLoad = Object.keys(this);
|
|
if (argsBeforeLoad !== argsAfterLoad) {
|
|
console.error(`[JQHTML] WARNING: Component "${this.component_name()}" modified this.args in on_load().
|
|
on_load() should ONLY modify this.data. The this.args property is read-only.
|
|
|
|
Before: ${argsBeforeLoad}
|
|
After: ${argsAfterLoad}
|
|
|
|
Fix: Move your modifications to this.data instead.`);
|
|
}
|
|
const newProperties = propertiesAfterLoad.filter((prop) => !propertiesBeforeLoad.has(prop) && prop !== "data");
|
|
if (newProperties.length > 0) {
|
|
console.error(`[JQHTML] WARNING: Component "${this.component_name()}" added new properties in on_load().
|
|
on_load() should ONLY modify this.data. New properties detected: ${newProperties.join(", ")}
|
|
|
|
Fix: Store your data in this.data instead:
|
|
\u274C this.${newProperties[0]} = value;
|
|
\u2705 this.data.${newProperties[0]} = value;`);
|
|
}
|
|
this._ready_state = 2;
|
|
this._update_debug_attrs();
|
|
this._log_lifecycle("load", "complete");
|
|
this.trigger("load");
|
|
}
|
|
/**
|
|
* Ready phase - Component fully initialized
|
|
* Called bottom-up (children before parent)
|
|
*/
|
|
async ready() {
|
|
if (this._stopped || this._ready_state >= 4)
|
|
return;
|
|
this._log_lifecycle("ready", "start");
|
|
await this._wait_for_children_ready();
|
|
await this.on_ready();
|
|
this._ready_state = 4;
|
|
this._update_debug_attrs();
|
|
this._log_lifecycle("ready", "complete");
|
|
this.trigger("ready");
|
|
}
|
|
/**
|
|
* Wait for all child components to reach ready state
|
|
* Ensures bottom-up ordering (children ready before parent)
|
|
* @private
|
|
*/
|
|
async _wait_for_children_ready() {
|
|
const children = this._get_dom_children();
|
|
if (children.length === 0) {
|
|
return;
|
|
}
|
|
const ready_promises = [];
|
|
for (const child of children) {
|
|
if (child._ready_state >= 4) {
|
|
continue;
|
|
}
|
|
const ready_promise = new Promise((resolve) => {
|
|
child.on("ready", () => resolve());
|
|
});
|
|
ready_promises.push(ready_promise);
|
|
}
|
|
await Promise.all(ready_promises);
|
|
}
|
|
/**
|
|
* Reinitialize the component - full reset and re-initialization
|
|
* Wipes the innerHTML, resets data to empty, and runs full lifecycle
|
|
*/
|
|
async reinitialize() {
|
|
if (this._stopped)
|
|
return;
|
|
this._log_lifecycle("reinitialize", "start");
|
|
this.$[0].innerHTML = "";
|
|
this.data = {};
|
|
this._ready_state = 0;
|
|
this._data_before_render = null;
|
|
this._dom_children.clear();
|
|
await this._render();
|
|
await this.create();
|
|
await this.load();
|
|
if (this.should_rerender()) {
|
|
await this._render();
|
|
}
|
|
await this.ready();
|
|
this._log_lifecycle("reinitialize", "complete");
|
|
}
|
|
/**
|
|
* Reload component - re-fetch data and re-render
|
|
* Re-runs on_load(), always renders, and calls on_ready()
|
|
*/
|
|
async reload() {
|
|
if (this._stopped)
|
|
return;
|
|
this._log_lifecycle("reload", "start");
|
|
const has_custom_on_load = this.on_load !== _Jqhtml_Component.prototype.on_load;
|
|
if (has_custom_on_load) {
|
|
const argsBeforeLoad = JSON.stringify(this.args);
|
|
const propertiesBeforeLoad = new Set(Object.keys(this));
|
|
this.__loading = true;
|
|
try {
|
|
await this.on_load();
|
|
} finally {
|
|
this.__loading = false;
|
|
}
|
|
const argsAfterLoad = JSON.stringify(this.args);
|
|
const propertiesAfterLoad = Object.keys(this);
|
|
if (argsBeforeLoad !== argsAfterLoad) {
|
|
console.error(`[JQHTML] WARNING: Component "${this.component_name()}" modified this.args in on_load().
|
|
on_load() should ONLY modify this.data. The this.args property is read-only.
|
|
|
|
Before: ${argsBeforeLoad}
|
|
After: ${argsAfterLoad}
|
|
|
|
Fix: Move your modifications to this.data instead.`);
|
|
}
|
|
const newProperties = propertiesAfterLoad.filter((prop) => !propertiesBeforeLoad.has(prop) && prop !== "data");
|
|
if (newProperties.length > 0) {
|
|
console.error(`[JQHTML] WARNING: Component "${this.component_name()}" added new properties in on_load().
|
|
on_load() should ONLY modify this.data. New properties detected: ${newProperties.join(", ")}
|
|
|
|
Fix: Store your data in this.data instead:
|
|
\u274C this.${newProperties[0]} = value;
|
|
\u2705 this.data.${newProperties[0]} = value;`);
|
|
}
|
|
}
|
|
await this.render();
|
|
this._log_lifecycle("reload", "complete");
|
|
}
|
|
/**
|
|
* 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() {
|
|
if (this._stopped)
|
|
return;
|
|
this._stopped = true;
|
|
const has_custom_destroy = this.on_destroy !== _Jqhtml_Component.prototype.on_destroy;
|
|
const has_destroy_callbacks = this._on_registered("destroy");
|
|
if (!has_custom_destroy && !has_destroy_callbacks) {
|
|
this._lifecycle_manager.unregister_component(this);
|
|
this._ready_state = 99;
|
|
return;
|
|
}
|
|
this._log_lifecycle("destroy", "start");
|
|
this.$.addClass("_Component_Stopped");
|
|
this._lifecycle_manager.unregister_component(this);
|
|
const destroyResult = this.on_destroy();
|
|
if (destroyResult && typeof destroyResult.then === "function") {
|
|
console.warn(`[JQHTML] Component "${this.component_name()}" returned a Promise from on_destroy(). on_destroy() must be synchronous code. Remove 'async' from the function declaration.`);
|
|
}
|
|
this.trigger("destroy");
|
|
this.$.trigger("destroy");
|
|
if (this._dom_parent) {
|
|
this._dom_parent._dom_children.delete(this);
|
|
}
|
|
this._ready_state = 99;
|
|
this._update_debug_attrs();
|
|
this._log_lifecycle("destroy", "complete");
|
|
}
|
|
/**
|
|
* Stop component lifecycle - stops all descendant components then self
|
|
* Leaves DOM intact, just stops lifecycle engine and fires cleanup hooks
|
|
*/
|
|
stop() {
|
|
this.$.find(".Component").each(function() {
|
|
const child = $(this).data("_component");
|
|
if (child && !child._stopped) {
|
|
child._stop();
|
|
}
|
|
});
|
|
this._stop();
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
// Overridable Lifecycle Hooks
|
|
// -------------------------------------------------------------------------
|
|
on_render() {
|
|
}
|
|
on_create() {
|
|
}
|
|
async on_load() {
|
|
}
|
|
async on_ready() {
|
|
}
|
|
on_destroy() {
|
|
}
|
|
/**
|
|
* Should component re-render after load?
|
|
* By default, only re-renders if data has changed
|
|
* Override to control re-rendering behavior
|
|
*/
|
|
should_rerender() {
|
|
const currentDataState = JSON.stringify(this.data);
|
|
const dataChanged = this._data_before_render !== currentDataState;
|
|
if (dataChanged) {
|
|
this._data_before_render = currentDataState;
|
|
}
|
|
return dataChanged;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
// Public API
|
|
// -------------------------------------------------------------------------
|
|
/**
|
|
* Get component name for debugging
|
|
*/
|
|
component_name() {
|
|
return this.constructor.name;
|
|
}
|
|
/**
|
|
* Emit a jQuery event from component root
|
|
*/
|
|
emit(event_name, data) {
|
|
this._log_debug("emit", event_name, data);
|
|
this.$.trigger(event_name, data);
|
|
}
|
|
/**
|
|
* Register lifecycle event callback
|
|
* Allowed events: 'render', 'create', 'load', 'ready', 'destroy'
|
|
* Callbacks fire after the lifecycle method completes
|
|
* If the event has already occurred, the callback fires immediately AND registers for future occurrences
|
|
*/
|
|
on(event_name, callback) {
|
|
const allowed_events = ["render", "create", "load", "ready", "destroy"];
|
|
if (!allowed_events.includes(event_name)) {
|
|
console.error(`[JQHTML] Component.on() only supports lifecycle events: ${allowed_events.join(", ")}. Received: ${event_name}`);
|
|
return this;
|
|
}
|
|
if (!this._lifecycle_callbacks.has(event_name)) {
|
|
this._lifecycle_callbacks.set(event_name, []);
|
|
}
|
|
this._lifecycle_callbacks.get(event_name).push(callback);
|
|
if (this._lifecycle_states.has(event_name)) {
|
|
try {
|
|
callback(this);
|
|
} catch (error) {
|
|
console.error(`[JQHTML] Error in ${event_name} callback:`, error);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Trigger a lifecycle event - fires all registered callbacks
|
|
* Marks event as occurred so future .on() calls fire immediately
|
|
*/
|
|
trigger(event_name) {
|
|
this._lifecycle_states.add(event_name);
|
|
const callbacks = this._lifecycle_callbacks.get(event_name);
|
|
if (callbacks) {
|
|
for (const callback of callbacks) {
|
|
try {
|
|
callback.bind(this)(this);
|
|
} catch (error) {
|
|
console.error(`[JQHTML] Error in ${event_name} callback:`, error);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Check if any callbacks are registered for a given event
|
|
* Used to determine if cleanup logic needs to run
|
|
*/
|
|
_on_registered(event_name) {
|
|
const callbacks = this._lifecycle_callbacks.get(event_name);
|
|
return !!(callbacks && callbacks.length > 0);
|
|
}
|
|
/**
|
|
* Find element by scoped ID
|
|
*
|
|
* Searches for elements with id="local_id:THIS_COMPONENT_CID"
|
|
*
|
|
* Example:
|
|
* Template: <button $id="save_btn">Save</button>
|
|
* Rendered: <button id="save_btn:abc123" data-id="save_btn">Save</button>
|
|
* Access: this.$id('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
|
|
*/
|
|
$id(local_id) {
|
|
const scopedId = `${local_id}:${this._cid}`;
|
|
const el = document.getElementById(scopedId);
|
|
if (el) {
|
|
return $(el);
|
|
}
|
|
return this.$.find(`#${$.escapeSelector(scopedId)}`);
|
|
}
|
|
/**
|
|
* Get component instance by scoped ID
|
|
*
|
|
* Convenience method that finds element by scoped ID and returns the component instance.
|
|
*
|
|
* Example:
|
|
* Template: <User_Card $id="active_user" />
|
|
* Access: const user = this.id('active_user'); // Returns User_Card instance
|
|
* user.data.name // Access component's data
|
|
*
|
|
* @param local_id The local ID (without _cid suffix)
|
|
* @returns Component instance or null if not found or not a component
|
|
*/
|
|
id(local_id) {
|
|
const element = this.$id(local_id);
|
|
const component = element.data("_component");
|
|
if (!component && element.length > 0) {
|
|
console.warn(`Component ${this.constructor.name} tried to call .id('${local_id}') - ${local_id} exists, however, it is not a component or $redrawable. Did you forget to add $redrawable to the tag?`);
|
|
}
|
|
return component || null;
|
|
}
|
|
/**
|
|
* Get the component that instantiated this component (rendered it in their template)
|
|
* Returns null if component was created programmatically via $().component()
|
|
*/
|
|
instantiator() {
|
|
return this._instantiator;
|
|
}
|
|
/**
|
|
* Find descendant components by CSS selector
|
|
*/
|
|
find(selector) {
|
|
const components = [];
|
|
this.$.find(selector).each((_, el) => {
|
|
const comp = $(el).data("_component");
|
|
if (comp instanceof _Jqhtml_Component) {
|
|
components.push(comp);
|
|
}
|
|
});
|
|
return components;
|
|
}
|
|
/**
|
|
* Find closest ancestor component matching selector
|
|
*/
|
|
closest(selector) {
|
|
let current = this.$.parent();
|
|
while (current.length > 0) {
|
|
if (current.is(selector)) {
|
|
const comp = current.data("_component");
|
|
if (comp instanceof _Jqhtml_Component) {
|
|
return comp;
|
|
}
|
|
}
|
|
current = current.parent();
|
|
}
|
|
return null;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
// Static Methods
|
|
// -------------------------------------------------------------------------
|
|
/**
|
|
* Get CSS class hierarchy for this component type
|
|
*/
|
|
static get_class_hierarchy() {
|
|
const classes = [];
|
|
let ctor = this;
|
|
while (ctor) {
|
|
if (!ctor.name || typeof ctor.name !== "string") {
|
|
break;
|
|
}
|
|
if (ctor.name !== "Object" && ctor.name !== "") {
|
|
let normalizedName = ctor.name;
|
|
if (normalizedName === "_Jqhtml_Component" || normalizedName === "_Base_Jqhtml_Component") {
|
|
normalizedName = "Component";
|
|
}
|
|
classes.push(normalizedName);
|
|
}
|
|
const nextProto = Object.getPrototypeOf(ctor);
|
|
if (!nextProto || nextProto === Object.prototype || nextProto.constructor === Object) {
|
|
break;
|
|
}
|
|
ctor = nextProto;
|
|
}
|
|
return classes;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
// Private Implementation
|
|
// -------------------------------------------------------------------------
|
|
_generate_cid() {
|
|
return uid();
|
|
}
|
|
/**
|
|
* Flatten instruction array - converts ['_content', [...]] markers to flat array
|
|
* Recursively flattens nested content from content() calls
|
|
*/
|
|
_flatten_instructions(instructions) {
|
|
const result = [];
|
|
for (const instruction of instructions) {
|
|
if (Array.isArray(instruction) && instruction[0] === "_content" && Array.isArray(instruction[1])) {
|
|
const contentInstructions = this._flatten_instructions(instruction[1]);
|
|
result.push(...contentInstructions);
|
|
} else {
|
|
result.push(instruction);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
_apply_css_classes() {
|
|
const hierarchy = this.constructor.get_class_hierarchy();
|
|
const classesToAdd = [...hierarchy];
|
|
if (this.args._component_name && this.args._component_name !== this.constructor.name) {
|
|
classesToAdd.unshift(this.args._component_name);
|
|
}
|
|
const publicClasses = classesToAdd.filter((className) => {
|
|
if (!className || typeof className !== "string") {
|
|
console.warn("[JQHTML] Filtered out invalid class name:", className);
|
|
return false;
|
|
}
|
|
return !className.startsWith("_");
|
|
});
|
|
if (publicClasses.length > 0) {
|
|
this.$.addClass(publicClasses.join(" "));
|
|
}
|
|
}
|
|
_apply_default_attributes() {
|
|
let template;
|
|
if (this.args._component_name) {
|
|
template = get_template(this.args._component_name);
|
|
} else {
|
|
template = get_template_by_class(this.constructor);
|
|
}
|
|
if (template && template.defaultAttributes) {
|
|
const defineAttrs = { ...template.defaultAttributes };
|
|
delete defineAttrs.tag;
|
|
if (window.jqhtml?.debug?.enabled) {
|
|
const componentName = template.name || this.args._component_name || this.constructor.name;
|
|
console.log(`[Component] Applying defaultAttributes for ${componentName}:`, defineAttrs);
|
|
}
|
|
for (const [key, value] of Object.entries(defineAttrs)) {
|
|
if (key === "class") {
|
|
const existingClasses = this.$.attr("class");
|
|
if (existingClasses) {
|
|
const existing = existingClasses.split(/\s+/).filter((c) => c);
|
|
const newClasses = String(value).split(/\s+/).filter((c) => c);
|
|
for (const newClass of newClasses) {
|
|
if (!existing.includes(newClass)) {
|
|
existing.push(newClass);
|
|
}
|
|
}
|
|
this.$.attr("class", existing.join(" "));
|
|
} else {
|
|
this.$.attr("class", value);
|
|
}
|
|
} else if (key === "style") {
|
|
const existingStyle = this.$.attr("style");
|
|
if (existingStyle) {
|
|
const existingRules = /* @__PURE__ */ new Map();
|
|
existingStyle.split(";").forEach((rule) => {
|
|
const [prop, val] = rule.split(":").map((s) => s.trim());
|
|
if (prop && val)
|
|
existingRules.set(prop, val);
|
|
});
|
|
String(value).split(";").forEach((rule) => {
|
|
const [prop, val] = rule.split(":").map((s) => s.trim());
|
|
if (prop && val)
|
|
existingRules.set(prop, val);
|
|
});
|
|
const merged = Array.from(existingRules.entries()).map(([prop, val]) => `${prop}: ${val}`).join("; ");
|
|
this.$.attr("style", merged);
|
|
} else {
|
|
this.$.attr("style", value);
|
|
}
|
|
} else if (key.startsWith("$") || key.startsWith("data-")) {
|
|
const dataKey = key.startsWith("$") ? key.substring(1) : key.startsWith("data-") ? key.substring(5) : key;
|
|
if (!(dataKey in this.args)) {
|
|
this.args[dataKey] = value;
|
|
this.$.data(dataKey, value);
|
|
this.$.attr(key.startsWith("$") ? `data-${dataKey}` : key, String(value));
|
|
}
|
|
} else {
|
|
if (!this.$.attr(key)) {
|
|
this.$.attr(key, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_set_attributes() {
|
|
this.$.attr("data-cid", this._cid);
|
|
if (window.jqhtml?.debug?.verbose) {
|
|
this.$.attr("data-_lifecycle-state", this._ready_state.toString());
|
|
}
|
|
}
|
|
_update_debug_attrs() {
|
|
if (window.jqhtml?.debug?.verbose) {
|
|
this.$.attr("data-_lifecycle-state", this._ready_state.toString());
|
|
}
|
|
}
|
|
_find_dom_parent() {
|
|
let current = this.$.parent();
|
|
while (current.length > 0) {
|
|
const parent = current.data("_component");
|
|
if (parent instanceof _Jqhtml_Component) {
|
|
this._dom_parent = parent;
|
|
parent._dom_children.add(this);
|
|
break;
|
|
}
|
|
current = current.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
|
|
*/
|
|
_get_dom_children() {
|
|
if (this._use_dom_fallback) {
|
|
const directChildren = [];
|
|
this.$.find(".Component").each((_, el) => {
|
|
const $el = $(el);
|
|
const comp = $el.data("_component");
|
|
if (comp instanceof _Jqhtml_Component) {
|
|
const closestParent = $el.parent().closest(".Component");
|
|
if (closestParent.length === 0 || closestParent.data("_component") === this) {
|
|
directChildren.push(comp);
|
|
}
|
|
}
|
|
});
|
|
return directChildren;
|
|
}
|
|
const children = Array.from(this._dom_children);
|
|
return children.filter((child) => {
|
|
return $.contains(document.documentElement, child.$[0]);
|
|
});
|
|
}
|
|
_log_lifecycle(phase, status) {
|
|
logLifecycle(this, phase, status);
|
|
if (typeof window !== "undefined" && window.JQHTML_DEBUG) {
|
|
window.JQHTML_DEBUG.log(this.component_name(), phase, status, {
|
|
cid: this._cid,
|
|
ready_state: this._ready_state,
|
|
args: this.args
|
|
});
|
|
}
|
|
}
|
|
_log_debug(action, ...args) {
|
|
if (typeof window !== "undefined" && window.JQHTML_DEBUG) {
|
|
window.JQHTML_DEBUG.log(this.component_name(), "debug", `${action}: ${args.map((a) => JSON.stringify(a)).join(", ")}`);
|
|
}
|
|
}
|
|
};
|
|
async function process_slot_inheritance(component, childSlots) {
|
|
let currentClass = Object.getPrototypeOf(component.constructor);
|
|
console.log(`[JQHTML] Walking prototype chain for ${component.constructor.name}`);
|
|
while (currentClass && currentClass !== Component && currentClass.name !== "Object") {
|
|
const className = currentClass.name;
|
|
console.log(`[JQHTML] Checking parent class: ${className}`);
|
|
if (className === "_Jqhtml_Component" || className === "_Base_Jqhtml_Component") {
|
|
currentClass = Object.getPrototypeOf(currentClass);
|
|
continue;
|
|
}
|
|
try {
|
|
const parentTemplate = get_template(className);
|
|
console.log(`[JQHTML] Template found for ${className}:`, parentTemplate ? parentTemplate.name : "null");
|
|
if (parentTemplate && parentTemplate.name !== "Component") {
|
|
console.log(`[JQHTML] Invoking parent template ${className}`);
|
|
const [parentInstructions, parentContext] = parentTemplate.render.call(
|
|
component,
|
|
component.data,
|
|
component.args,
|
|
childSlots
|
|
// Pass child slots as content parameter
|
|
);
|
|
if (parentInstructions && typeof parentInstructions === "object" && parentInstructions._slots) {
|
|
console.log(`[JQHTML] Parent also slot-only, recursing`);
|
|
return await process_slot_inheritance(component, parentInstructions._slots);
|
|
}
|
|
console.log(`[JQHTML] Parent returned instructions, inheritance complete`);
|
|
return [parentInstructions, parentContext];
|
|
}
|
|
} catch (error) {
|
|
console.warn(`[JQHTML] Error looking up parent template for ${className}:`, error);
|
|
}
|
|
currentClass = Object.getPrototypeOf(currentClass);
|
|
}
|
|
console.warn(`[JQHTML] No parent template found after walking chain`);
|
|
return null;
|
|
}
|
|
async function render_template(component, template_fn) {
|
|
let render_fn = template_fn;
|
|
if (!render_fn) {
|
|
const template_def = get_template_by_class(component.constructor);
|
|
render_fn = template_def.render;
|
|
}
|
|
if (!render_fn) {
|
|
return;
|
|
}
|
|
component.$.empty();
|
|
const defaultContent = () => "";
|
|
let [instructions, context] = render_fn.call(
|
|
component,
|
|
component.data,
|
|
component.args,
|
|
defaultContent
|
|
// Default content function that returns empty string
|
|
);
|
|
if (instructions && typeof instructions === "object" && instructions._slots) {
|
|
console.log(`[JQHTML] Slot-only template detected for ${component.constructor.name}, invoking inheritance`);
|
|
const result = await process_slot_inheritance(component, instructions._slots);
|
|
if (result) {
|
|
console.log(`[JQHTML] Parent template found, using parent instructions`);
|
|
instructions = result[0];
|
|
context = result[1];
|
|
} else {
|
|
console.warn(`[JQHTML] No parent template found for ${component.constructor.name}, rendering empty`);
|
|
instructions = [];
|
|
}
|
|
}
|
|
await process_instructions(instructions, component.$, component);
|
|
await process_bindings(component);
|
|
await attach_event_handlers(component);
|
|
}
|
|
async function process_bindings(component) {
|
|
component.$.find("[data-bind-prop], [data-bind-value], [data-bind-text], [data-bind-html], [data-bind-class], [data-bind-style]").each((_, element) => {
|
|
const el = $(element);
|
|
const attrs = element.attributes;
|
|
for (let i = 0; i < attrs.length; i++) {
|
|
const attr = attrs[i];
|
|
if (attr.name.startsWith("data-bind-")) {
|
|
const binding_type = attr.name.substring(10);
|
|
const expression = attr.value;
|
|
try {
|
|
const value = evaluate_expression(expression, component);
|
|
switch (binding_type) {
|
|
case "prop":
|
|
const prop_name = el.attr("data-bind-prop-name") || "value";
|
|
el.prop(prop_name, value);
|
|
break;
|
|
case "value":
|
|
el.val(value);
|
|
break;
|
|
case "text":
|
|
el.text(value);
|
|
break;
|
|
case "html":
|
|
el.html(value);
|
|
break;
|
|
case "class":
|
|
if (typeof value === "object") {
|
|
Object.entries(value).forEach(([className, enabled]) => {
|
|
el.toggleClass(className, !!enabled);
|
|
});
|
|
} else {
|
|
el.addClass(String(value));
|
|
}
|
|
break;
|
|
case "style":
|
|
if (typeof value === "object") {
|
|
el.css(value);
|
|
} else {
|
|
el.attr("style", String(value));
|
|
}
|
|
break;
|
|
default:
|
|
el.attr(binding_type, value);
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error evaluating binding "${expression}":`, error);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
async function attach_event_handlers(component) {
|
|
component.$.find("[data-on-click], [data-on-change], [data-on-submit], [data-on-keyup], [data-on-keydown], [data-on-focus], [data-on-blur]").each((_, element) => {
|
|
const el = $(element);
|
|
const attrs = element.attributes;
|
|
for (let i = 0; i < attrs.length; i++) {
|
|
const attr = attrs[i];
|
|
if (attr.name.startsWith("data-on-")) {
|
|
const event_name = attr.name.substring(8);
|
|
const handler_expr = attr.value;
|
|
el.removeAttr(attr.name);
|
|
el.on(event_name, function(event) {
|
|
try {
|
|
const handler = evaluate_handler(handler_expr, component);
|
|
if (typeof handler === "function") {
|
|
handler.call(component, event);
|
|
} else {
|
|
evaluate_expression(handler_expr, component, { $event: event });
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error in ${event_name} handler "${handler_expr}":`, error);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function evaluate_expression(expression, component, locals = {}) {
|
|
const context = {
|
|
// Component properties
|
|
data: component.data,
|
|
args: component.args,
|
|
$: component.$,
|
|
// Component methods
|
|
emit: component.emit.bind(component),
|
|
$id: component.$id.bind(component),
|
|
// Locals (like $event)
|
|
...locals
|
|
};
|
|
const keys = Object.keys(context);
|
|
const values = Object.values(context);
|
|
try {
|
|
const fn = new Function(...keys, `return (${expression})`);
|
|
return fn(...values);
|
|
} catch (error) {
|
|
console.error(`Invalid expression: ${expression}`, error);
|
|
return void 0;
|
|
}
|
|
}
|
|
function evaluate_handler(expression, component) {
|
|
if (expression in component && typeof component[expression] === "function") {
|
|
return component[expression];
|
|
}
|
|
try {
|
|
return new Function("$event", `
|
|
const { data, args, $, emit, $id } = this;
|
|
${expression}
|
|
`).bind(component);
|
|
} catch (error) {
|
|
console.error(`Invalid handler: ${expression}`, error);
|
|
return null;
|
|
}
|
|
}
|
|
function escape_html(str) {
|
|
const div = document.createElement("div");
|
|
div.textContent = str;
|
|
return div.innerHTML;
|
|
}
|
|
function getJQuery() {
|
|
if (typeof window !== "undefined" && window.$) {
|
|
return window.$;
|
|
}
|
|
if (typeof window !== "undefined" && window.jQuery) {
|
|
return window.jQuery;
|
|
}
|
|
throw new Error('FATAL: jQuery is not defined. jQuery must be loaded before using JQHTML. Add <script src="https://code.jquery.com/jquery-3.7.1.min.js"><\/script> before loading JQHTML.');
|
|
}
|
|
function getJqhtml() {
|
|
if (typeof window !== "undefined" && window.jqhtml) {
|
|
return window.jqhtml;
|
|
}
|
|
if (typeof globalThis !== "undefined" && globalThis.jqhtml) {
|
|
return globalThis.jqhtml;
|
|
}
|
|
throw new Error("FATAL: window.jqhtml is not defined. The JQHTML runtime must be loaded before using JQHTML components. Ensure @jqhtml/core is imported and initialized before attempting to use debug features.");
|
|
}
|
|
var DebugOverlay = class _DebugOverlay {
|
|
constructor(options = {}) {
|
|
this.$container = null;
|
|
this.$statusIndicator = null;
|
|
this.$ = getJQuery();
|
|
if (!this.$) {
|
|
throw new Error("jQuery is required for DebugOverlay");
|
|
}
|
|
this.options = {
|
|
position: "bottom",
|
|
theme: "dark",
|
|
compact: false,
|
|
showStatus: true,
|
|
autoHide: false,
|
|
...options
|
|
};
|
|
}
|
|
/**
|
|
* Static method to show debug overlay (singleton pattern)
|
|
*/
|
|
static show(options) {
|
|
if (!_DebugOverlay.instance) {
|
|
_DebugOverlay.instance = new _DebugOverlay(options);
|
|
}
|
|
_DebugOverlay.instance.display();
|
|
return _DebugOverlay.instance;
|
|
}
|
|
/**
|
|
* Static method to hide debug overlay
|
|
*/
|
|
static hide() {
|
|
if (_DebugOverlay.instance) {
|
|
_DebugOverlay.instance.hide();
|
|
}
|
|
}
|
|
/**
|
|
* Static method to toggle debug overlay visibility
|
|
*/
|
|
static toggle() {
|
|
if (_DebugOverlay.instance && _DebugOverlay.instance.$container) {
|
|
if (_DebugOverlay.instance.$container.is(":visible")) {
|
|
_DebugOverlay.hide();
|
|
} else {
|
|
_DebugOverlay.instance.display();
|
|
}
|
|
} else {
|
|
_DebugOverlay.show();
|
|
}
|
|
}
|
|
/**
|
|
* Static method to destroy debug overlay
|
|
*/
|
|
static destroy() {
|
|
if (_DebugOverlay.instance) {
|
|
_DebugOverlay.instance.destroy();
|
|
_DebugOverlay.instance = null;
|
|
}
|
|
}
|
|
/**
|
|
* Display the debug overlay
|
|
*/
|
|
display() {
|
|
if (this.$container) {
|
|
this.$container.show();
|
|
return;
|
|
}
|
|
this.createOverlay();
|
|
if (this.options.showStatus) {
|
|
this.createStatusIndicator();
|
|
}
|
|
}
|
|
/**
|
|
* Hide the debug overlay
|
|
*/
|
|
hide() {
|
|
if (this.$container) {
|
|
this.$container.hide();
|
|
}
|
|
if (this.$statusIndicator) {
|
|
this.$statusIndicator.hide();
|
|
}
|
|
}
|
|
/**
|
|
* Remove the debug overlay completely
|
|
*/
|
|
destroy() {
|
|
if (this.$container) {
|
|
this.$container.remove();
|
|
this.$container = null;
|
|
}
|
|
if (this.$statusIndicator) {
|
|
this.$statusIndicator.remove();
|
|
this.$statusIndicator = null;
|
|
}
|
|
}
|
|
/**
|
|
* Update the status indicator
|
|
*/
|
|
updateStatus(mode) {
|
|
if (!this.$statusIndicator)
|
|
return;
|
|
this.$statusIndicator.text("Debug: " + mode);
|
|
this.$statusIndicator.attr("class", "jqhtml-debug-status" + (mode !== "Off" ? " active" : ""));
|
|
}
|
|
createOverlay() {
|
|
this.addStyles();
|
|
this.$container = this.$("<div>").addClass(`jqhtml-debug-overlay ${this.options.theme} ${this.options.position}`);
|
|
const $content = this.$("<div>").addClass("jqhtml-debug-content");
|
|
const $controls = this.$("<div>").addClass("jqhtml-debug-controls");
|
|
const $title = this.$("<span>").addClass("jqhtml-debug-title").html("<strong>\u{1F41B} JQHTML Debug:</strong>");
|
|
$controls.append($title);
|
|
const buttons = [
|
|
{ text: "Slow Motion + Flash", action: "enableSlowMotionDebug", class: "success" },
|
|
{ text: "Basic Debug", action: "enableBasicDebug", class: "" },
|
|
{ text: "Full Debug", action: "enableFullDebug", class: "" },
|
|
{ text: "Sequential", action: "enableSequentialMode", class: "" },
|
|
{ text: "Clear Debug", action: "clearAllDebug", class: "danger" },
|
|
{ text: "Settings", action: "showDebugInfo", class: "" }
|
|
];
|
|
buttons.forEach((btn) => {
|
|
const $button = this.$("<button>").text(btn.text).addClass("jqhtml-debug-btn" + (btn.class ? ` ${btn.class}` : "")).on("click", () => this.executeAction(btn.action));
|
|
$controls.append($button);
|
|
});
|
|
const $toggleBtn = this.$("<button>").text(this.options.compact ? "\u25BC" : "\u25B2").addClass("jqhtml-debug-toggle").on("click", () => this.toggle());
|
|
$controls.append($toggleBtn);
|
|
$content.append($controls);
|
|
this.$container.append($content);
|
|
this.$("body").append(this.$container);
|
|
}
|
|
createStatusIndicator() {
|
|
this.$statusIndicator = this.$("<div>").addClass("jqhtml-debug-status").text("Debug: Off").css({
|
|
position: "fixed",
|
|
top: "10px",
|
|
right: "10px",
|
|
background: "#2c3e50",
|
|
color: "white",
|
|
padding: "5px 10px",
|
|
borderRadius: "4px",
|
|
fontSize: "0.75rem",
|
|
zIndex: "10001",
|
|
opacity: "0.8",
|
|
fontFamily: "monospace"
|
|
});
|
|
this.$("body").append(this.$statusIndicator);
|
|
}
|
|
addStyles() {
|
|
if (this.$("#jqhtml-debug-styles").length > 0)
|
|
return;
|
|
const $style = this.$("<style>").attr("id", "jqhtml-debug-styles").text('.jqhtml-debug-overlay {position: fixed;left: 0;right: 0;z-index: 10000;font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, monospace;font-size: 0.8rem;box-shadow: 0 2px 10px rgba(0,0,0,0.2);}.jqhtml-debug-overlay.top {top: 0;}.jqhtml-debug-overlay.bottom {bottom: 0;}.jqhtml-debug-overlay.dark {background: #34495e;color: #ecf0f1;}.jqhtml-debug-overlay.light {background: #f8f9fa;color: #333;border-bottom: 1px solid #dee2e6;}.jqhtml-debug-content {padding: 0.5rem 1rem;}.jqhtml-debug-controls {display: flex;flex-wrap: wrap;gap: 8px;align-items: center;}.jqhtml-debug-title {margin-right: 10px;font-weight: bold;}.jqhtml-debug-btn {padding: 4px 8px;border: none;border-radius: 3px;background: #3498db;color: white;cursor: pointer;font-size: 0.75rem;transition: background 0.2s;}.jqhtml-debug-btn:hover {background: #2980b9;}.jqhtml-debug-btn.success {background: #27ae60;}.jqhtml-debug-btn.success:hover {background: #229954;}.jqhtml-debug-btn.danger {background: #e74c3c;}.jqhtml-debug-btn.danger:hover {background: #c0392b;}.jqhtml-debug-toggle {padding: 4px 8px;border: none;border-radius: 3px;background: #7f8c8d;color: white;cursor: pointer;font-size: 0.75rem;margin-left: auto;}.jqhtml-debug-toggle:hover {background: #6c7b7d;}.jqhtml-debug-status.active {background: #27ae60 !important;}@media (max-width: 768px) {.jqhtml-debug-controls {flex-direction: column;align-items: flex-start;}.jqhtml-debug-title {margin-bottom: 5px;}}');
|
|
this.$("head").append($style);
|
|
}
|
|
toggle() {
|
|
this.options.compact = !this.options.compact;
|
|
const $toggleBtn = this.$container.find(".jqhtml-debug-toggle");
|
|
$toggleBtn.text(this.options.compact ? "\u25BC" : "\u25B2");
|
|
const $buttons = this.$container.find(".jqhtml-debug-btn");
|
|
if (this.options.compact) {
|
|
$buttons.hide();
|
|
} else {
|
|
$buttons.show();
|
|
}
|
|
}
|
|
executeAction(action) {
|
|
const jqhtml2 = getJqhtml();
|
|
if (!jqhtml2) {
|
|
console.warn("JQHTML not available - make sure it's loaded and exposed globally");
|
|
return;
|
|
}
|
|
switch (action) {
|
|
case "enableSlowMotionDebug":
|
|
jqhtml2.setDebugSettings({
|
|
logFullLifecycle: true,
|
|
sequentialProcessing: true,
|
|
delayAfterComponent: 150,
|
|
delayAfterRender: 200,
|
|
delayAfterRerender: 250,
|
|
flashComponents: true,
|
|
flashDuration: 800,
|
|
flashColors: {
|
|
create: "#3498db",
|
|
render: "#27ae60",
|
|
ready: "#9b59b6"
|
|
},
|
|
profilePerformance: true,
|
|
highlightSlowRenders: 30,
|
|
logDispatch: true
|
|
});
|
|
this.updateStatus("Slow Motion");
|
|
console.log("\u{1F41B} Slow Motion Debug Mode Enabled");
|
|
break;
|
|
case "enableBasicDebug":
|
|
jqhtml2.enableDebugMode("basic");
|
|
this.updateStatus("Basic");
|
|
console.log("\u{1F41B} Basic Debug Mode Enabled");
|
|
break;
|
|
case "enableFullDebug":
|
|
jqhtml2.enableDebugMode("full");
|
|
this.updateStatus("Full");
|
|
console.log("\u{1F41B} Full Debug Mode Enabled");
|
|
break;
|
|
case "enableSequentialMode":
|
|
jqhtml2.setDebugSettings({
|
|
logCreationReady: true,
|
|
sequentialProcessing: true,
|
|
flashComponents: true,
|
|
profilePerformance: true
|
|
});
|
|
this.updateStatus("Sequential");
|
|
console.log("\u{1F41B} Sequential Processing Mode Enabled");
|
|
break;
|
|
case "clearAllDebug":
|
|
jqhtml2.clearDebugSettings();
|
|
this.updateStatus("Off");
|
|
console.log("\u{1F41B} All Debug Modes Disabled");
|
|
break;
|
|
case "showDebugInfo":
|
|
const settings = JSON.stringify(jqhtml2.debug, null, 2);
|
|
console.log("\u{1F41B} Current Debug Settings:", settings);
|
|
alert("Debug settings logged to console:\n\n" + (Object.keys(jqhtml2.debug).length > 0 ? settings : "No debug settings active"));
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
DebugOverlay.instance = null;
|
|
if (typeof window !== "undefined") {
|
|
const urlParams = new URLSearchParams(window.location.search);
|
|
if (urlParams.get("debug") === "true" || urlParams.get("jqhtml-debug") === "true") {
|
|
document.addEventListener("DOMContentLoaded", () => {
|
|
DebugOverlay.show();
|
|
});
|
|
}
|
|
}
|
|
function init_jquery_plugin(jQuery) {
|
|
if (!jQuery || !jQuery.fn) {
|
|
throw new Error("jQuery is required for JQHTML. Please ensure jQuery is loaded before initializing JQHTML.");
|
|
}
|
|
if (typeof window !== "undefined" && window.$ !== jQuery && !jQuery.__jqhtml_checked) {
|
|
devWarn('jQuery instance appears to be bundled with webpack/modules rather than loaded globally.\nFor best compatibility, it is recommended to:\n1. Include jQuery via <script> tag from a CDN (UMD format)\n2. Configure webpack with: externals: { jquery: "$" }\n3. Remove jquery from package.json dependencies\n\nTo suppress this warning, set: window.JQHTML_SUPPRESS_WARNINGS = true');
|
|
jQuery.__jqhtml_checked = true;
|
|
}
|
|
const _jqhtml_original_jquery = jQuery;
|
|
const JQueryWithComponentSupport = function(selector, context) {
|
|
if (selector && typeof selector === "object" && selector.$ && typeof selector.$id === "function" && typeof selector.id === "function") {
|
|
return selector.$;
|
|
}
|
|
return new _jqhtml_original_jquery(selector, context);
|
|
};
|
|
Object.setPrototypeOf(JQueryWithComponentSupport, _jqhtml_original_jquery);
|
|
for (const key in _jqhtml_original_jquery) {
|
|
if (_jqhtml_original_jquery.hasOwnProperty(key)) {
|
|
JQueryWithComponentSupport[key] = _jqhtml_original_jquery[key];
|
|
}
|
|
}
|
|
JQueryWithComponentSupport.prototype = _jqhtml_original_jquery.prototype;
|
|
JQueryWithComponentSupport.fn = _jqhtml_original_jquery.fn;
|
|
if (typeof window !== "undefined") {
|
|
window.jQuery = JQueryWithComponentSupport;
|
|
window.$ = JQueryWithComponentSupport;
|
|
}
|
|
jQuery = JQueryWithComponentSupport;
|
|
const originalVal = jQuery.fn.val;
|
|
jQuery.fn.val = function(value) {
|
|
if (arguments.length === 0) {
|
|
const firstEl = this.first();
|
|
if (firstEl.length === 0)
|
|
return void 0;
|
|
const component = firstEl.data("_component");
|
|
const tagName = firstEl.prop("tagName");
|
|
if (component && typeof component.val === "function" && tagName !== "INPUT" && tagName !== "TEXTAREA") {
|
|
return component.val();
|
|
}
|
|
return originalVal.call(this);
|
|
} else {
|
|
this.each(function() {
|
|
const $el = jQuery(this);
|
|
const component = $el.data("_component");
|
|
const tagName = $el.prop("tagName");
|
|
if (component && typeof component.val === "function" && tagName !== "INPUT" && tagName !== "TEXTAREA") {
|
|
component.val(value);
|
|
} else {
|
|
originalVal.call($el, value);
|
|
}
|
|
});
|
|
return this;
|
|
}
|
|
};
|
|
jQuery.fn.component = function(componentOrName, args = {}) {
|
|
const element = this.first ? this.first() : this;
|
|
if (!componentOrName) {
|
|
if (element.length === 0) {
|
|
return null;
|
|
}
|
|
const comp = element.data("_component");
|
|
return comp || null;
|
|
}
|
|
const existingComponent = element.data("_component");
|
|
if (existingComponent) {
|
|
return existingComponent;
|
|
}
|
|
let ComponentClass;
|
|
let componentName;
|
|
if (typeof componentOrName === "string") {
|
|
componentName = componentOrName;
|
|
const found = get_component_class(componentOrName);
|
|
args = { ...args, _component_name: componentName };
|
|
if (!found) {
|
|
ComponentClass = Component;
|
|
} else {
|
|
ComponentClass = found;
|
|
}
|
|
} else {
|
|
ComponentClass = componentOrName;
|
|
}
|
|
let targetElement = element;
|
|
if (componentName) {
|
|
const template = get_template(componentName);
|
|
const expectedTag = args._tag || template.tag || "div";
|
|
const currentTag = element.prop("tagName").toLowerCase();
|
|
if (currentTag !== expectedTag.toLowerCase()) {
|
|
if (args._inner_html) {
|
|
const newElement = jQuery(`<${expectedTag}></${expectedTag}>`);
|
|
const oldEl = element[0];
|
|
if (oldEl && oldEl.attributes) {
|
|
for (let i = 0; i < oldEl.attributes.length; i++) {
|
|
const attr = oldEl.attributes[i];
|
|
newElement.attr(attr.name, attr.value);
|
|
}
|
|
}
|
|
newElement.html(element.html());
|
|
element.replaceWith(newElement);
|
|
targetElement = newElement;
|
|
} else {
|
|
console.warn(`[JQHTML] Component '${componentName}' expects tag '<${expectedTag}>' but element is '<${currentTag}>'. Element tag will not be changed. Consider using the correct tag.`);
|
|
}
|
|
}
|
|
}
|
|
const component = new ComponentClass(targetElement, args);
|
|
component.boot();
|
|
applyDebugDelay("component");
|
|
return component;
|
|
};
|
|
const _jqhtml_jquery_overrides = {};
|
|
const dom_insertion_methods = ["append", "prepend", "before", "after", "replaceWith"];
|
|
for (const fnname of dom_insertion_methods) {
|
|
_jqhtml_jquery_overrides[fnname] = jQuery.fn[fnname];
|
|
jQuery.fn[fnname] = function(...args) {
|
|
const resolvedArgs = args.map((arg) => {
|
|
if (arg && typeof arg === "object" && arg instanceof Component) {
|
|
return arg.$;
|
|
}
|
|
return arg;
|
|
});
|
|
const $elements = resolvedArgs.filter((arg) => arg instanceof jQuery);
|
|
const ret = _jqhtml_jquery_overrides[fnname].apply(this, resolvedArgs);
|
|
for (const $e of $elements) {
|
|
if ($e.closest("html").length > 0) {
|
|
$e.find(".Component").addBack(".Component").each(function() {
|
|
const $comp = jQuery(this);
|
|
const component = $comp.data("_component");
|
|
if (component && !component._ready_state) {
|
|
component.boot();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
}
|
|
jQuery.fn.shallowFind = function(selector) {
|
|
const results = [];
|
|
this.each(function() {
|
|
const traverse = (parent) => {
|
|
for (let i = 0; i < parent.children.length; i++) {
|
|
const child = parent.children[i];
|
|
if (jQuery(child).is(selector)) {
|
|
results.push(child);
|
|
} else {
|
|
traverse(child);
|
|
}
|
|
}
|
|
};
|
|
traverse(this);
|
|
});
|
|
return jQuery(results);
|
|
};
|
|
const originalEmpty = jQuery.fn.empty;
|
|
const originalHtml = jQuery.fn.html;
|
|
const originalText = jQuery.fn.text;
|
|
jQuery.fn.empty = function() {
|
|
return this.each(function() {
|
|
jQuery(this).find(".Component").each(function() {
|
|
const component = jQuery(this).data("_component");
|
|
if (component && !component._stopped) {
|
|
component._stop();
|
|
}
|
|
});
|
|
originalEmpty.call(jQuery(this));
|
|
});
|
|
};
|
|
jQuery.fn.html = function(value) {
|
|
if (arguments.length === 0) {
|
|
return originalHtml.call(this);
|
|
}
|
|
return this.each(function() {
|
|
jQuery(this).empty();
|
|
originalHtml.call(jQuery(this), value);
|
|
});
|
|
};
|
|
jQuery.fn.text = function(value) {
|
|
if (arguments.length === 0) {
|
|
return originalText.call(this);
|
|
}
|
|
return this.each(function() {
|
|
jQuery(this).empty();
|
|
originalText.call(jQuery(this), value);
|
|
});
|
|
};
|
|
}
|
|
if (typeof window !== "undefined" && window.jQuery) {
|
|
init_jquery_plugin(window.jQuery);
|
|
}
|
|
var version = "2.2.185";
|
|
var jqhtml = {
|
|
// Core
|
|
Component,
|
|
LifecycleManager,
|
|
// Registry
|
|
register_component,
|
|
get_component_class,
|
|
register_template,
|
|
get_template,
|
|
get_template_by_class,
|
|
create_component,
|
|
has_component,
|
|
get_component_names,
|
|
get_registered_templates,
|
|
list_components,
|
|
// Template system
|
|
process_instructions,
|
|
extract_slots,
|
|
render_template,
|
|
escape_html,
|
|
// Version property - internal
|
|
__version: version,
|
|
// Debug settings
|
|
debug: {
|
|
enabled: false,
|
|
verbose: false
|
|
},
|
|
// Debug helper functions (mainly for internal use but exposed for advanced debugging)
|
|
setDebugSettings(settings) {
|
|
Object.assign(this.debug, settings);
|
|
},
|
|
enableDebugMode(level = "basic") {
|
|
if (level === "basic") {
|
|
this.debug.logCreationReady = true;
|
|
this.debug.logDispatch = true;
|
|
this.debug.flashComponents = true;
|
|
} else {
|
|
this.debug.logFullLifecycle = true;
|
|
this.debug.logDispatchVerbose = true;
|
|
this.debug.flashComponents = true;
|
|
this.debug.profilePerformance = true;
|
|
this.debug.traceDataFlow = true;
|
|
}
|
|
},
|
|
clearDebugSettings() {
|
|
this.debug = {};
|
|
},
|
|
// Debug overlay methods
|
|
showDebugOverlay(options) {
|
|
return DebugOverlay.show(options);
|
|
},
|
|
hideDebugOverlay() {
|
|
return DebugOverlay.hide();
|
|
},
|
|
// Export DebugOverlay class for direct access
|
|
DebugOverlay,
|
|
// Install globals function
|
|
installGlobals() {
|
|
if (typeof window !== "undefined") {
|
|
window.jqhtml = this;
|
|
window.Component = Component;
|
|
window.Jqhtml_LifecycleManager = LifecycleManager;
|
|
}
|
|
},
|
|
// Version display function - shows version of core library and all registered templates
|
|
_version() {
|
|
console.log(`JQHTML Core v${this.__version}`);
|
|
console.log("Registered Templates:");
|
|
const templateNames = get_component_names();
|
|
if (templateNames.length === 0) {
|
|
console.log(" (no templates registered)");
|
|
} else {
|
|
for (const name of templateNames) {
|
|
const template = get_template(name);
|
|
const templateVersion = template ? template._jqhtml_version || "unknown" : "unknown";
|
|
console.log(` - ${name}: v${templateVersion}`);
|
|
}
|
|
}
|
|
return this.__version;
|
|
},
|
|
// Public version function - returns the stamped version number
|
|
version() {
|
|
return version;
|
|
}
|
|
};
|
|
if (typeof window !== "undefined" && !window.jqhtml) {
|
|
window.jqhtml = jqhtml;
|
|
window.Component = Component;
|
|
window.Component = Component;
|
|
window.Jqhtml_LifecycleManager = LifecycleManager;
|
|
if (jqhtml.debug?.enabled) {
|
|
console.log("[JQHTML] Auto-registered window.jqhtml global for template compatibility");
|
|
}
|
|
}
|
|
|
|
// storage/rsx-tmp/npm-compile/entry_6459e8ed0f60bda4f121420766012d53.js
|
|
window._rsx_npm = window._rsx_npm || {};
|
|
window._rsx_npm.jqhtml = jqhtml;
|
|
window._rsx_npm._Base_Jqhtml_Component = Component;
|
|
})();
|
|
|
|
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["storage/rsx-build/bundles/npm_Bootstrap5_Bundle_6459e8ed0f60bda4f121420766012d53.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"bundle_output_Bootstrap5_Bundle.js","sourceRoot":"","sourcesContent":["(() => {\n  // node_modules/@jqhtml/core/dist/index.js\n  var LifecycleManager = class _LifecycleManager {\n    static get_instance() {\n      if (!_LifecycleManager.instance) {\n        _LifecycleManager.instance = new _LifecycleManager();\n      }\n      return _LifecycleManager.instance;\n    }\n    constructor() {\n      this.active_components = /* @__PURE__ */ new Set();\n    }\n    /**\n     * Boot a component - run its full lifecycle\n     * Called when component is created\n     */\n    async boot_component(component) {\n      this.active_components.add(component);\n      try {\n        await component.create();\n        if (component._stopped)\n          return;\n        component.trigger(\"create\");\n        let render_id = component._render();\n        if (component._stopped)\n          return;\n        await component.load();\n        if (component._stopped)\n          return;\n        if (component.should_rerender()) {\n          render_id = component._render();\n          if (component._stopped)\n            return;\n        }\n        if (component._render_count !== render_id) {\n          return;\n        }\n        await component.ready();\n        if (component._stopped)\n          return;\n        await component.trigger(\"ready\");\n      } catch (error) {\n        console.error(`Error booting component ${component.component_name()}:`, error);\n        throw error;\n      }\n    }\n    /**\n     * Unregister a component (called on destroy)\n     */\n    unregister_component(component) {\n      this.active_components.delete(component);\n    }\n    /**\n     * Wait for all active components to reach ready state\n     */\n    async wait_for_ready() {\n      const ready_promises = [];\n      for (const component of this.active_components) {\n        if (component._ready_state < 4) {\n          ready_promises.push(new Promise((resolve) => {\n            component.on(\"ready\", () => resolve());\n          }));\n        }\n      }\n      await Promise.all(ready_promises);\n    }\n  };\n  var component_classes = /* @__PURE__ */ new Map();\n  var component_templates = /* @__PURE__ */ new Map();\n  var warned_components = /* @__PURE__ */ new Set();\n  var DEFAULT_TEMPLATE = {\n    name: \"Jqhtml_Component\",\n    // Default name\n    tag: \"div\",\n    render: function(data, args, content) {\n      const _output = [];\n      if (args._inner_html) {\n        _output.push(args._inner_html);\n        return [_output, this];\n      }\n      if (content && typeof content === \"function\") {\n        const result = content(this);\n        if (Array.isArray(result) && result.length === 2) {\n          _output.push(...result[0]);\n        } else if (typeof result === \"string\") {\n          _output.push(result);\n        }\n      }\n      return [_output, this];\n    }\n  };\n  function register_component(nameOrClass, component_class, template) {\n    if (typeof nameOrClass === \"string\") {\n      const name = nameOrClass;\n      if (!component_class) {\n        throw new Error(\"Component class is required when registering by name\");\n      }\n      if (!/^[A-Z]/.test(name)) {\n        throw new Error(`Component name '${name}' must start with a capital letter. Convention is First_Letter_With_Underscores.`);\n      }\n      component_classes.set(name, component_class);\n      if (template) {\n        if (template.name !== name) {\n          throw new Error(`Template name '${template.name}' must match component name '${name}'`);\n        }\n        register_template(template);\n      }\n    } else {\n      const component_class2 = nameOrClass;\n      const name = component_class2.name;\n      if (!name || name === \"Jqhtml_Component\") {\n        throw new Error(\"Component class must have a name when registering without explicit name\");\n      }\n      component_classes.set(name, component_class2);\n    }\n  }\n  function get_component_class(name) {\n    const directClass = component_classes.get(name);\n    if (directClass) {\n      return directClass;\n    }\n    const template = component_templates.get(name);\n    if (template && template.extends) {\n      const visited = /* @__PURE__ */ new Set([name]);\n      let currentTemplateName = template.extends;\n      while (currentTemplateName && !visited.has(currentTemplateName)) {\n        visited.add(currentTemplateName);\n        const parentClass = component_classes.get(currentTemplateName);\n        if (parentClass) {\n          if (window.jqhtml?.debug?.enabled) {\n            console.log(`[JQHTML] Component '${name}' using class from parent '${currentTemplateName}' via extends chain`);\n          }\n          return parentClass;\n        }\n        const parentTemplate = component_templates.get(currentTemplateName);\n        if (parentTemplate && parentTemplate.extends) {\n          currentTemplateName = parentTemplate.extends;\n        } else {\n          break;\n        }\n      }\n    }\n    return void 0;\n  }\n  function register_template(template_def) {\n    const name = template_def.name;\n    if (!name) {\n      throw new Error(\"Template must have a name property\");\n    }\n    if (!/^[A-Z]/.test(name)) {\n      throw new Error(`Template name '${name}' must start with a capital letter. Convention is First_Letter_With_Underscores.`);\n    }\n    if (component_templates.has(name)) {\n      console.warn(`[JQHTML] Template '${name}' already registered, skipping duplicate registration`);\n      return false;\n    }\n    component_templates.set(name, template_def);\n    if (window.jqhtml?.debug?.enabled) {\n      console.log(`[JQHTML] Successfully registered template: ${name}`);\n    }\n    const component_class = component_classes.get(name);\n    if (component_class) {\n      component_class._jqhtml_metadata = {\n        tag: template_def.tag,\n        defaultAttributes: template_def.defaultAttributes || {}\n      };\n    }\n    return true;\n  }\n  function get_template(name) {\n    const template = component_templates.get(name);\n    if (!template) {\n      const component_class = component_classes.get(name);\n      if (component_class) {\n        const inherited_template = get_template_by_class(component_class);\n        if (inherited_template !== DEFAULT_TEMPLATE) {\n          if (window.jqhtml?.debug?.enabled) {\n            console.log(`[JQHTML] Component '${name}' has no template, using template from prototype chain`);\n          }\n          return inherited_template;\n        }\n        if (window.jqhtml?.debug?.enabled && !warned_components.has(name)) {\n          warned_components.add(name);\n          console.log(`[JQHTML] No template found for class: ${name}, using default div template`);\n        }\n      } else {\n        if (name !== \"_Jqhtml_Component\" && name !== \"Redrawable\" && !warned_components.has(name)) {\n          warned_components.add(name);\n          console.warn(`[JQHTML] Creating ${name} with defaults - no template or class defined`);\n        }\n      }\n      if (window.jqhtml?.debug?.verbose) {\n        const registered = Array.from(component_templates.keys());\n        console.log(`[JQHTML] Looking for template '${name}' in: [${registered.join(\", \")}]`);\n      }\n      return DEFAULT_TEMPLATE;\n    }\n    return template;\n  }\n  function get_template_by_class(component_class) {\n    if (component_class.template) {\n      return component_class.template;\n    }\n    let currentClass = component_class;\n    while (currentClass && currentClass.name !== \"Object\") {\n      let normalizedName = currentClass.name;\n      if (normalizedName === \"_Jqhtml_Component\" || normalizedName === \"_Base_Jqhtml_Component\") {\n        normalizedName = \"Jqhtml_Component\";\n      }\n      const template = component_templates.get(normalizedName);\n      if (template) {\n        return template;\n      }\n      currentClass = Object.getPrototypeOf(currentClass);\n    }\n    return DEFAULT_TEMPLATE;\n  }\n  function create_component(name, element, args = {}) {\n    const ComponentClass = get_component_class(name) || Jqhtml_Component;\n    return new ComponentClass(element, args);\n  }\n  function has_component(name) {\n    return component_classes.has(name);\n  }\n  function get_component_names() {\n    return Array.from(component_classes.keys());\n  }\n  function get_registered_templates() {\n    return Array.from(component_templates.keys());\n  }\n  function list_components() {\n    const result = {};\n    for (const name of component_classes.keys()) {\n      result[name] = {\n        has_class: true,\n        has_template: component_templates.has(name)\n      };\n    }\n    for (const name of component_templates.keys()) {\n      if (!result[name]) {\n        result[name] = {\n          has_class: false,\n          has_template: true\n        };\n      }\n    }\n    return result;\n  }\n  var _cid_increment = \"aa\";\n  function uid() {\n    const current = _cid_increment;\n    const chars = _cid_increment.split(\"\");\n    let carry = true;\n    for (let i = chars.length - 1; i >= 0 && carry; i--) {\n      const char = chars[i];\n      if (char >= \"a\" && char < \"z\") {\n        chars[i] = String.fromCharCode(char.charCodeAt(0) + 1);\n        carry = false;\n      } else if (char === \"z\") {\n        chars[i] = \"0\";\n        carry = false;\n      } else if (char >= \"0\" && char < \"9\") {\n        chars[i] = String.fromCharCode(char.charCodeAt(0) + 1);\n        carry = false;\n      } else if (char === \"9\") {\n        chars[i] = \"a\";\n        carry = true;\n      }\n    }\n    if (carry) {\n      chars.unshift(\"a\");\n    }\n    if (chars[0] >= \"0\" && chars[0] <= \"9\") {\n      chars[0] = \"a\";\n      chars.unshift(\"a\");\n    }\n    _cid_increment = chars.join(\"\");\n    return current;\n  }\n  function process_instructions(instructions, target, context, slots) {\n    const html = [];\n    const tagElements = {};\n    const components = {};\n    for (const instruction of instructions) {\n      process_instruction_to_html(instruction, html, tagElements, components, context, slots);\n    }\n    target[0].innerHTML = html.join(\"\");\n    for (const [tid, tagData] of Object.entries(tagElements)) {\n      const el = target[0].querySelector(`[data-tid=\"${tid}\"]`);\n      if (el) {\n        const element = $(el);\n        el.removeAttribute(\"data-tid\");\n        apply_attributes(element, tagData.attrs, context);\n      }\n    }\n    for (const [cid, compData] of Object.entries(components)) {\n      const el = target[0].querySelector(`[data-cid=\"${cid}\"]`);\n      if (el) {\n        const element = $(el);\n        el.removeAttribute(\"data-cid\");\n        initialize_component(element, compData);\n      }\n    }\n  }\n  function process_instruction_to_html(instruction, html, tagElements, components, context, slots) {\n    if (typeof instruction === \"string\") {\n      html.push(instruction);\n    } else if (\"tag\" in instruction) {\n      process_tag_to_html(instruction, html, tagElements, components, context);\n    } else if (\"comp\" in instruction) {\n      process_component_to_html(instruction, html, components, context);\n    } else if (\"slot\" in instruction) {\n      process_slot_to_html(instruction, html, tagElements, components, context, slots);\n    } else if (\"rawtag\" in instruction) {\n      process_rawtag_to_html(instruction, html);\n    }\n  }\n  function process_tag_to_html(instruction, html, tagElements, components, context) {\n    const [tagName, attrs, selfClosing] = instruction.tag;\n    const needsTracking = Object.keys(attrs).some((key) => key === \"$id\" || key.startsWith(\"$\") || key.startsWith(\"@\") || key.startsWith(\"on\") || key.startsWith(\"data-bind-\") || key.startsWith(\"data-on-\"));\n    html.push(`<${tagName}`);\n    let tid = null;\n    if (needsTracking) {\n      tid = uid();\n      html.push(` data-tid=\"${tid}\"`);\n      tagElements[tid] = { attrs, context };\n    }\n    for (const [key, value] of Object.entries(attrs)) {\n      if (!key.startsWith(\"$\") && !key.startsWith(\"on\") && !key.startsWith(\"@\") && !key.startsWith(\"data-bind-\") && !key.startsWith(\"data-on-\") && (typeof value === \"string\" || typeof value === \"number\")) {\n        if (key === \"id\" && tid) {\n          html.push(` id=\"${value}:${context._cid}\"`);\n        } else {\n          html.push(` ${key}=\"${value}\"`);\n        }\n      }\n    }\n    if (selfClosing) {\n      html.push(\" />\");\n    } else {\n      html.push(\">\");\n    }\n  }\n  function process_component_to_html(instruction, html, components, context) {\n    const [componentName, props, contentFn] = instruction.comp;\n    const cid = uid();\n    get_component_class(componentName) || Jqhtml_Component;\n    const template = get_template(componentName);\n    const tagName = props._tag || template.tag || \"div\";\n    html.push(`<${tagName} data-cid=\"${cid}\"`);\n    if (props[\"data-id\"]) {\n      const baseId = props[\"data-id\"];\n      html.push(` id=\"${props[\"id\"]}\" data-id=\"${baseId}\"`);\n    } else if (props[\"id\"]) {\n      html.push(` id=\"${props[\"id\"]}\"`);\n    }\n    html.push(\"></\" + tagName + \">\");\n    components[cid] = {\n      name: componentName,\n      props,\n      contentFn,\n      context\n    };\n  }\n  function process_slot_to_html(instruction, html, tagElements, components, context, parentSlots) {\n    const [slotName] = instruction.slot;\n    if (parentSlots && slotName in parentSlots) {\n      const parentSlot = parentSlots[slotName];\n      const [, slotProps, contentFn] = parentSlot.slot;\n      const [content] = contentFn.call(context, slotProps);\n      for (const item of content) {\n        process_instruction_to_html(item, html, tagElements, components, context);\n      }\n    } else if (slotName === \"default\" && instruction.slot[2]) {\n      const [, , defaultFn] = instruction.slot;\n      const [content] = defaultFn.call(context, {});\n      for (const item of content) {\n        process_instruction_to_html(item, html, tagElements, components, context);\n      }\n    }\n  }\n  function process_rawtag_to_html(instruction, html) {\n    const [tagName, attrs, rawContent] = instruction.rawtag;\n    html.push(`<${tagName}`);\n    for (const [key, value] of Object.entries(attrs)) {\n      if (typeof value === \"string\" || typeof value === \"number\") {\n        const escaped_value = String(value).replace(/\"/g, \"&quot;\");\n        html.push(` ${key}=\"${escaped_value}\"`);\n      } else if (typeof value === \"boolean\" && value) {\n        html.push(` ${key}`);\n      }\n    }\n    html.push(\">\");\n    const escaped_content = rawContent.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\");\n    html.push(escaped_content);\n    html.push(`</${tagName}>`);\n  }\n  function apply_attributes(element, attrs, context) {\n    for (const [key, value] of Object.entries(attrs)) {\n      if (key === \"$id\" || key === \"id\") {\n        continue;\n      } else if (key.startsWith(\"$\")) {\n        const dataKey = key.substring(1);\n        element.data(dataKey, value);\n        context.args[dataKey] = value;\n        if (typeof value == \"string\" || typeof value == \"number\") {\n          const attrValue = typeof value === \"string\" ? value.trim() : value;\n          element.attr(`data-${dataKey}`, attrValue);\n        }\n      } else if (key.startsWith(\"data-on-\")) {\n        const eventName = key.substring(8);\n        if (typeof value === \"function\") {\n          element.on(eventName, function(e) {\n            value.bind(context)(e, element);\n          });\n        } else {\n          console.warn(\"(JQHTML) Tried to assign a non function to on event handler \" + key);\n        }\n      } else if (key.startsWith(\"on\")) {\n        const eventName = key.substring(2);\n        if (typeof value === \"function\") {\n          element.on(eventName, function(e) {\n            value.bind(context)(e, element);\n          });\n        } else {\n          console.warn(\"(JQHTML) Tried to assign a non function to on event handler \" + key);\n        }\n      } else if (key.startsWith(\"data-\")) {\n        const attrValue = typeof value === \"string\" ? value.trim() : value;\n        element.attr(key, attrValue);\n        const dataKey = key.substring(5);\n        element.data(dataKey, value);\n        context.args[dataKey] = value;\n      } else if (key === \"class\") {\n        const existingClasses = element.attr(\"class\");\n        if (window.jqhtml?.debug?.enabled) {\n          console.log(`[InstructionProcessor] Merging class attribute:`, {\n            existing: existingClasses,\n            new: value\n          });\n        }\n        if (!existingClasses) {\n          const attrValue = typeof value === \"string\" ? value.trim() : value;\n          element.attr(\"class\", attrValue);\n        } else {\n          const existing = existingClasses.split(/\\s+/).filter((c) => c);\n          const newClasses = String(value).split(/\\s+/).filter((c) => c);\n          for (const newClass of newClasses) {\n            if (!existing.includes(newClass)) {\n              existing.push(newClass);\n            }\n          }\n          element.attr(\"class\", existing.join(\" \"));\n        }\n        if (window.jqhtml?.debug?.enabled) {\n          console.log(`[InstructionProcessor] Class after merge:`, element.attr(\"class\"));\n        }\n      } else if (key === \"style\") {\n        const existingStyle = element.attr(\"style\");\n        if (!existingStyle) {\n          const attrValue = typeof value === \"string\" ? value.trim() : value;\n          element.attr(\"style\", attrValue);\n        } else {\n          const styleMap = {};\n          existingStyle.split(\";\").forEach((rule) => {\n            const [prop, val] = rule.split(\":\").map((s) => s.trim());\n            if (prop && val) {\n              styleMap[prop] = val;\n            }\n          });\n          String(value).split(\";\").forEach((rule) => {\n            const [prop, val] = rule.split(\":\").map((s) => s.trim());\n            if (prop && val) {\n              styleMap[prop] = val;\n            }\n          });\n          const mergedStyle = Object.entries(styleMap).map(([prop, val]) => `${prop}: ${val}`).join(\"; \");\n          element.attr(\"style\", mergedStyle);\n        }\n      } else {\n        if (typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\") {\n          const attrValue = typeof value === \"string\" ? value.trim() : String(value);\n          element.attr(key, attrValue);\n        } else if (typeof value === \"object\") {\n          console.warn(`(JQHTML) Unexpected value for '${key}' on`, element);\n        }\n      }\n    }\n  }\n  async function initialize_component(element, compData) {\n    const { name, props, contentFn, context } = compData;\n    const ComponentClass = get_component_class(name) || Jqhtml_Component;\n    const invocationAttrs = {};\n    for (const [key, value] of Object.entries(props)) {\n      if (!key.startsWith(\"_\")) {\n        invocationAttrs[key] = value;\n      }\n    }\n    if (window.jqhtml?.debug?.enabled) {\n      console.log(`[InstructionProcessor] Applying invocation attributes for ${name}:`, invocationAttrs);\n    }\n    apply_attributes(element, invocationAttrs, context);\n    const options = {};\n    if (contentFn) {\n      options._innerhtml_function = contentFn;\n    }\n    if (ComponentClass.name !== name) {\n      options._component_name = name;\n    }\n    const instance = new ComponentClass(element, options);\n    instance._instantiator = context;\n    await instance.boot();\n  }\n  function extract_slots(instructions) {\n    const slots = {};\n    for (const instruction of instructions) {\n      if (typeof instruction === \"object\" && \"slot\" in instruction) {\n        const [name] = instruction.slot;\n        slots[name] = instruction;\n      }\n    }\n    return slots;\n  }\n  var performanceMetrics = /* @__PURE__ */ new Map();\n  function devWarn(message) {\n    if (typeof window !== \"undefined\" && window.JQHTML_SUPPRESS_WARNINGS) {\n      return;\n    }\n    if (typeof process !== \"undefined\" && process.env && false) {\n      return;\n    }\n    console.warn(`[JQHTML Dev Warning] ${message}`);\n  }\n  function getJqhtml$1() {\n    if (typeof window !== \"undefined\" && window.jqhtml) {\n      return window.jqhtml;\n    }\n    if (typeof globalThis !== \"undefined\" && globalThis.jqhtml) {\n      return globalThis.jqhtml;\n    }\n    throw new Error(\"FATAL: window.jqhtml is not defined. The JQHTML runtime must be loaded before using debug features. Import and initialize @jqhtml/core before attempting to use debug functionality.\");\n  }\n  function flashComponent(component, eventType) {\n    const jqhtml2 = getJqhtml$1();\n    if (!jqhtml2?.debug?.flashComponents)\n      return;\n    const duration = jqhtml2.debug.flashDuration || 500;\n    const colors = jqhtml2.debug.flashColors || {};\n    const color = colors[eventType] || (eventType === \"create\" ? \"#3498db\" : eventType === \"render\" ? \"#27ae60\" : \"#9b59b6\");\n    const originalBorder = component.$.css(\"border\");\n    component.$.css({\n      \"border\": `2px solid ${color}`,\n      \"transition\": `border ${duration}ms ease-out`\n    });\n    setTimeout(() => {\n      component.$.css(\"border\", originalBorder || \"\");\n    }, duration);\n  }\n  function logLifecycle(component, phase, status) {\n    const jqhtml2 = getJqhtml$1();\n    if (!jqhtml2?.debug)\n      return;\n    const shouldLog = jqhtml2.debug.logFullLifecycle || jqhtml2.debug.logCreationReady && (phase === \"create\" || phase === \"ready\");\n    if (!shouldLog)\n      return;\n    const componentName = component.constructor.name;\n    const timestamp = (/* @__PURE__ */ new Date()).toISOString();\n    const prefix = `[JQHTML ${timestamp}]`;\n    if (status === \"start\") {\n      console.log(`${prefix} ${componentName}#${component._cid} \\u2192 ${phase} starting...`);\n      if (jqhtml2.debug.profilePerformance) {\n        performanceMetrics.set(`${component._cid}_${phase}`, Date.now());\n      }\n    } else {\n      let message = `${prefix} ${componentName}#${component._cid} \\u2713 ${phase} complete`;\n      if (jqhtml2.debug.profilePerformance) {\n        const startTime = performanceMetrics.get(`${component._cid}_${phase}`);\n        if (startTime) {\n          const duration = Date.now() - startTime;\n          message += ` (${duration}ms)`;\n          if (phase === \"render\" && jqhtml2.debug.highlightSlowRenders && duration > jqhtml2.debug.highlightSlowRenders) {\n            console.warn(`${prefix} SLOW RENDER: ${componentName}#${component._cid} took ${duration}ms`);\n            component.$.css(\"outline\", \"2px dashed red\");\n          }\n        }\n      }\n      console.log(message);\n      if (jqhtml2.debug.flashComponents && (phase === \"create\" || phase === \"render\" || phase === \"ready\")) {\n        flashComponent(component, phase);\n      }\n    }\n    if (jqhtml2.debug.showComponentTree) {\n      updateComponentTree();\n    }\n  }\n  function applyDebugDelay(phase) {\n    const jqhtml2 = getJqhtml$1();\n    if (!jqhtml2?.debug)\n      return;\n    let delayMs = 0;\n    switch (phase) {\n      case \"component\":\n        delayMs = jqhtml2.debug.delayAfterComponent || 0;\n        break;\n      case \"render\":\n        delayMs = jqhtml2.debug.delayAfterRender || 0;\n        break;\n      case \"rerender\":\n        delayMs = jqhtml2.debug.delayAfterRerender || 0;\n        break;\n    }\n    if (delayMs > 0) {\n      console.log(`[JQHTML Debug] Applying ${delayMs}ms delay after ${phase}`);\n    }\n  }\n  function updateComponentTree() {\n    console.log(\"[JQHTML Tree] Component hierarchy updated\");\n  }\n  var Jqhtml_Component = class _Jqhtml_Component {\n    constructor(element, args = {}) {\n      this.data = {};\n      this._ready_state = 0;\n      this._instantiator = null;\n      this._dom_parent = null;\n      this._dom_children = /* @__PURE__ */ new Set();\n      this._use_dom_fallback = false;\n      this._stopped = false;\n      this._booted = false;\n      this._data_before_render = null;\n      this._lifecycle_callbacks = /* @__PURE__ */ new Map();\n      this._lifecycle_states = /* @__PURE__ */ new Set();\n      this.__loading = false;\n      this._did_first_render = false;\n      this._render_count = 0;\n      this._cid = this._generate_cid();\n      this._lifecycle_manager = LifecycleManager.get_instance();\n      if (element) {\n        this.$ = $(element);\n      } else {\n        const div = document.createElement(\"div\");\n        this.$ = $(div);\n      }\n      const dataAttrs = {};\n      if (this.$.length > 0) {\n        const dataset = this.$[0].dataset || {};\n        for (const key in dataset) {\n          if (key !== \"cid\" && key !== \"tid\" && key !== \"componentName\" && key !== \"readyState\") {\n            const dataValue = this.$.data(key);\n            if (dataValue !== void 0 && dataValue !== dataset[key]) {\n              dataAttrs[key] = dataValue;\n            } else {\n              dataAttrs[key] = dataset[key];\n            }\n          }\n        }\n      }\n      let template_for_args;\n      if (args._component_name) {\n        template_for_args = get_template(args._component_name);\n      } else {\n        template_for_args = get_template_by_class(this.constructor);\n      }\n      const defineArgs = template_for_args?.defineArgs || {};\n      this.args = { ...defineArgs, ...dataAttrs, ...args };\n      for (const [key, value] of Object.entries(this.args)) {\n        if (key === \"cid\" || key === \"tid\" || key === \"componentName\" || key === \"readyState\" || key.startsWith(\"_\")) {\n          continue;\n        }\n        if (typeof value === \"string\" || typeof value === \"number\") {\n          try {\n            const currentAttr = this.$.attr(`data-${key}`);\n            if (currentAttr != value) {\n              this.$.attr(`data-${key}`, String(value));\n            }\n          } catch (e) {\n          }\n        }\n      }\n      this.$.data(\"_component\", this);\n      this._apply_css_classes();\n      this._apply_default_attributes();\n      this._set_attributes();\n      this._find_dom_parent();\n      this._log_lifecycle(\"construct\", \"complete\");\n    }\n    /**\n     * Boot - Start the full component lifecycle\n     * Called immediately after construction by instruction processor\n     */\n    async boot() {\n      if (this._booted)\n        return;\n      this._booted = true;\n      await this._lifecycle_manager.boot_component(this);\n    }\n    // -------------------------------------------------------------------------\n    // Lifecycle Methods (called by LifecycleManager)\n    // -------------------------------------------------------------------------\n    /**\n     * Internal render phase - Create DOM structure\n     * Called top-down (parent before children) when part of lifecycle\n     * This is an internal method - users should call render() instead\n     *\n     * @param id Optional scoped ID - if provided, delegates to child component's _render()\n     * @returns The current _render_count after incrementing (used to detect stale renders)\n     * @private\n     */\n    _render(id = null) {\n      this._render_count++;\n      const current_render_id = this._render_count;\n      if (this._stopped)\n        return current_render_id;\n      if (id) {\n        const $element = this.$id(id);\n        if ($element.length === 0) {\n          throw new Error(`[JQHTML] render(\"${id}\") - no such id.\nComponent \"${this.component_name()}\" has no child element with $id=\"${id}\".`);\n        }\n        const child = $element.data(\"_component\");\n        if (!child) {\n          throw new Error(`[JQHTML] render(\"${id}\") - element is not a component or does not have $redrawable attribute set.\nElement with $id=\"${id}\" exists but is not initialized as a component.\nAdd $redrawable attribute or make it a proper component.`);\n        }\n        return child._render();\n      }\n      if (this.__loading) {\n        throw new Error(`[JQHTML] Component \"${this.component_name()}\" attempted to call render() during on_load().\non_load() should ONLY modify this.data. DOM updates happen automatically after on_load() completes.\n\nFix: Remove the this.render() call from on_load().\nThe framework will automatically re-render if this.data changes during on_load().`);\n      }\n      this._log_lifecycle(\"render\", \"start\");\n      if (!$.contains(document.documentElement, this.$[0])) {\n        this._use_dom_fallback = true;\n      } else {\n        this._use_dom_fallback = false;\n      }\n      if (this._did_first_render) {\n        this.$.find(\".Jqhtml_Component\").each(function() {\n          const child = $(this).data(\"_component\");\n          if (child && !child._stopped) {\n            child._stop();\n          }\n        });\n        this.$[0].innerHTML = \"\";\n      } else {\n        this._did_first_render = true;\n      }\n      this.$.removeClass(\"_Component_Stopped\");\n      if (this._data_before_render === null) {\n        this._data_before_render = JSON.stringify(this.data);\n      }\n      this._dom_children.clear();\n      let template_def;\n      if (this.args._component_name) {\n        template_def = get_template(this.args._component_name);\n      } else {\n        template_def = get_template_by_class(this.constructor);\n      }\n      if (template_def && template_def.render) {\n        const jqhtml2 = {\n          escape_html: (str) => {\n            const div = document.createElement(\"div\");\n            div.textContent = String(str);\n            return div.innerHTML;\n          }\n        };\n        const defaultContent = () => \"\";\n        let [instructions, context] = template_def.render.bind(this)(\n          this.data,\n          this.args,\n          this.args._innerhtml_function || defaultContent,\n          // Content function with fallback\n          jqhtml2\n          // Utilities object\n        );\n        if (instructions && typeof instructions === \"object\" && instructions._slots && !Array.isArray(instructions)) {\n          const componentName = template_def.name || this.args._component_name || this.constructor.name;\n          console.log(`[JQHTML] Slot-only template detected for ${componentName}`);\n          let parentTemplate = null;\n          let parentTemplateName = null;\n          if (template_def.extends) {\n            console.log(`[JQHTML]   Using explicit extends: ${template_def.extends}`);\n            parentTemplate = get_template(template_def.extends);\n            parentTemplateName = template_def.extends;\n          }\n          if (!parentTemplate) {\n            let currentClass = Object.getPrototypeOf(this.constructor);\n            while (currentClass && currentClass.name !== \"Object\" && currentClass.name !== \"Jqhtml_Component\") {\n              const className = currentClass.name;\n              console.log(`[JQHTML]   Checking parent: ${className}`);\n              try {\n                const classTemplate = get_template(className);\n                if (classTemplate && classTemplate.name !== \"Jqhtml_Component\") {\n                  console.log(`[JQHTML]   Found parent template: ${className}`);\n                  parentTemplate = classTemplate;\n                  parentTemplateName = className;\n                  break;\n                }\n              } catch (error) {\n                console.warn(`[JQHTML] Error finding parent template ${className}:`, error);\n              }\n              currentClass = Object.getPrototypeOf(currentClass);\n            }\n          }\n          if (parentTemplate) {\n            try {\n              const childSlots = instructions._slots;\n              const contentFunction = (slotName, data) => {\n                if (childSlots[slotName] && typeof childSlots[slotName] === \"function\") {\n                  const [slotInstructions, slotContext] = childSlots[slotName](data);\n                  return [slotInstructions, slotContext];\n                }\n                return \"\";\n              };\n              const [parentInstructions, parentContext] = parentTemplate.render.bind(this)(\n                this.data,\n                this.args,\n                contentFunction,\n                // Pass content function that invokes child slots\n                jqhtml2\n              );\n              console.log(`[JQHTML]   Parent template invoked successfully`);\n              instructions = parentInstructions;\n              context = parentContext;\n            } catch (error) {\n              console.warn(`[JQHTML] Error invoking parent template ${parentTemplateName}:`, error);\n              instructions = [];\n            }\n          } else {\n            console.warn(`[JQHTML] No parent template found for ${this.constructor.name}, rendering empty`);\n            instructions = [];\n          }\n        }\n        const flattenedInstructions = this._flatten_instructions(instructions);\n        process_instructions(flattenedInstructions, this.$, this);\n      }\n      this._update_debug_attrs();\n      this._log_lifecycle(\"render\", \"complete\");\n      const renderResult = this.on_render();\n      if (renderResult && typeof renderResult.then === \"function\") {\n        console.warn(`[JQHTML] Component \"${this.component_name()}\" returned a Promise from on_render(). on_render() must be synchronous code. Remove 'async' from the function declaration.`);\n      }\n      this.trigger(\"render\");\n      const isRerender = this._ready_state >= 3;\n      applyDebugDelay(isRerender ? \"rerender\" : \"render\");\n      return current_render_id;\n    }\n    /**\n     * Public render method - re-renders component and completes lifecycle\n     * This is what users should call when they want to update a component.\n     *\n     * Lifecycle sequence:\n     * 1. _render() - Updates DOM synchronously, calls on_render(), fires 'render' event\n     * 2. Async continuation (fire and forget):\n     *    - _wait_for_children_ready() - Waits for all children to reach ready state\n     *    - on_ready() - Calls user's ready hook\n     *    - trigger('ready') - Fires ready event\n     *\n     * Returns immediately after _render() completes - does NOT wait for children\n     */\n    render(id = null) {\n      if (this._stopped)\n        return;\n      if (id) {\n        const $element = this.$id(id);\n        if ($element.length === 0) {\n          throw new Error(`[JQHTML] render(\"${id}\") - no such id.\nComponent \"${this.component_name()}\" has no child element with $id=\"${id}\".`);\n        }\n        const child = $element.data(\"_component\");\n        if (!child) {\n          throw new Error(`[JQHTML] render(\"${id}\") - element is not a component or does not have $redrawable attribute set.\nElement with $id=\"${id}\" exists but is not initialized as a component.\nAdd $redrawable attribute or make it a proper component.`);\n        }\n        return child.render();\n      }\n      const render_id = this._render();\n      (async () => {\n        await this._wait_for_children_ready();\n        if (this._render_count !== render_id) {\n          return;\n        }\n        await this.on_ready();\n        await this.trigger(\"ready\");\n      })();\n    }\n    /**\n     * Alias for render() - re-renders component with current data\n     * Provided for API consistency and clarity\n     */\n    redraw(id = null) {\n      return this.render(id);\n    }\n    /**\n     * Create phase - Quick setup, prepare UI\n     * Called bottom-up (children before parent)\n     */\n    async create() {\n      if (this._stopped || this._ready_state >= 1)\n        return;\n      this._log_lifecycle(\"create\", \"start\");\n      const result = this.on_create();\n      if (result && typeof result.then === \"function\") {\n        console.warn(`[JQHTML] Component \"${this.component_name()}\" returned a Promise from on_create(). on_create() must be synchronous code. Remove 'async' from the function declaration.`);\n        await result;\n      }\n      this._ready_state = 1;\n      this._update_debug_attrs();\n      this._log_lifecycle(\"create\", \"complete\");\n      this.trigger(\"create\");\n    }\n    /**\n     * Load phase - Fetch data from APIs\n     * Called bottom-up, fully parallel\n     * NO DOM MODIFICATIONS ALLOWED IN THIS PHASE\n     */\n    async load() {\n      if (this._stopped || this._ready_state >= 2)\n        return;\n      this._log_lifecycle(\"load\", \"start\");\n      const argsBeforeLoad = JSON.stringify(this.args);\n      const propertiesBeforeLoad = new Set(Object.keys(this));\n      this.__loading = true;\n      try {\n        await this.on_load();\n      } finally {\n        this.__loading = false;\n      }\n      const argsAfterLoad = JSON.stringify(this.args);\n      const propertiesAfterLoad = Object.keys(this);\n      if (argsBeforeLoad !== argsAfterLoad) {\n        console.error(`[JQHTML] WARNING: Component \"${this.component_name()}\" modified this.args in on_load().\non_load() should ONLY modify this.data. The this.args property is read-only.\n\nBefore: ${argsBeforeLoad}\nAfter:  ${argsAfterLoad}\n\nFix: Move your modifications to this.data instead.`);\n      }\n      const newProperties = propertiesAfterLoad.filter((prop) => !propertiesBeforeLoad.has(prop) && prop !== \"data\");\n      if (newProperties.length > 0) {\n        console.error(`[JQHTML] WARNING: Component \"${this.component_name()}\" added new properties in on_load().\non_load() should ONLY modify this.data. New properties detected: ${newProperties.join(\", \")}\n\nFix: Store your data in this.data instead:\n  \\u274C this.${newProperties[0]} = value;\n  \\u2705 this.data.${newProperties[0]} = value;`);\n      }\n      this._ready_state = 2;\n      this._update_debug_attrs();\n      this._log_lifecycle(\"load\", \"complete\");\n      this.trigger(\"load\");\n    }\n    /**\n     * Ready phase - Component fully initialized\n     * Called bottom-up (children before parent)\n     */\n    async ready() {\n      if (this._stopped || this._ready_state >= 4)\n        return;\n      this._log_lifecycle(\"ready\", \"start\");\n      await this._wait_for_children_ready();\n      await this.on_ready();\n      this._ready_state = 4;\n      this._update_debug_attrs();\n      this._log_lifecycle(\"ready\", \"complete\");\n      this.trigger(\"ready\");\n    }\n    /**\n     * Wait for all child components to reach ready state\n     * Ensures bottom-up ordering (children ready before parent)\n     * @private\n     */\n    async _wait_for_children_ready() {\n      const children = this._get_dom_children();\n      if (children.length === 0) {\n        return;\n      }\n      const ready_promises = [];\n      for (const child of children) {\n        if (child._ready_state >= 4) {\n          continue;\n        }\n        const ready_promise = new Promise((resolve) => {\n          child.on(\"ready\", () => resolve());\n        });\n        ready_promises.push(ready_promise);\n      }\n      await Promise.all(ready_promises);\n    }\n    /**\n     * Reinitialize the component - full reset and re-initialization\n     * Wipes the innerHTML, resets data to empty, and runs full lifecycle\n     */\n    async reinitialize() {\n      if (this._stopped)\n        return;\n      this._log_lifecycle(\"reinitialize\", \"start\");\n      this.$[0].innerHTML = \"\";\n      this.data = {};\n      this._ready_state = 0;\n      this._data_before_render = null;\n      this._dom_children.clear();\n      await this._render();\n      await this.create();\n      await this.load();\n      if (this.should_rerender()) {\n        await this._render();\n      }\n      await this.ready();\n      this._log_lifecycle(\"reinitialize\", \"complete\");\n    }\n    /**\n     * Reload component - re-fetch data and re-render\n     * Re-runs on_load(), always renders, and calls on_ready()\n     */\n    async reload() {\n      if (this._stopped)\n        return;\n      this._log_lifecycle(\"reload\", \"start\");\n      const has_custom_on_load = this.on_load !== _Jqhtml_Component.prototype.on_load;\n      if (has_custom_on_load) {\n        const argsBeforeLoad = JSON.stringify(this.args);\n        const propertiesBeforeLoad = new Set(Object.keys(this));\n        this.__loading = true;\n        try {\n          await this.on_load();\n        } finally {\n          this.__loading = false;\n        }\n        const argsAfterLoad = JSON.stringify(this.args);\n        const propertiesAfterLoad = Object.keys(this);\n        if (argsBeforeLoad !== argsAfterLoad) {\n          console.error(`[JQHTML] WARNING: Component \"${this.component_name()}\" modified this.args in on_load().\non_load() should ONLY modify this.data. The this.args property is read-only.\n\nBefore: ${argsBeforeLoad}\nAfter:  ${argsAfterLoad}\n\nFix: Move your modifications to this.data instead.`);\n        }\n        const newProperties = propertiesAfterLoad.filter((prop) => !propertiesBeforeLoad.has(prop) && prop !== \"data\");\n        if (newProperties.length > 0) {\n          console.error(`[JQHTML] WARNING: Component \"${this.component_name()}\" added new properties in on_load().\non_load() should ONLY modify this.data. New properties detected: ${newProperties.join(\", \")}\n\nFix: Store your data in this.data instead:\n  \\u274C this.${newProperties[0]} = value;\n  \\u2705 this.data.${newProperties[0]} = value;`);\n        }\n      }\n      await this.render();\n      this._log_lifecycle(\"reload\", \"complete\");\n    }\n    /**\n     * Destroy the component and cleanup\n     * Called automatically by MutationObserver when component is removed from DOM\n     * Can also be called manually for explicit cleanup\n     */\n    /**\n     * Internal stop method - stops just this component (no children)\n     * Sets stopped flag, calls lifecycle hooks, but leaves DOM intact\n     * @private\n     */\n    _stop() {\n      if (this._stopped)\n        return;\n      this._stopped = true;\n      const has_custom_destroy = this.on_destroy !== _Jqhtml_Component.prototype.on_destroy;\n      const has_destroy_callbacks = this._on_registered(\"destroy\");\n      if (!has_custom_destroy && !has_destroy_callbacks) {\n        this._lifecycle_manager.unregister_component(this);\n        this._ready_state = 99;\n        return;\n      }\n      this._log_lifecycle(\"destroy\", \"start\");\n      this.$.addClass(\"_Component_Stopped\");\n      this._lifecycle_manager.unregister_component(this);\n      const destroyResult = this.on_destroy();\n      if (destroyResult && typeof destroyResult.then === \"function\") {\n        console.warn(`[JQHTML] Component \"${this.component_name()}\" returned a Promise from on_destroy(). on_destroy() must be synchronous code. Remove 'async' from the function declaration.`);\n      }\n      this.trigger(\"destroy\");\n      this.$.trigger(\"destroy\");\n      if (this._dom_parent) {\n        this._dom_parent._dom_children.delete(this);\n      }\n      this._ready_state = 99;\n      this._update_debug_attrs();\n      this._log_lifecycle(\"destroy\", \"complete\");\n    }\n    /**\n     * Stop component lifecycle - stops all descendant components then self\n     * Leaves DOM intact, just stops lifecycle engine and fires cleanup hooks\n     */\n    stop() {\n      this.$.find(\".Jqhtml_Component\").each(function() {\n        const child = $(this).data(\"_component\");\n        if (child && !child._stopped) {\n          child._stop();\n        }\n      });\n      this._stop();\n    }\n    // -------------------------------------------------------------------------\n    // Overridable Lifecycle Hooks\n    // -------------------------------------------------------------------------\n    on_render() {\n    }\n    on_create() {\n    }\n    async on_load() {\n    }\n    async on_ready() {\n    }\n    on_destroy() {\n    }\n    /**\n     * Should component re-render after load?\n     * By default, only re-renders if data has changed\n     * Override to control re-rendering behavior\n     */\n    should_rerender() {\n      const currentDataState = JSON.stringify(this.data);\n      const dataChanged = this._data_before_render !== currentDataState;\n      if (dataChanged) {\n        this._data_before_render = currentDataState;\n      }\n      return dataChanged;\n    }\n    // -------------------------------------------------------------------------\n    // Public API\n    // -------------------------------------------------------------------------\n    /**\n     * Get component name for debugging\n     */\n    component_name() {\n      return this.constructor.name;\n    }\n    /**\n     * Emit a jQuery event from component root\n     */\n    emit(event_name, data) {\n      this._log_debug(\"emit\", event_name, data);\n      this.$.trigger(event_name, data);\n    }\n    /**\n     * Register lifecycle event callback\n     * Allowed events: 'render', 'create', 'load', 'ready', 'destroy'\n     * Callbacks fire after the lifecycle method completes\n     * If the event has already occurred, the callback fires immediately AND registers for future occurrences\n     */\n    on(event_name, callback) {\n      const allowed_events = [\"render\", \"create\", \"load\", \"ready\", \"destroy\"];\n      if (!allowed_events.includes(event_name)) {\n        console.error(`[JQHTML] Component.on() only supports lifecycle events: ${allowed_events.join(\", \")}. Received: ${event_name}`);\n        return this;\n      }\n      if (!this._lifecycle_callbacks.has(event_name)) {\n        this._lifecycle_callbacks.set(event_name, []);\n      }\n      this._lifecycle_callbacks.get(event_name).push(callback);\n      if (this._lifecycle_states.has(event_name)) {\n        try {\n          callback(this);\n        } catch (error) {\n          console.error(`[JQHTML] Error in ${event_name} callback:`, error);\n        }\n      }\n      return this;\n    }\n    /**\n     * Trigger a lifecycle event - fires all registered callbacks\n     * Marks event as occurred so future .on() calls fire immediately\n     */\n    trigger(event_name) {\n      this._lifecycle_states.add(event_name);\n      const callbacks = this._lifecycle_callbacks.get(event_name);\n      if (callbacks) {\n        for (const callback of callbacks) {\n          try {\n            callback.bind(this)(this);\n          } catch (error) {\n            console.error(`[JQHTML] Error in ${event_name} callback:`, error);\n          }\n        }\n      }\n    }\n    /**\n     * Check if any callbacks are registered for a given event\n     * Used to determine if cleanup logic needs to run\n     */\n    _on_registered(event_name) {\n      const callbacks = this._lifecycle_callbacks.get(event_name);\n      return !!(callbacks && callbacks.length > 0);\n    }\n    /**\n     * Find element by scoped ID\n     *\n     * Searches for elements with id=\"local_id:THIS_COMPONENT_CID\"\n     *\n     * Example:\n     *   Template: <button $id=\"save_btn\">Save</button>\n     *   Rendered: <button id=\"save_btn:abc123\" data-id=\"save_btn\">Save</button>\n     *   Access:   this.$id('save_btn')  // Returns jQuery element\n     *\n     * Performance: Uses native document.getElementById() when component is in DOM,\n     * falls back to jQuery.find() for components not yet attached to DOM.\n     *\n     * @param local_id The local ID (without _cid suffix)\n     * @returns jQuery element with id=\"local_id:_cid\", or empty jQuery object if not found\n     */\n    $id(local_id) {\n      const scopedId = `${local_id}:${this._cid}`;\n      const el = document.getElementById(scopedId);\n      if (el) {\n        return $(el);\n      }\n      return this.$.find(`#${$.escapeSelector(scopedId)}`);\n    }\n    /**\n     * Get component instance by scoped ID\n     *\n     * Convenience method that finds element by scoped ID and returns the component instance.\n     *\n     * Example:\n     *   Template: <User_Card $id=\"active_user\" />\n     *   Access:   const user = this.id('active_user');  // Returns User_Card instance\n     *             user.data.name  // Access component's data\n     *\n     * @param local_id The local ID (without _cid suffix)\n     * @returns Component instance or null if not found or not a component\n     */\n    id(local_id) {\n      const element = this.$id(local_id);\n      const component = element.data(\"_component\");\n      if (!component && element.length > 0) {\n        console.warn(`Component ${this.constructor.name} tried to call .id('${local_id}') - ${local_id} exists, however, it is not a component or $redrawable. Did you forget to add $redrawable to the tag?`);\n      }\n      return component || null;\n    }\n    /**\n     * Get the component that instantiated this component (rendered it in their template)\n     * Returns null if component was created programmatically via $().component()\n     */\n    instantiator() {\n      return this._instantiator;\n    }\n    /**\n     * Find descendant components by CSS selector\n     */\n    find(selector) {\n      const components = [];\n      this.$.find(selector).each((_, el) => {\n        const comp = $(el).data(\"_component\");\n        if (comp instanceof _Jqhtml_Component) {\n          components.push(comp);\n        }\n      });\n      return components;\n    }\n    /**\n     * Find closest ancestor component matching selector\n     */\n    closest(selector) {\n      let current = this.$.parent();\n      while (current.length > 0) {\n        if (current.is(selector)) {\n          const comp = current.data(\"_component\");\n          if (comp instanceof _Jqhtml_Component) {\n            return comp;\n          }\n        }\n        current = current.parent();\n      }\n      return null;\n    }\n    // -------------------------------------------------------------------------\n    // Static Methods\n    // -------------------------------------------------------------------------\n    /**\n     * Get CSS class hierarchy for this component type\n     */\n    static get_class_hierarchy() {\n      const classes = [];\n      let ctor = this;\n      while (ctor) {\n        if (!ctor.name || typeof ctor.name !== \"string\") {\n          break;\n        }\n        if (ctor.name !== \"Object\" && ctor.name !== \"\") {\n          let normalizedName = ctor.name;\n          if (normalizedName === \"_Jqhtml_Component\" || normalizedName === \"_Base_Jqhtml_Component\") {\n            normalizedName = \"Jqhtml_Component\";\n          }\n          classes.push(normalizedName);\n        }\n        const nextProto = Object.getPrototypeOf(ctor);\n        if (!nextProto || nextProto === Object.prototype || nextProto.constructor === Object) {\n          break;\n        }\n        ctor = nextProto;\n      }\n      return classes;\n    }\n    // -------------------------------------------------------------------------\n    // Private Implementation\n    // -------------------------------------------------------------------------\n    _generate_cid() {\n      return uid();\n    }\n    /**\n     * Flatten instruction array - converts ['_content', [...]] markers to flat array\n     * Recursively flattens nested content from content() calls\n     */\n    _flatten_instructions(instructions) {\n      const result = [];\n      for (const instruction of instructions) {\n        if (Array.isArray(instruction) && instruction[0] === \"_content\" && Array.isArray(instruction[1])) {\n          const contentInstructions = this._flatten_instructions(instruction[1]);\n          result.push(...contentInstructions);\n        } else {\n          result.push(instruction);\n        }\n      }\n      return result;\n    }\n    _apply_css_classes() {\n      const hierarchy = this.constructor.get_class_hierarchy();\n      const classesToAdd = [...hierarchy];\n      if (this.args._component_name && this.args._component_name !== this.constructor.name) {\n        classesToAdd.unshift(this.args._component_name);\n      }\n      const publicClasses = classesToAdd.filter((className) => {\n        if (!className || typeof className !== \"string\") {\n          console.warn(\"[JQHTML] Filtered out invalid class name:\", className);\n          return false;\n        }\n        return !className.startsWith(\"_\");\n      });\n      if (publicClasses.length > 0) {\n        this.$.addClass(publicClasses.join(\" \"));\n      }\n    }\n    _apply_default_attributes() {\n      let template;\n      if (this.args._component_name) {\n        template = get_template(this.args._component_name);\n      } else {\n        template = get_template_by_class(this.constructor);\n      }\n      if (template && template.defaultAttributes) {\n        const defineAttrs = { ...template.defaultAttributes };\n        delete defineAttrs.tag;\n        if (window.jqhtml?.debug?.enabled) {\n          const componentName = template.name || this.args._component_name || this.constructor.name;\n          console.log(`[Component] Applying defaultAttributes for ${componentName}:`, defineAttrs);\n        }\n        for (const [key, value] of Object.entries(defineAttrs)) {\n          if (key === \"class\") {\n            const existingClasses = this.$.attr(\"class\");\n            if (existingClasses) {\n              const existing = existingClasses.split(/\\s+/).filter((c) => c);\n              const newClasses = String(value).split(/\\s+/).filter((c) => c);\n              for (const newClass of newClasses) {\n                if (!existing.includes(newClass)) {\n                  existing.push(newClass);\n                }\n              }\n              this.$.attr(\"class\", existing.join(\" \"));\n            } else {\n              this.$.attr(\"class\", value);\n            }\n          } else if (key === \"style\") {\n            const existingStyle = this.$.attr(\"style\");\n            if (existingStyle) {\n              const existingRules = /* @__PURE__ */ new Map();\n              existingStyle.split(\";\").forEach((rule) => {\n                const [prop, val] = rule.split(\":\").map((s) => s.trim());\n                if (prop && val)\n                  existingRules.set(prop, val);\n              });\n              String(value).split(\";\").forEach((rule) => {\n                const [prop, val] = rule.split(\":\").map((s) => s.trim());\n                if (prop && val)\n                  existingRules.set(prop, val);\n              });\n              const merged = Array.from(existingRules.entries()).map(([prop, val]) => `${prop}: ${val}`).join(\"; \");\n              this.$.attr(\"style\", merged);\n            } else {\n              this.$.attr(\"style\", value);\n            }\n          } else if (key.startsWith(\"$\") || key.startsWith(\"data-\")) {\n            const dataKey = key.startsWith(\"$\") ? key.substring(1) : key.startsWith(\"data-\") ? key.substring(5) : key;\n            if (!(dataKey in this.args)) {\n              this.args[dataKey] = value;\n              this.$.data(dataKey, value);\n              this.$.attr(key.startsWith(\"$\") ? `data-${dataKey}` : key, String(value));\n            }\n          } else {\n            if (!this.$.attr(key)) {\n              this.$.attr(key, value);\n            }\n          }\n        }\n      }\n    }\n    _set_attributes() {\n      this.$.attr(\"data-cid\", this._cid);\n      if (window.jqhtml?.debug?.verbose) {\n        this.$.attr(\"data-_lifecycle-state\", this._ready_state.toString());\n      }\n    }\n    _update_debug_attrs() {\n      if (window.jqhtml?.debug?.verbose) {\n        this.$.attr(\"data-_lifecycle-state\", this._ready_state.toString());\n      }\n    }\n    _find_dom_parent() {\n      let current = this.$.parent();\n      while (current.length > 0) {\n        const parent = current.data(\"_component\");\n        if (parent instanceof _Jqhtml_Component) {\n          this._dom_parent = parent;\n          parent._dom_children.add(this);\n          break;\n        }\n        current = current.parent();\n      }\n    }\n    /**\n     * Get DOM children (components in DOM subtree)\n     * Uses fast _dom_children registry when possible, falls back to DOM traversal for off-DOM components\n     * @private - Used internally for lifecycle coordination\n     */\n    _get_dom_children() {\n      if (this._use_dom_fallback) {\n        const directChildren = [];\n        this.$.find(\".Jqhtml_Component\").each((_, el) => {\n          const $el = $(el);\n          const comp = $el.data(\"_component\");\n          if (comp instanceof _Jqhtml_Component) {\n            const closestParent = $el.parent().closest(\".Jqhtml_Component\");\n            if (closestParent.length === 0 || closestParent.data(\"_component\") === this) {\n              directChildren.push(comp);\n            }\n          }\n        });\n        return directChildren;\n      }\n      const children = Array.from(this._dom_children);\n      return children.filter((child) => {\n        return $.contains(document.documentElement, child.$[0]);\n      });\n    }\n    _log_lifecycle(phase, status) {\n      logLifecycle(this, phase, status);\n      if (typeof window !== \"undefined\" && window.JQHTML_DEBUG) {\n        window.JQHTML_DEBUG.log(this.component_name(), phase, status, {\n          cid: this._cid,\n          ready_state: this._ready_state,\n          args: this.args\n        });\n      }\n    }\n    _log_debug(action, ...args) {\n      if (typeof window !== \"undefined\" && window.JQHTML_DEBUG) {\n        window.JQHTML_DEBUG.log(this.component_name(), \"debug\", `${action}: ${args.map((a) => JSON.stringify(a)).join(\", \")}`);\n      }\n    }\n  };\n  async function process_slot_inheritance(component, childSlots) {\n    let currentClass = Object.getPrototypeOf(component.constructor);\n    console.log(`[JQHTML] Walking prototype chain for ${component.constructor.name}`);\n    while (currentClass && currentClass !== Jqhtml_Component && currentClass.name !== \"Object\") {\n      const className = currentClass.name;\n      console.log(`[JQHTML]   Checking parent class: ${className}`);\n      if (className === \"_Jqhtml_Component\" || className === \"_Base_Jqhtml_Component\") {\n        currentClass = Object.getPrototypeOf(currentClass);\n        continue;\n      }\n      try {\n        const parentTemplate = get_template(className);\n        console.log(`[JQHTML]   Template found for ${className}:`, parentTemplate ? parentTemplate.name : \"null\");\n        if (parentTemplate && parentTemplate.name !== \"Jqhtml_Component\") {\n          console.log(`[JQHTML]   Invoking parent template ${className}`);\n          const [parentInstructions, parentContext] = parentTemplate.render.call(\n            component,\n            component.data,\n            component.args,\n            childSlots\n            // Pass child slots as content parameter\n          );\n          if (parentInstructions && typeof parentInstructions === \"object\" && parentInstructions._slots) {\n            console.log(`[JQHTML]   Parent also slot-only, recursing`);\n            return await process_slot_inheritance(component, parentInstructions._slots);\n          }\n          console.log(`[JQHTML]   Parent returned instructions, inheritance complete`);\n          return [parentInstructions, parentContext];\n        }\n      } catch (error) {\n        console.warn(`[JQHTML] Error looking up parent template for ${className}:`, error);\n      }\n      currentClass = Object.getPrototypeOf(currentClass);\n    }\n    console.warn(`[JQHTML] No parent template found after walking chain`);\n    return null;\n  }\n  async function render_template(component, template_fn) {\n    let render_fn = template_fn;\n    if (!render_fn) {\n      const template_def = get_template_by_class(component.constructor);\n      render_fn = template_def.render;\n    }\n    if (!render_fn) {\n      return;\n    }\n    component.$.empty();\n    const defaultContent = () => \"\";\n    let [instructions, context] = render_fn.call(\n      component,\n      component.data,\n      component.args,\n      defaultContent\n      // Default content function that returns empty string\n    );\n    if (instructions && typeof instructions === \"object\" && instructions._slots) {\n      console.log(`[JQHTML] Slot-only template detected for ${component.constructor.name}, invoking inheritance`);\n      const result = await process_slot_inheritance(component, instructions._slots);\n      if (result) {\n        console.log(`[JQHTML] Parent template found, using parent instructions`);\n        instructions = result[0];\n        context = result[1];\n      } else {\n        console.warn(`[JQHTML] No parent template found for ${component.constructor.name}, rendering empty`);\n        instructions = [];\n      }\n    }\n    await process_instructions(instructions, component.$, component);\n    await process_bindings(component);\n    await attach_event_handlers(component);\n  }\n  async function process_bindings(component) {\n    component.$.find(\"[data-bind-prop], [data-bind-value], [data-bind-text], [data-bind-html], [data-bind-class], [data-bind-style]\").each((_, element) => {\n      const el = $(element);\n      const attrs = element.attributes;\n      for (let i = 0; i < attrs.length; i++) {\n        const attr = attrs[i];\n        if (attr.name.startsWith(\"data-bind-\")) {\n          const binding_type = attr.name.substring(10);\n          const expression = attr.value;\n          try {\n            const value = evaluate_expression(expression, component);\n            switch (binding_type) {\n              case \"prop\":\n                const prop_name = el.attr(\"data-bind-prop-name\") || \"value\";\n                el.prop(prop_name, value);\n                break;\n              case \"value\":\n                el.val(value);\n                break;\n              case \"text\":\n                el.text(value);\n                break;\n              case \"html\":\n                el.html(value);\n                break;\n              case \"class\":\n                if (typeof value === \"object\") {\n                  Object.entries(value).forEach(([className, enabled]) => {\n                    el.toggleClass(className, !!enabled);\n                  });\n                } else {\n                  el.addClass(String(value));\n                }\n                break;\n              case \"style\":\n                if (typeof value === \"object\") {\n                  el.css(value);\n                } else {\n                  el.attr(\"style\", String(value));\n                }\n                break;\n              default:\n                el.attr(binding_type, value);\n            }\n          } catch (error) {\n            console.error(`Error evaluating binding \"${expression}\":`, error);\n          }\n        }\n      }\n    });\n  }\n  async function attach_event_handlers(component) {\n    component.$.find(\"[data-on-click], [data-on-change], [data-on-submit], [data-on-keyup], [data-on-keydown], [data-on-focus], [data-on-blur]\").each((_, element) => {\n      const el = $(element);\n      const attrs = element.attributes;\n      for (let i = 0; i < attrs.length; i++) {\n        const attr = attrs[i];\n        if (attr.name.startsWith(\"data-on-\")) {\n          const event_name = attr.name.substring(8);\n          const handler_expr = attr.value;\n          el.removeAttr(attr.name);\n          el.on(event_name, function(event) {\n            try {\n              const handler = evaluate_handler(handler_expr, component);\n              if (typeof handler === \"function\") {\n                handler.call(component, event);\n              } else {\n                evaluate_expression(handler_expr, component, { $event: event });\n              }\n            } catch (error) {\n              console.error(`Error in ${event_name} handler \"${handler_expr}\":`, error);\n            }\n          });\n        }\n      }\n    });\n  }\n  function evaluate_expression(expression, component, locals = {}) {\n    const context = {\n      // Component properties\n      data: component.data,\n      args: component.args,\n      $: component.$,\n      // Component methods\n      emit: component.emit.bind(component),\n      $id: component.$id.bind(component),\n      // Locals (like $event)\n      ...locals\n    };\n    const keys = Object.keys(context);\n    const values = Object.values(context);\n    try {\n      const fn = new Function(...keys, `return (${expression})`);\n      return fn(...values);\n    } catch (error) {\n      console.error(`Invalid expression: ${expression}`, error);\n      return void 0;\n    }\n  }\n  function evaluate_handler(expression, component) {\n    if (expression in component && typeof component[expression] === \"function\") {\n      return component[expression];\n    }\n    try {\n      return new Function(\"$event\", `\n      const { data, args, $, emit, $id } = this;\n      ${expression}\n    `).bind(component);\n    } catch (error) {\n      console.error(`Invalid handler: ${expression}`, error);\n      return null;\n    }\n  }\n  function escape_html(str) {\n    const div = document.createElement(\"div\");\n    div.textContent = str;\n    return div.innerHTML;\n  }\n  function getJQuery() {\n    if (typeof window !== \"undefined\" && window.$) {\n      return window.$;\n    }\n    if (typeof window !== \"undefined\" && window.jQuery) {\n      return window.jQuery;\n    }\n    throw new Error('FATAL: jQuery is not defined. jQuery must be loaded before using JQHTML. Add <script src=\"https://code.jquery.com/jquery-3.7.1.min.js\"><\\/script> before loading JQHTML.');\n  }\n  function getJqhtml() {\n    if (typeof window !== \"undefined\" && window.jqhtml) {\n      return window.jqhtml;\n    }\n    if (typeof globalThis !== \"undefined\" && globalThis.jqhtml) {\n      return globalThis.jqhtml;\n    }\n    throw new Error(\"FATAL: window.jqhtml is not defined. The JQHTML runtime must be loaded before using JQHTML components. Ensure @jqhtml/core is imported and initialized before attempting to use debug features.\");\n  }\n  var DebugOverlay = class _DebugOverlay {\n    constructor(options = {}) {\n      this.$container = null;\n      this.$statusIndicator = null;\n      this.$ = getJQuery();\n      if (!this.$) {\n        throw new Error(\"jQuery is required for DebugOverlay\");\n      }\n      this.options = {\n        position: \"bottom\",\n        theme: \"dark\",\n        compact: false,\n        showStatus: true,\n        autoHide: false,\n        ...options\n      };\n    }\n    /**\n     * Static method to show debug overlay (singleton pattern)\n     */\n    static show(options) {\n      if (!_DebugOverlay.instance) {\n        _DebugOverlay.instance = new _DebugOverlay(options);\n      }\n      _DebugOverlay.instance.display();\n      return _DebugOverlay.instance;\n    }\n    /**\n     * Static method to hide debug overlay\n     */\n    static hide() {\n      if (_DebugOverlay.instance) {\n        _DebugOverlay.instance.hide();\n      }\n    }\n    /**\n     * Static method to toggle debug overlay visibility\n     */\n    static toggle() {\n      if (_DebugOverlay.instance && _DebugOverlay.instance.$container) {\n        if (_DebugOverlay.instance.$container.is(\":visible\")) {\n          _DebugOverlay.hide();\n        } else {\n          _DebugOverlay.instance.display();\n        }\n      } else {\n        _DebugOverlay.show();\n      }\n    }\n    /**\n     * Static method to destroy debug overlay\n     */\n    static destroy() {\n      if (_DebugOverlay.instance) {\n        _DebugOverlay.instance.destroy();\n        _DebugOverlay.instance = null;\n      }\n    }\n    /**\n     * Display the debug overlay\n     */\n    display() {\n      if (this.$container) {\n        this.$container.show();\n        return;\n      }\n      this.createOverlay();\n      if (this.options.showStatus) {\n        this.createStatusIndicator();\n      }\n    }\n    /**\n     * Hide the debug overlay\n     */\n    hide() {\n      if (this.$container) {\n        this.$container.hide();\n      }\n      if (this.$statusIndicator) {\n        this.$statusIndicator.hide();\n      }\n    }\n    /**\n     * Remove the debug overlay completely\n     */\n    destroy() {\n      if (this.$container) {\n        this.$container.remove();\n        this.$container = null;\n      }\n      if (this.$statusIndicator) {\n        this.$statusIndicator.remove();\n        this.$statusIndicator = null;\n      }\n    }\n    /**\n     * Update the status indicator\n     */\n    updateStatus(mode) {\n      if (!this.$statusIndicator)\n        return;\n      this.$statusIndicator.text(\"Debug: \" + mode);\n      this.$statusIndicator.attr(\"class\", \"jqhtml-debug-status\" + (mode !== \"Off\" ? \" active\" : \"\"));\n    }\n    createOverlay() {\n      this.addStyles();\n      this.$container = this.$(\"<div>\").addClass(`jqhtml-debug-overlay ${this.options.theme} ${this.options.position}`);\n      const $content = this.$(\"<div>\").addClass(\"jqhtml-debug-content\");\n      const $controls = this.$(\"<div>\").addClass(\"jqhtml-debug-controls\");\n      const $title = this.$(\"<span>\").addClass(\"jqhtml-debug-title\").html(\"<strong>\\u{1F41B} JQHTML Debug:</strong>\");\n      $controls.append($title);\n      const buttons = [\n        { text: \"Slow Motion + Flash\", action: \"enableSlowMotionDebug\", class: \"success\" },\n        { text: \"Basic Debug\", action: \"enableBasicDebug\", class: \"\" },\n        { text: \"Full Debug\", action: \"enableFullDebug\", class: \"\" },\n        { text: \"Sequential\", action: \"enableSequentialMode\", class: \"\" },\n        { text: \"Clear Debug\", action: \"clearAllDebug\", class: \"danger\" },\n        { text: \"Settings\", action: \"showDebugInfo\", class: \"\" }\n      ];\n      buttons.forEach((btn) => {\n        const $button = this.$(\"<button>\").text(btn.text).addClass(\"jqhtml-debug-btn\" + (btn.class ? ` ${btn.class}` : \"\")).on(\"click\", () => this.executeAction(btn.action));\n        $controls.append($button);\n      });\n      const $toggleBtn = this.$(\"<button>\").text(this.options.compact ? \"\\u25BC\" : \"\\u25B2\").addClass(\"jqhtml-debug-toggle\").on(\"click\", () => this.toggle());\n      $controls.append($toggleBtn);\n      $content.append($controls);\n      this.$container.append($content);\n      this.$(\"body\").append(this.$container);\n    }\n    createStatusIndicator() {\n      this.$statusIndicator = this.$(\"<div>\").addClass(\"jqhtml-debug-status\").text(\"Debug: Off\").css({\n        position: \"fixed\",\n        top: \"10px\",\n        right: \"10px\",\n        background: \"#2c3e50\",\n        color: \"white\",\n        padding: \"5px 10px\",\n        borderRadius: \"4px\",\n        fontSize: \"0.75rem\",\n        zIndex: \"10001\",\n        opacity: \"0.8\",\n        fontFamily: \"monospace\"\n      });\n      this.$(\"body\").append(this.$statusIndicator);\n    }\n    addStyles() {\n      if (this.$(\"#jqhtml-debug-styles\").length > 0)\n        return;\n      const $style = this.$(\"<style>\").attr(\"id\", \"jqhtml-debug-styles\").text('.jqhtml-debug-overlay {position: fixed;left: 0;right: 0;z-index: 10000;font-family: -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, monospace;font-size: 0.8rem;box-shadow: 0 2px 10px rgba(0,0,0,0.2);}.jqhtml-debug-overlay.top {top: 0;}.jqhtml-debug-overlay.bottom {bottom: 0;}.jqhtml-debug-overlay.dark {background: #34495e;color: #ecf0f1;}.jqhtml-debug-overlay.light {background: #f8f9fa;color: #333;border-bottom: 1px solid #dee2e6;}.jqhtml-debug-content {padding: 0.5rem 1rem;}.jqhtml-debug-controls {display: flex;flex-wrap: wrap;gap: 8px;align-items: center;}.jqhtml-debug-title {margin-right: 10px;font-weight: bold;}.jqhtml-debug-btn {padding: 4px 8px;border: none;border-radius: 3px;background: #3498db;color: white;cursor: pointer;font-size: 0.75rem;transition: background 0.2s;}.jqhtml-debug-btn:hover {background: #2980b9;}.jqhtml-debug-btn.success {background: #27ae60;}.jqhtml-debug-btn.success:hover {background: #229954;}.jqhtml-debug-btn.danger {background: #e74c3c;}.jqhtml-debug-btn.danger:hover {background: #c0392b;}.jqhtml-debug-toggle {padding: 4px 8px;border: none;border-radius: 3px;background: #7f8c8d;color: white;cursor: pointer;font-size: 0.75rem;margin-left: auto;}.jqhtml-debug-toggle:hover {background: #6c7b7d;}.jqhtml-debug-status.active {background: #27ae60 !important;}@media (max-width: 768px) {.jqhtml-debug-controls {flex-direction: column;align-items: flex-start;}.jqhtml-debug-title {margin-bottom: 5px;}}');\n      this.$(\"head\").append($style);\n    }\n    toggle() {\n      this.options.compact = !this.options.compact;\n      const $toggleBtn = this.$container.find(\".jqhtml-debug-toggle\");\n      $toggleBtn.text(this.options.compact ? \"\\u25BC\" : \"\\u25B2\");\n      const $buttons = this.$container.find(\".jqhtml-debug-btn\");\n      if (this.options.compact) {\n        $buttons.hide();\n      } else {\n        $buttons.show();\n      }\n    }\n    executeAction(action) {\n      const jqhtml2 = getJqhtml();\n      if (!jqhtml2) {\n        console.warn(\"JQHTML not available - make sure it's loaded and exposed globally\");\n        return;\n      }\n      switch (action) {\n        case \"enableSlowMotionDebug\":\n          jqhtml2.setDebugSettings({\n            logFullLifecycle: true,\n            sequentialProcessing: true,\n            delayAfterComponent: 150,\n            delayAfterRender: 200,\n            delayAfterRerender: 250,\n            flashComponents: true,\n            flashDuration: 800,\n            flashColors: {\n              create: \"#3498db\",\n              render: \"#27ae60\",\n              ready: \"#9b59b6\"\n            },\n            profilePerformance: true,\n            highlightSlowRenders: 30,\n            logDispatch: true\n          });\n          this.updateStatus(\"Slow Motion\");\n          console.log(\"\\u{1F41B} Slow Motion Debug Mode Enabled\");\n          break;\n        case \"enableBasicDebug\":\n          jqhtml2.enableDebugMode(\"basic\");\n          this.updateStatus(\"Basic\");\n          console.log(\"\\u{1F41B} Basic Debug Mode Enabled\");\n          break;\n        case \"enableFullDebug\":\n          jqhtml2.enableDebugMode(\"full\");\n          this.updateStatus(\"Full\");\n          console.log(\"\\u{1F41B} Full Debug Mode Enabled\");\n          break;\n        case \"enableSequentialMode\":\n          jqhtml2.setDebugSettings({\n            logCreationReady: true,\n            sequentialProcessing: true,\n            flashComponents: true,\n            profilePerformance: true\n          });\n          this.updateStatus(\"Sequential\");\n          console.log(\"\\u{1F41B} Sequential Processing Mode Enabled\");\n          break;\n        case \"clearAllDebug\":\n          jqhtml2.clearDebugSettings();\n          this.updateStatus(\"Off\");\n          console.log(\"\\u{1F41B} All Debug Modes Disabled\");\n          break;\n        case \"showDebugInfo\":\n          const settings = JSON.stringify(jqhtml2.debug, null, 2);\n          console.log(\"\\u{1F41B} Current Debug Settings:\", settings);\n          alert(\"Debug settings logged to console:\\n\\n\" + (Object.keys(jqhtml2.debug).length > 0 ? settings : \"No debug settings active\"));\n          break;\n      }\n    }\n  };\n  DebugOverlay.instance = null;\n  if (typeof window !== \"undefined\") {\n    const urlParams = new URLSearchParams(window.location.search);\n    if (urlParams.get(\"debug\") === \"true\" || urlParams.get(\"jqhtml-debug\") === \"true\") {\n      document.addEventListener(\"DOMContentLoaded\", () => {\n        DebugOverlay.show();\n      });\n    }\n  }\n  function init_jquery_plugin(jQuery) {\n    if (!jQuery || !jQuery.fn) {\n      throw new Error(\"jQuery is required for JQHTML. Please ensure jQuery is loaded before initializing JQHTML.\");\n    }\n    if (typeof window !== \"undefined\" && window.$ !== jQuery && !jQuery.__jqhtml_checked) {\n      devWarn('jQuery instance appears to be bundled with webpack/modules rather than loaded globally.\\nFor best compatibility, it is recommended to:\\n1. Include jQuery via <script> tag from a CDN (UMD format)\\n2. Configure webpack with: externals: { jquery: \"$\" }\\n3. Remove jquery from package.json dependencies\\n\\nTo suppress this warning, set: window.JQHTML_SUPPRESS_WARNINGS = true');\n      jQuery.__jqhtml_checked = true;\n    }\n    const _jqhtml_original_jquery = jQuery;\n    const JQueryWithComponentSupport = function(selector, context) {\n      if (selector && typeof selector === \"object\" && selector.$ && typeof selector.$id === \"function\" && typeof selector.id === \"function\") {\n        return selector.$;\n      }\n      return new _jqhtml_original_jquery(selector, context);\n    };\n    Object.setPrototypeOf(JQueryWithComponentSupport, _jqhtml_original_jquery);\n    for (const key in _jqhtml_original_jquery) {\n      if (_jqhtml_original_jquery.hasOwnProperty(key)) {\n        JQueryWithComponentSupport[key] = _jqhtml_original_jquery[key];\n      }\n    }\n    JQueryWithComponentSupport.prototype = _jqhtml_original_jquery.prototype;\n    JQueryWithComponentSupport.fn = _jqhtml_original_jquery.fn;\n    if (typeof window !== \"undefined\") {\n      window.jQuery = JQueryWithComponentSupport;\n      window.$ = JQueryWithComponentSupport;\n    }\n    jQuery = JQueryWithComponentSupport;\n    const originalVal = jQuery.fn.val;\n    jQuery.fn.val = function(value) {\n      if (arguments.length === 0) {\n        const firstEl = this.first();\n        if (firstEl.length === 0)\n          return void 0;\n        const component = firstEl.data(\"_component\");\n        const tagName = firstEl.prop(\"tagName\");\n        if (component && typeof component.val === \"function\" && tagName !== \"INPUT\" && tagName !== \"TEXTAREA\") {\n          return component.val();\n        }\n        return originalVal.call(this);\n      } else {\n        this.each(function() {\n          const $el = jQuery(this);\n          const component = $el.data(\"_component\");\n          const tagName = $el.prop(\"tagName\");\n          if (component && typeof component.val === \"function\" && tagName !== \"INPUT\" && tagName !== \"TEXTAREA\") {\n            component.val(value);\n          } else {\n            originalVal.call($el, value);\n          }\n        });\n        return this;\n      }\n    };\n    jQuery.fn.component = function(componentOrName, args = {}) {\n      const element = this.first ? this.first() : this;\n      if (!componentOrName) {\n        if (element.length === 0) {\n          return null;\n        }\n        const comp = element.data(\"_component\");\n        return comp || null;\n      }\n      const existingComponent = element.data(\"_component\");\n      if (existingComponent) {\n        return existingComponent;\n      }\n      let ComponentClass;\n      let componentName;\n      if (typeof componentOrName === \"string\") {\n        componentName = componentOrName;\n        const found = get_component_class(componentOrName);\n        args = { ...args, _component_name: componentName };\n        if (!found) {\n          ComponentClass = Jqhtml_Component;\n        } else {\n          ComponentClass = found;\n        }\n      } else {\n        ComponentClass = componentOrName;\n      }\n      let targetElement = element;\n      if (componentName) {\n        const template = get_template(componentName);\n        const expectedTag = args._tag || template.tag || \"div\";\n        const currentTag = element.prop(\"tagName\").toLowerCase();\n        if (currentTag !== expectedTag.toLowerCase()) {\n          if (args._inner_html) {\n            const newElement = jQuery(`<${expectedTag}></${expectedTag}>`);\n            const oldEl = element[0];\n            if (oldEl && oldEl.attributes) {\n              for (let i = 0; i < oldEl.attributes.length; i++) {\n                const attr = oldEl.attributes[i];\n                newElement.attr(attr.name, attr.value);\n              }\n            }\n            newElement.html(element.html());\n            element.replaceWith(newElement);\n            targetElement = newElement;\n          } else {\n            console.warn(`[JQHTML] Component '${componentName}' expects tag '<${expectedTag}>' but element is '<${currentTag}>'. Element tag will not be changed. Consider using the correct tag.`);\n          }\n        }\n      }\n      const component = new ComponentClass(targetElement, args);\n      component.boot();\n      applyDebugDelay(\"component\");\n      return component;\n    };\n    const _jqhtml_jquery_overrides = {};\n    const dom_insertion_methods = [\"append\", \"prepend\", \"before\", \"after\", \"replaceWith\"];\n    for (const fnname of dom_insertion_methods) {\n      _jqhtml_jquery_overrides[fnname] = jQuery.fn[fnname];\n      jQuery.fn[fnname] = function(...args) {\n        const resolvedArgs = args.map((arg) => {\n          if (arg && typeof arg === \"object\" && arg instanceof Jqhtml_Component) {\n            return arg.$;\n          }\n          return arg;\n        });\n        const $elements = resolvedArgs.filter((arg) => arg instanceof jQuery);\n        const ret = _jqhtml_jquery_overrides[fnname].apply(this, resolvedArgs);\n        for (const $e of $elements) {\n          if ($e.closest(\"html\").length > 0) {\n            $e.find(\".Jqhtml_Component\").addBack(\".Jqhtml_Component\").each(function() {\n              const $comp = jQuery(this);\n              const component = $comp.data(\"_component\");\n              if (component && !component._ready_state) {\n                component.boot();\n              }\n            });\n          }\n        }\n        return ret;\n      };\n    }\n    jQuery.fn.shallowFind = function(selector) {\n      const results = [];\n      this.each(function() {\n        const traverse = (parent) => {\n          for (let i = 0; i < parent.children.length; i++) {\n            const child = parent.children[i];\n            if (jQuery(child).is(selector)) {\n              results.push(child);\n            } else {\n              traverse(child);\n            }\n          }\n        };\n        traverse(this);\n      });\n      return jQuery(results);\n    };\n    const originalEmpty = jQuery.fn.empty;\n    const originalHtml = jQuery.fn.html;\n    const originalText = jQuery.fn.text;\n    jQuery.fn.empty = function() {\n      return this.each(function() {\n        jQuery(this).find(\".Jqhtml_Component\").each(function() {\n          const component = jQuery(this).data(\"_component\");\n          if (component && !component._stopped) {\n            component._stop();\n          }\n        });\n        originalEmpty.call(jQuery(this));\n      });\n    };\n    jQuery.fn.html = function(value) {\n      if (arguments.length === 0) {\n        return originalHtml.call(this);\n      }\n      return this.each(function() {\n        jQuery(this).empty();\n        originalHtml.call(jQuery(this), value);\n      });\n    };\n    jQuery.fn.text = function(value) {\n      if (arguments.length === 0) {\n        return originalText.call(this);\n      }\n      return this.each(function() {\n        jQuery(this).empty();\n        originalText.call(jQuery(this), value);\n      });\n    };\n  }\n  if (typeof window !== \"undefined\" && window.jQuery) {\n    init_jquery_plugin(window.jQuery);\n  }\n  var version = \"2.2.185\";\n  var jqhtml = {\n    // Core\n    Jqhtml_Component,\n    LifecycleManager,\n    // Registry\n    register_component,\n    get_component_class,\n    register_template,\n    get_template,\n    get_template_by_class,\n    create_component,\n    has_component,\n    get_component_names,\n    get_registered_templates,\n    list_components,\n    // Template system\n    process_instructions,\n    extract_slots,\n    render_template,\n    escape_html,\n    // Version property - internal\n    __version: version,\n    // Debug settings\n    debug: {\n      enabled: false,\n      verbose: false\n    },\n    // Debug helper functions (mainly for internal use but exposed for advanced debugging)\n    setDebugSettings(settings) {\n      Object.assign(this.debug, settings);\n    },\n    enableDebugMode(level = \"basic\") {\n      if (level === \"basic\") {\n        this.debug.logCreationReady = true;\n        this.debug.logDispatch = true;\n        this.debug.flashComponents = true;\n      } else {\n        this.debug.logFullLifecycle = true;\n        this.debug.logDispatchVerbose = true;\n        this.debug.flashComponents = true;\n        this.debug.profilePerformance = true;\n        this.debug.traceDataFlow = true;\n      }\n    },\n    clearDebugSettings() {\n      this.debug = {};\n    },\n    // Debug overlay methods\n    showDebugOverlay(options) {\n      return DebugOverlay.show(options);\n    },\n    hideDebugOverlay() {\n      return DebugOverlay.hide();\n    },\n    // Export DebugOverlay class for direct access\n    DebugOverlay,\n    // Install globals function\n    installGlobals() {\n      if (typeof window !== \"undefined\") {\n        window.jqhtml = this;\n        window.Jqhtml_Component = Jqhtml_Component;\n        window.Jqhtml_LifecycleManager = LifecycleManager;\n      }\n    },\n    // Version display function - shows version of core library and all registered templates\n    _version() {\n      console.log(`JQHTML Core v${this.__version}`);\n      console.log(\"Registered Templates:\");\n      const templateNames = get_component_names();\n      if (templateNames.length === 0) {\n        console.log(\"  (no templates registered)\");\n      } else {\n        for (const name of templateNames) {\n          const template = get_template(name);\n          const templateVersion = template ? template._jqhtml_version || \"unknown\" : \"unknown\";\n          console.log(`  - ${name}: v${templateVersion}`);\n        }\n      }\n      return this.__version;\n    },\n    // Public version function - returns the stamped version number\n    version() {\n      return version;\n    }\n  };\n  if (typeof window !== \"undefined\" && !window.jqhtml) {\n    window.jqhtml = jqhtml;\n    window.Jqhtml_Component = Jqhtml_Component;\n    window.Component = Jqhtml_Component;\n    window.Jqhtml_LifecycleManager = LifecycleManager;\n    if (jqhtml.debug?.enabled) {\n      console.log(\"[JQHTML] Auto-registered window.jqhtml global for template compatibility\");\n    }\n  }\n\n  // storage/rsx-tmp/npm-compile/entry_6459e8ed0f60bda4f121420766012d53.js\n  window._rsx_npm = window._rsx_npm || {};\n  window._rsx_npm.jqhtml = jqhtml;\n  window._rsx_npm._Base_Jqhtml_Component = Jqhtml_Component;\n})();\n"]}
|