78553d4edf
Remove unused blade settings pages not linked from UI Convert remaining frontend pages to SPA actions Convert settings user_settings and general to SPA actions Convert settings profile pages to SPA actions Convert contacts and projects add/edit pages to SPA actions Convert clients add/edit page to SPA action with loading pattern Refactor component scoped IDs from $id to $sid Fix jqhtml comment syntax and implement universal error component system Update all application code to use new unified error system Remove all backwards compatibility - unified error system complete Phase 5: Remove old response classes Phase 3-4: Ajax response handler sends new format, old helpers deprecated Phase 2: Add client-side unified error foundation Phase 1: Add server-side unified error foundation Add unified Ajax error response system with constants 🤖 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.$sid(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.$sid(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.$sid('save_btn') // Returns jQuery element
|
|
*
|
|
* Performance: Uses native document.getElementById() when component is in DOM,
|
|
* falls back to jQuery.find() for components not yet attached to DOM.
|
|
*
|
|
* @param local_id The local ID (without _cid suffix)
|
|
* @returns jQuery element with id="local_id:_cid", or empty jQuery object if not found
|
|
*/
|
|
$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.$sid(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"]}
|