| 1 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 2 |
// == File /includes/page-form-builder/_out/core/bfb-core.js == | 2025-09-10 15:47
|
| 3 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 4 |
(function ( w ) {
|
| 5 |
'use strict';
|
| 6 |
|
| 7 |
// Single global namespace (idempotent & load-order safe).
|
| 8 |
const Core = ( w.WPBC_BFB_Core = w.WPBC_BFB_Core || {} );
|
| 9 |
const UI = ( Core.UI = Core.UI || {} );
|
| 10 |
|
| 11 |
/**
|
| 12 |
* Core sanitize/escape/normalize helpers.
|
| 13 |
* All methods use snake_case; camelCase aliases are provided for backwards compatibility.
|
| 14 |
*/
|
| 15 |
Core.WPBC_BFB_Sanitize = class {
|
| 16 |
|
| 17 |
/**
|
| 18 |
* Escape text for safe use in CSS selectors.
|
| 19 |
* @param {string} s - raw selector fragment
|
| 20 |
* @returns {string}
|
| 21 |
*/
|
| 22 |
static esc_css(s) {
|
| 23 |
return (w.CSS && w.CSS.escape) ? w.CSS.escape( String( s ) ) : String( s ).replace( /([^\w-])/g, '\\$1' );
|
| 24 |
}
|
| 25 |
|
| 26 |
/**
|
| 27 |
* Escape a value for attribute selectors, e.g. [data-id="<value>"].
|
| 28 |
* @param {string} v
|
| 29 |
* @returns {string}
|
| 30 |
*/
|
| 31 |
static esc_attr_value_for_selector(v) {
|
| 32 |
return String( v )
|
| 33 |
.replace( /\\/g, '\\\\' )
|
| 34 |
.replace( /"/g, '\\"' )
|
| 35 |
.replace( /\n/g, '\\A ' )
|
| 36 |
.replace( /\]/g, '\\]' );
|
| 37 |
}
|
| 38 |
|
| 39 |
/**
|
| 40 |
* Sanitize into a broadly compatible HTML id: letters, digits, - _ : . ; must start with a letter.
|
| 41 |
* @param {string} v
|
| 42 |
* @returns {string}
|
| 43 |
*/
|
| 44 |
static sanitize_html_id(v) {
|
| 45 |
let s = (v == null ? '' : String( v )).trim();
|
| 46 |
s = s
|
| 47 |
.replace( /\s+/g, '-' )
|
| 48 |
.replace( /[^A-Za-z0-9\-_\:.]/g, '-' )
|
| 49 |
.replace( /-+/g, '-' )
|
| 50 |
.replace( /^[-_.:]+|[-_.:]+$/g, '' );
|
| 51 |
if ( !s ) return 'field';
|
| 52 |
if ( !/^[A-Za-z]/.test( s ) ) s = 'f-' + s;
|
| 53 |
return s;
|
| 54 |
}
|
| 55 |
|
| 56 |
/**
|
| 57 |
* Sanitize into a safe HTML name token: letters, digits, _ -
|
| 58 |
* Must start with a letter; no dots/brackets/spaces.
|
| 59 |
* @param {string} v
|
| 60 |
* @returns {string}
|
| 61 |
*/
|
| 62 |
static sanitize_html_name(v) {
|
| 63 |
|
| 64 |
let s = (v == null ? '' : String( v )).trim();
|
| 65 |
|
| 66 |
s = s.replace( /\s+/g, '_' ).replace( /[^A-Za-z0-9_-]/g, '_' ).replace( /_+/g, '_' );
|
| 67 |
|
| 68 |
if ( ! s ) {
|
| 69 |
s = 'field';
|
| 70 |
}
|
| 71 |
if ( ! /^[A-Za-z]/.test( s ) ) {
|
| 72 |
s = 'f_' + s;
|
| 73 |
}
|
| 74 |
return s;
|
| 75 |
}
|
| 76 |
|
| 77 |
/**
|
| 78 |
* Escape for HTML text/attributes (not URLs).
|
| 79 |
* @param {any} v
|
| 80 |
* @returns {string}
|
| 81 |
*/
|
| 82 |
static escape_html(v) {
|
| 83 |
if ( v == null ) {
|
| 84 |
return '';
|
| 85 |
}
|
| 86 |
return String( v )
|
| 87 |
.replace( /&/g, '&' )
|
| 88 |
.replace( /"/g, '"' )
|
| 89 |
.replace( /'/g, ''' )
|
| 90 |
.replace( /</g, '<' )
|
| 91 |
.replace( />/g, '>' );
|
| 92 |
}
|
| 93 |
|
| 94 |
/**
|
| 95 |
* Escape minimal set for attribute-safety without slugging.
|
| 96 |
* Keeps original human text; escapes &, <, >, " and ' only.
|
| 97 |
* @param {string} s
|
| 98 |
* @returns {string}
|
| 99 |
*/
|
| 100 |
static escape_value_for_attr(s) {
|
| 101 |
return String( s == null ? '' : s )
|
| 102 |
.replace( /&/g, '&' )
|
| 103 |
.replace( /</g, '<' )
|
| 104 |
.replace( />/g, '>' )
|
| 105 |
.replace( /"/g, '"' )
|
| 106 |
.replace( /'/g, ''' );
|
| 107 |
}
|
| 108 |
|
| 109 |
/**
|
| 110 |
* Sanitize a space-separated CSS class list.
|
| 111 |
* @param {any} v
|
| 112 |
* @returns {string}
|
| 113 |
*/
|
| 114 |
static sanitize_css_classlist(v) {
|
| 115 |
if ( v == null ) return '';
|
| 116 |
return String( v ).replace( /[^\w\- ]+/g, ' ' ).replace( /\s+/g, ' ' ).trim();
|
| 117 |
}
|
| 118 |
// == NEW ==
|
| 119 |
/**
|
| 120 |
* Turn an arbitrary value into a conservative "token" (underscores, hyphens allowed).
|
| 121 |
* Useful for shortcode tokens, ids in plain text, etc.
|
| 122 |
* @param {any} v
|
| 123 |
* @returns {string}
|
| 124 |
*/
|
| 125 |
static to_token(v) {
|
| 126 |
return String( v ?? '' )
|
| 127 |
.trim()
|
| 128 |
.replace( /\s+/g, '_' )
|
| 129 |
.replace( /[^A-Za-z0-9_\-]/g, '' );
|
| 130 |
}
|
| 131 |
|
| 132 |
/**
|
| 133 |
* Convert to kebab-case (letters, digits, hyphens).
|
| 134 |
* @param {any} v
|
| 135 |
* @returns {string}
|
| 136 |
*/
|
| 137 |
static to_kebab(v) {
|
| 138 |
return String( v ?? '' )
|
| 139 |
.trim()
|
| 140 |
.replace( /[_\s]+/g, '-' )
|
| 141 |
.replace( /[^A-Za-z0-9-]/g, '' )
|
| 142 |
.replace( /-+/g, '-' )
|
| 143 |
.toLowerCase();
|
| 144 |
}
|
| 145 |
|
| 146 |
/**
|
| 147 |
* Truthy normalization for form-like inputs: true, 'true', 1, '1', 'yes', 'on'.
|
| 148 |
* @param {any} v
|
| 149 |
* @returns {boolean}
|
| 150 |
*/
|
| 151 |
static is_truthy(v) {
|
| 152 |
if ( typeof v === 'boolean' ) return v;
|
| 153 |
const s = String( v ?? '' ).trim().toLowerCase();
|
| 154 |
return s === 'true' || s === '1' || s === 'yes' || s === 'on';
|
| 155 |
}
|
| 156 |
|
| 157 |
/**
|
| 158 |
* Coerce to boolean with an optional default for empty values.
|
| 159 |
* @param {any} v
|
| 160 |
* @param {boolean} [def=false]
|
| 161 |
* @returns {boolean}
|
| 162 |
*/
|
| 163 |
static coerce_boolean(v, def = false) {
|
| 164 |
if ( v == null || v === '' ) return def;
|
| 165 |
return this.is_truthy( v );
|
| 166 |
}
|
| 167 |
|
| 168 |
/**
|
| 169 |
* Parse a "percent-like" value ('33'|'33%'|33) with fallback.
|
| 170 |
* @param {string|number|null|undefined} v
|
| 171 |
* @param {number} fallback_value
|
| 172 |
* @returns {number}
|
| 173 |
*/
|
| 174 |
static parse_percent(v, fallback_value) {
|
| 175 |
if ( v == null ) {
|
| 176 |
return fallback_value;
|
| 177 |
}
|
| 178 |
const s = String( v ).trim();
|
| 179 |
const n = parseFloat( s.replace( /%/g, '' ) );
|
| 180 |
return Number.isFinite( n ) ? n : fallback_value;
|
| 181 |
}
|
| 182 |
|
| 183 |
/**
|
| 184 |
* Clamp a number to the [min, max] range.
|
| 185 |
* @param {number} n
|
| 186 |
* @param {number} min
|
| 187 |
* @param {number} max
|
| 188 |
* @returns {number}
|
| 189 |
*/
|
| 190 |
static clamp(n, min, max) {
|
| 191 |
return Math.max( min, Math.min( max, n ) );
|
| 192 |
}
|
| 193 |
|
| 194 |
/**
|
| 195 |
* Escape a value for inclusion inside a quoted HTML attribute (double quotes).
|
| 196 |
* Replaces newlines with spaces and double quotes with single quotes.
|
| 197 |
* @param {any} v
|
| 198 |
* @returns {string}
|
| 199 |
*/
|
| 200 |
static escape_for_attr_quoted(v) {
|
| 201 |
if ( v == null ) return '';
|
| 202 |
return String( v ).replace( /\r?\n/g, ' ' ).replace( /"/g, '\'' );
|
| 203 |
}
|
| 204 |
|
| 205 |
/**
|
| 206 |
* Escape for shortcode-like tokens where double quotes and newlines should be neutralized.
|
| 207 |
* @param {any} v
|
| 208 |
* @returns {string}
|
| 209 |
*/
|
| 210 |
static escape_for_shortcode(v) {
|
| 211 |
return String( v ?? '' ).replace( /"/g, '\\"' ).replace( /\r?\n/g, ' ' );
|
| 212 |
}
|
| 213 |
|
| 214 |
/**
|
| 215 |
* JSON.parse with fallback (no throw).
|
| 216 |
* @param {string} s
|
| 217 |
* @param {any} [fallback=null]
|
| 218 |
* @returns {any}
|
| 219 |
*/
|
| 220 |
static safe_json_parse(s, fallback = null) {
|
| 221 |
try {
|
| 222 |
return JSON.parse( s );
|
| 223 |
} catch ( _ ) {
|
| 224 |
return fallback;
|
| 225 |
}
|
| 226 |
}
|
| 227 |
|
| 228 |
/**
|
| 229 |
* Stringify data-* attribute value safely (objects -> JSON, others -> String).
|
| 230 |
* @param {any} v
|
| 231 |
* @returns {string}
|
| 232 |
*/
|
| 233 |
static stringify_data_value(v) {
|
| 234 |
if ( typeof v === 'object' && v !== null ) {
|
| 235 |
try {
|
| 236 |
return JSON.stringify( v );
|
| 237 |
} catch {
|
| 238 |
console.error( 'WPBC: stringify_data_value' );
|
| 239 |
return '';
|
| 240 |
}
|
| 241 |
}
|
| 242 |
return String( v );
|
| 243 |
}
|
| 244 |
|
| 245 |
// -------------------------------------------------------------------------------------------------------------
|
| 246 |
// Strict value guards for CSS lengths and hex colors (defense-in-depth).
|
| 247 |
// -------------------------------------------------------------------------------------------------------------
|
| 248 |
/**
|
| 249 |
* Sanitize a CSS length. Allows: px, %, rem, em (lower/upper).
|
| 250 |
* Returns fallback if invalid.
|
| 251 |
* @param {any} v
|
| 252 |
* @param {string} [fallback='100%']
|
| 253 |
* @returns {string}
|
| 254 |
*/
|
| 255 |
static sanitize_css_len(v, fallback = '100%') {
|
| 256 |
const s = String( v ?? '' ).trim();
|
| 257 |
const m = s.match( /^(-?\d+(?:\.\d+)?)(px|%|rem|em)$/i );
|
| 258 |
return m ? m[0] : String( fallback );
|
| 259 |
}
|
| 260 |
|
| 261 |
/**
|
| 262 |
* Sanitize a hex color. Allows #rgb or #rrggbb (case-insensitive).
|
| 263 |
* Returns fallback if invalid.
|
| 264 |
* @param {any} v
|
| 265 |
* @param {string} [fallback='#e0e0e0']
|
| 266 |
* @returns {string}
|
| 267 |
*/
|
| 268 |
static sanitize_hex_color(v, fallback = '#e0e0e0') {
|
| 269 |
const s = String( v ?? '' ).trim();
|
| 270 |
return /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i.test( s ) ? s : String( fallback );
|
| 271 |
}
|
| 272 |
|
| 273 |
}
|
| 274 |
|
| 275 |
/**
|
| 276 |
* WPBC ID / Name service. Generates, sanitizes, and ensures uniqueness for field ids/names/html_ids within the
|
| 277 |
* canvas.
|
| 278 |
*/
|
| 279 |
Core.WPBC_BFB_IdService = class {
|
| 280 |
|
| 281 |
/**
|
| 282 |
* Constructor. Set root container of the form pages.
|
| 283 |
*
|
| 284 |
* @param {HTMLElement} pages_container - Root container of the form pages.
|
| 285 |
*/
|
| 286 |
constructor( pages_container ) {
|
| 287 |
this.pages_container = pages_container;
|
| 288 |
}
|
| 289 |
|
| 290 |
/**
|
| 291 |
* Ensure a unique **internal** field id (stored in data-id) within the canvas.
|
| 292 |
* Starts from a desired id (already sanitized or not) and appends suffixes if needed.
|
| 293 |
*
|
| 294 |
* @param {string} baseId - Desired id.
|
| 295 |
* @returns {string} Unique id.
|
| 296 |
*/
|
| 297 |
ensure_unique_field_id(baseId, currentEl = null) {
|
| 298 |
const base = Core.WPBC_BFB_Sanitize.sanitize_html_id( baseId );
|
| 299 |
let id = base || 'field';
|
| 300 |
const esc = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );
|
| 301 |
const escUid = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );
|
| 302 |
const notSelf = currentEl?.dataset?.uid ? `:not([data-uid="${escUid( currentEl.dataset.uid )}"])` : '';
|
| 303 |
while ( this.pages_container?.querySelector(
|
| 304 |
`.wpbc_bfb__panel--preview .wpbc_bfb__field${notSelf}[data-id="${esc(id)}"], .wpbc_bfb__panel--preview .wpbc_bfb__section${notSelf}[data-id="${esc(id)}"]`
|
| 305 |
) ) {
|
| 306 |
// Excludes self by data-uid .
|
| 307 |
const found = this.pages_container.querySelector( `.wpbc_bfb__panel--preview .wpbc_bfb__field[data-id="${esc( id )}"], .wpbc_bfb__panel--preview .wpbc_bfb__section[data-id="${esc( id )}"]` );
|
| 308 |
if ( found && currentEl && found === currentEl ) {
|
| 309 |
break;
|
| 310 |
}
|
| 311 |
id = `${base || 'field'}-${Math.random().toString( 36 ).slice( 2, 5 )}`;
|
| 312 |
}
|
| 313 |
return id;
|
| 314 |
}
|
| 315 |
|
| 316 |
/**
|
| 317 |
* Ensure a unique HTML name across the form.
|
| 318 |
*
|
| 319 |
* @param {string} base - Desired base name (un/sanitized).
|
| 320 |
* @param {HTMLElement|null} currentEl - If provided, ignore conflicts with this element.
|
| 321 |
* @returns {string} Unique name.
|
| 322 |
*/
|
| 323 |
ensure_unique_field_name(base, currentEl = null) {
|
| 324 |
let name = base || 'field';
|
| 325 |
const esc = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );
|
| 326 |
const escUid = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );
|
| 327 |
// Exclude the current field *and any DOM mirrors of it* (same data-uid)
|
| 328 |
const uid = currentEl?.dataset?.uid;
|
| 329 |
const notSelf = uid ? `:not([data-uid="${escUid( uid )}"])` : '';
|
| 330 |
while ( true ) {
|
| 331 |
const selector = `.wpbc_bfb__panel--preview .wpbc_bfb__field${notSelf}[data-name="${esc( name )}"]`;
|
| 332 |
const clashes = this.pages_container?.querySelectorAll( selector ) || [];
|
| 333 |
if ( clashes.length === 0 ) break; // nobody else uses this name
|
| 334 |
const m = name.match( /-(\d+)$/ );
|
| 335 |
name = m ? name.replace( /-\d+$/, '-' + (Number( m[1] ) + 1) ) : `${base}-2`;
|
| 336 |
}
|
| 337 |
return name;
|
| 338 |
}
|
| 339 |
|
| 340 |
/**
|
| 341 |
* Set field's INTERNAL id (data-id) on an element. Ensures uniqueness and optionally asks caller to refresh
|
| 342 |
* preview.
|
| 343 |
*
|
| 344 |
* @param {HTMLElement} field_el - Field element in the canvas.
|
| 345 |
* @param {string} newIdRaw - Desired id (un/sanitized).
|
| 346 |
* @param {boolean} [renderPreview=false] - Caller can decide to re-render preview.
|
| 347 |
* @returns {string} Applied unique id.
|
| 348 |
*/
|
| 349 |
set_field_id( field_el, newIdRaw, renderPreview = false ) {
|
| 350 |
const desired = Core.WPBC_BFB_Sanitize.sanitize_html_id( newIdRaw );
|
| 351 |
const unique = this.ensure_unique_field_id( desired, field_el );
|
| 352 |
field_el.setAttribute( 'data-id', unique );
|
| 353 |
if ( renderPreview ) {
|
| 354 |
// Caller decides if / when to render.
|
| 355 |
}
|
| 356 |
return unique;
|
| 357 |
}
|
| 358 |
|
| 359 |
/**
|
| 360 |
* Set field's REQUIRED HTML name (data-name). Ensures sanitized + unique per form.
|
| 361 |
* Falls back to sanitized internal id if user provides empty value.
|
| 362 |
*
|
| 363 |
* @param {HTMLElement} field_el - Field element in the canvas.
|
| 364 |
* @param {string} newNameRaw - Desired name (un/sanitized).
|
| 365 |
* @param {boolean} [renderPreview=false] - Caller can decide to re-render preview.
|
| 366 |
* @returns {string} Applied unique name.
|
| 367 |
*/
|
| 368 |
set_field_name( field_el, newNameRaw, renderPreview = false ) {
|
| 369 |
const raw = (newNameRaw == null ? '' : String( newNameRaw )).trim();
|
| 370 |
const base = raw
|
| 371 |
? Core.WPBC_BFB_Sanitize.sanitize_html_name( raw )
|
| 372 |
: Core.WPBC_BFB_Sanitize.sanitize_html_name( field_el.getAttribute( 'data-id' ) || 'field' );
|
| 373 |
|
| 374 |
const unique = this.ensure_unique_field_name( base, field_el );
|
| 375 |
field_el.setAttribute( 'data-name', unique );
|
| 376 |
if ( renderPreview ) {
|
| 377 |
// Caller decides if / when to render.
|
| 378 |
}
|
| 379 |
return unique;
|
| 380 |
}
|
| 381 |
|
| 382 |
/**
|
| 383 |
* Set field's OPTIONAL public HTML id (data-html_id). Empty value removes the attribute.
|
| 384 |
* Ensures sanitization + uniqueness among other declared HTML ids.
|
| 385 |
*
|
| 386 |
* @param {HTMLElement} field_el - Field element in the canvas.
|
| 387 |
* @param {string} newHtmlIdRaw - Desired html_id (optional).
|
| 388 |
* @param {boolean} [renderPreview=false] - Caller can decide to re-render preview.
|
| 389 |
* @returns {string} The applied html_id or empty string if removed.
|
| 390 |
*/
|
| 391 |
set_field_html_id( field_el, newHtmlIdRaw, renderPreview = false ) {
|
| 392 |
const raw = (newHtmlIdRaw == null ? '' : String( newHtmlIdRaw )).trim();
|
| 393 |
|
| 394 |
if ( raw === '' ) {
|
| 395 |
field_el.removeAttribute( 'data-html_id' );
|
| 396 |
if ( renderPreview ) {
|
| 397 |
// Caller decides if / when to render.
|
| 398 |
}
|
| 399 |
return '';
|
| 400 |
}
|
| 401 |
|
| 402 |
const desired = Core.WPBC_BFB_Sanitize.sanitize_html_id( raw );
|
| 403 |
let htmlId = desired;
|
| 404 |
const esc = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );
|
| 405 |
const escUid = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );
|
| 406 |
|
| 407 |
while ( true ) {
|
| 408 |
|
| 409 |
const uid = field_el?.dataset?.uid;
|
| 410 |
const notSelf = uid ? `:not([data-uid="${escUid( uid )}"])` : '';
|
| 411 |
|
| 412 |
const clashInCanvas = this.pages_container?.querySelector(
|
| 413 |
`.wpbc_bfb__panel--preview .wpbc_bfb__field${notSelf}[data-html_id="${esc( htmlId )}"],` +
|
| 414 |
`.wpbc_bfb__panel--preview .wpbc_bfb__section${notSelf}[data-html_id="${esc( htmlId )}"]`
|
| 415 |
);
|
| 416 |
const domClash = document.getElementById( htmlId );
|
| 417 |
|
| 418 |
// Allow when the only "clash" is inside this same field (e.g., the input you just rendered)
|
| 419 |
const domClashIsSelf = domClash === field_el || (domClash && field_el.contains( domClash ));
|
| 420 |
|
| 421 |
if ( !clashInCanvas && (!domClash || domClashIsSelf) ) {
|
| 422 |
break;
|
| 423 |
}
|
| 424 |
|
| 425 |
const m = htmlId.match( /-(\d+)$/ );
|
| 426 |
htmlId = m ? htmlId.replace( /-\d+$/, '-' + (Number( m[1] ) + 1) ) : `${desired}-2`;
|
| 427 |
}
|
| 428 |
|
| 429 |
field_el.setAttribute( 'data-html_id', htmlId );
|
| 430 |
if ( renderPreview ) {
|
| 431 |
// Caller decides if / when to render.
|
| 432 |
}
|
| 433 |
return htmlId;
|
| 434 |
}
|
| 435 |
};
|
| 436 |
|
| 437 |
/**
|
| 438 |
* WPBC Layout service. Encapsulates column width math with gap handling, presets, and utilities.
|
| 439 |
*/
|
| 440 |
Core.WPBC_BFB_LayoutService = class {
|
| 441 |
|
| 442 |
/**
|
| 443 |
* Constructor. Set options with gap between columns (%).
|
| 444 |
*
|
| 445 |
* @param {{ col_gap_percent?: number }} [opts] - Options with gap between columns (%).
|
| 446 |
*/
|
| 447 |
constructor( opts = {} ) {
|
| 448 |
this.col_gap_percent = Number.isFinite( +opts.col_gap_percent ) ? +opts.col_gap_percent : 3;
|
| 449 |
}
|
| 450 |
|
| 451 |
/**
|
| 452 |
* Compute normalized flex-basis values for a row, respecting column gaps.
|
| 453 |
* Returns bases that sum to available = 100 - (n-1)*gap.
|
| 454 |
*
|
| 455 |
* @param {HTMLElement} row_el - Row element containing .wpbc_bfb__column children.
|
| 456 |
* @param {number} [gap_percent=this.col_gap_percent] - Gap percent between columns.
|
| 457 |
* @returns {{available:number,bases:number[]}} Available space and basis values.
|
| 458 |
*/
|
| 459 |
compute_effective_bases_from_row( row_el, gap_percent = this.col_gap_percent ) {
|
| 460 |
const cols = Array.from( row_el?.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );
|
| 461 |
const n = cols.length || 1;
|
| 462 |
|
| 463 |
const raw = cols.map( ( col ) => {
|
| 464 |
const w = col.style.flexBasis || '';
|
| 465 |
const p = Core.WPBC_BFB_Sanitize.parse_percent( w, NaN );
|
| 466 |
return Number.isFinite( p ) ? p : (100 / n);
|
| 467 |
} );
|
| 468 |
|
| 469 |
const sum_raw = raw.reduce( ( a, b ) => a + b, 0 ) || 100;
|
| 470 |
const gp = Number.isFinite( +gap_percent ) ? +gap_percent : 3;
|
| 471 |
const total_gaps = Math.max( 0, n - 1 ) * gp;
|
| 472 |
const available = Math.max( 0, 100 - total_gaps );
|
| 473 |
const scale = available / sum_raw;
|
| 474 |
|
| 475 |
return {
|
| 476 |
available,
|
| 477 |
bases: raw.map( ( p ) => Math.max( 0, p * scale ) )
|
| 478 |
};
|
| 479 |
}
|
| 480 |
|
| 481 |
/**
|
| 482 |
* Apply computed bases to the row's columns (sets flex-basis %).
|
| 483 |
*
|
| 484 |
* @param {HTMLElement} row_el - Row element.
|
| 485 |
* @param {number[]} bases - Array of basis values (percent of full 100).
|
| 486 |
* @returns {void}
|
| 487 |
*/
|
| 488 |
apply_bases_to_row( row_el, bases ) {
|
| 489 |
const cols = Array.from( row_el?.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );
|
| 490 |
cols.forEach( ( col, i ) => {
|
| 491 |
const p = bases[i] ?? 0;
|
| 492 |
col.style.flexBasis = `${p}%`;
|
| 493 |
} );
|
| 494 |
}
|
| 495 |
|
| 496 |
/**
|
| 497 |
* Distribute columns evenly, respecting gap.
|
| 498 |
*
|
| 499 |
* @param {HTMLElement} row_el - Row element.
|
| 500 |
* @param {number} [gap_percent=this.col_gap_percent] - Gap percent.
|
| 501 |
* @returns {void}
|
| 502 |
*/
|
| 503 |
set_equal_bases( row_el, gap_percent = this.col_gap_percent ) {
|
| 504 |
const cols = Array.from( row_el?.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );
|
| 505 |
const n = cols.length || 1;
|
| 506 |
const gp = Number.isFinite( +gap_percent ) ? +gap_percent : 3;
|
| 507 |
const total_gaps = Math.max( 0, n - 1 ) * gp;
|
| 508 |
const available = Math.max( 0, 100 - total_gaps );
|
| 509 |
const each = available / n;
|
| 510 |
this.apply_bases_to_row( row_el, Array( n ).fill( each ) );
|
| 511 |
}
|
| 512 |
|
| 513 |
/**
|
| 514 |
* Apply a preset of relative weights to a row/section.
|
| 515 |
*
|
| 516 |
* @param {HTMLElement} sectionOrRow - .wpbc_bfb__section or its child .wpbc_bfb__row.
|
| 517 |
* @param {number[]} weights - Relative weights (e.g., [1,3,1]).
|
| 518 |
* @param {number} [gap_percent=this.col_gap_percent] - Gap percent.
|
| 519 |
* @returns {void}
|
| 520 |
*/
|
| 521 |
apply_layout_preset( sectionOrRow, weights, gap_percent = this.col_gap_percent ) {
|
| 522 |
const row = sectionOrRow?.classList?.contains( 'wpbc_bfb__row' )
|
| 523 |
? sectionOrRow
|
| 524 |
: sectionOrRow?.querySelector( ':scope > .wpbc_bfb__row' );
|
| 525 |
|
| 526 |
if ( ! row ) {
|
| 527 |
return;
|
| 528 |
}
|
| 529 |
|
| 530 |
const cols = Array.from( row.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );
|
| 531 |
const n = cols.length || 1;
|
| 532 |
|
| 533 |
if ( ! Array.isArray( weights ) || weights.length !== n ) {
|
| 534 |
this.set_equal_bases( row, gap_percent );
|
| 535 |
return;
|
| 536 |
}
|
| 537 |
|
| 538 |
const sum = weights.reduce( ( a, b ) => a + Math.max( 0, Number( b ) || 0 ), 0 ) || 1;
|
| 539 |
const gp = Number.isFinite( +gap_percent ) ? +gap_percent : 3;
|
| 540 |
const available = Math.max( 0, 100 - Math.max( 0, n - 1 ) * gp );
|
| 541 |
const bases = weights.map( ( w ) => Math.max( 0, (Number( w ) || 0) / sum * available ) );
|
| 542 |
|
| 543 |
this.apply_bases_to_row( row, bases );
|
| 544 |
}
|
| 545 |
|
| 546 |
/**
|
| 547 |
* Build preset weight lists for a given column count.
|
| 548 |
*
|
| 549 |
* @param {number} n - Column count.
|
| 550 |
* @returns {number[][]} List of weight arrays.
|
| 551 |
*/
|
| 552 |
build_presets_for_columns( n ) {
|
| 553 |
switch ( n ) {
|
| 554 |
case 1:
|
| 555 |
return [ [ 1 ] ];
|
| 556 |
case 2:
|
| 557 |
return [ [ 1, 2 ], [ 2, 1 ], [ 1, 3 ], [ 3, 1 ] ];
|
| 558 |
case 3:
|
| 559 |
return [ [ 1, 3, 1 ], [ 1, 2, 1 ], [ 2, 1, 1 ], [ 1, 1, 2 ] ];
|
| 560 |
case 4:
|
| 561 |
return [ [ 1, 2, 2, 1 ], [ 2, 1, 1, 1 ], [ 1, 1, 1, 2 ] ];
|
| 562 |
default:
|
| 563 |
return [ Array( n ).fill( 1 ) ];
|
| 564 |
}
|
| 565 |
}
|
| 566 |
|
| 567 |
/**
|
| 568 |
* Format a human-readable label like "50%/25%/25%" from weights.
|
| 569 |
*
|
| 570 |
* @param {number[]} weights - Weight list.
|
| 571 |
* @returns {string} Label string.
|
| 572 |
*/
|
| 573 |
format_preset_label( weights ) {
|
| 574 |
const sum = weights.reduce( ( a, b ) => a + (Number( b ) || 0), 0 ) || 1;
|
| 575 |
return weights.map( ( w ) => Math.round( ((Number( w ) || 0) / sum) * 100 ) ).join( '%/' ) + '%';
|
| 576 |
}
|
| 577 |
|
| 578 |
/**
|
| 579 |
* Parse comma/space separated weights into numbers.
|
| 580 |
*
|
| 581 |
* @param {string} input - User input like "20,60,20".
|
| 582 |
* @returns {number[]} Parsed weights.
|
| 583 |
*/
|
| 584 |
parse_weights( input ) {
|
| 585 |
if ( ! input ) {
|
| 586 |
return [];
|
| 587 |
}
|
| 588 |
return String( input )
|
| 589 |
.replace( /[^\d,.\s]/g, '' )
|
| 590 |
.split( /[\s,]+/ )
|
| 591 |
.map( ( s ) => parseFloat( s ) )
|
| 592 |
.filter( ( n ) => Number.isFinite( n ) && n >= 0 );
|
| 593 |
}
|
| 594 |
};
|
| 595 |
|
| 596 |
/**
|
| 597 |
* WPBC Usage Limit service.
|
| 598 |
* Counts field usage by key, compares to palette limits, and updates palette UI.
|
| 599 |
*/
|
| 600 |
Core.WPBC_BFB_UsageLimitService = class {
|
| 601 |
|
| 602 |
/**
|
| 603 |
* Constructor. Set pages_container and palette_ul.
|
| 604 |
*
|
| 605 |
* @param {HTMLElement} pages_container - Canvas root that holds placed fields.
|
| 606 |
* @param {HTMLElement[]|null} palette_uls?: Palettes UL with .wpbc_bfb__field items (may be null).
|
| 607 |
*/
|
| 608 |
constructor(pages_container, palette_uls) {
|
| 609 |
this.pages_container = pages_container;
|
| 610 |
// Normalize to an array; we’ll still be robust if none provided.
|
| 611 |
this.palette_uls = Array.isArray( palette_uls ) ? palette_uls : (palette_uls ? [ palette_uls ] : []);
|
| 612 |
}
|
| 613 |
|
| 614 |
|
| 615 |
/**
|
| 616 |
* Parse usage limit from raw dataset value. Missing/invalid -> Infinity.
|
| 617 |
*
|
| 618 |
* @param {string|number|null|undefined} raw - Raw attribute value.
|
| 619 |
* @returns {number} Limit number or Infinity.
|
| 620 |
*/
|
| 621 |
static parse_usage_limit( raw ) {
|
| 622 |
if ( raw == null ) {
|
| 623 |
return Infinity;
|
| 624 |
}
|
| 625 |
const n = parseInt( raw, 10 );
|
| 626 |
return Number.isFinite( n ) ? n : Infinity;
|
| 627 |
}
|
| 628 |
|
| 629 |
/**
|
| 630 |
* Count how many instances exist per usage_key in the canvas.
|
| 631 |
*
|
| 632 |
* @returns {Record<string, number>} Map of usage_key -> count.
|
| 633 |
*/
|
| 634 |
count_usage_by_key() {
|
| 635 |
const used = {};
|
| 636 |
const all = this.pages_container?.querySelectorAll( '.wpbc_bfb__panel--preview .wpbc_bfb__field:not(.is-invalid)' ) || [];
|
| 637 |
all.forEach( ( el ) => {
|
| 638 |
const key = el.dataset.usage_key || el.dataset.type || el.dataset.id;
|
| 639 |
if ( ! key ) {
|
| 640 |
return;
|
| 641 |
}
|
| 642 |
used[key] = (used[key] || 0) + 1;
|
| 643 |
} );
|
| 644 |
return used;
|
| 645 |
}
|
| 646 |
|
| 647 |
/**
|
| 648 |
* Return palette limit for a given usage key (id of the palette item).
|
| 649 |
*
|
| 650 |
* @param {string} key - Usage key.
|
| 651 |
* @returns {number} Limit value or Infinity.
|
| 652 |
*/
|
| 653 |
get_limit_for_key(key) {
|
| 654 |
if ( ! key ) {
|
| 655 |
return Infinity;
|
| 656 |
}
|
| 657 |
// Query across all palettes present now (stored + any newly added in DOM).
|
| 658 |
const roots = this.palette_uls?.length ? this.palette_uls : document.querySelectorAll( '.wpbc_bfb__panel_field_types__ul' );
|
| 659 |
const allPaletteFields = Array.from( roots ).flatMap( r => Array.from( r.querySelectorAll( '.wpbc_bfb__field' ) ) );
|
| 660 |
let limit = Infinity;
|
| 661 |
|
| 662 |
allPaletteFields.forEach( (el) => {
|
| 663 |
const usage_key = el.dataset.usage_key || el.dataset.id;
|
| 664 |
if ( el.dataset.id === key || usage_key === key ) {
|
| 665 |
const n = Core.WPBC_BFB_UsageLimitService.parse_usage_limit( el.dataset.usagenumber );
|
| 666 |
// Choose the smallest finite limit (safest if palettes disagree).
|
| 667 |
if ( n < limit ) {
|
| 668 |
limit = n;
|
| 669 |
}
|
| 670 |
}
|
| 671 |
} );
|
| 672 |
|
| 673 |
return limit;
|
| 674 |
}
|
| 675 |
|
| 676 |
|
| 677 |
/**
|
| 678 |
* Disable/enable palette items based on current usage counts and limits.
|
| 679 |
*
|
| 680 |
* @returns {void}
|
| 681 |
*/
|
| 682 |
update_palette_ui() {
|
| 683 |
// Always compute usage from the canvas:
|
| 684 |
const usage = this.count_usage_by_key();
|
| 685 |
|
| 686 |
// Update all palettes currently in DOM (not just the initially captured ones)
|
| 687 |
const palettes = document.querySelectorAll( '.wpbc_bfb__panel_field_types__ul' );
|
| 688 |
|
| 689 |
palettes.forEach( (pal) => {
|
| 690 |
pal.querySelectorAll( '.wpbc_bfb__field' ).forEach( (panel_field) => {
|
| 691 |
const paletteId = panel_field.dataset.id;
|
| 692 |
const usageKey = panel_field.dataset.usage_key || paletteId;
|
| 693 |
const raw_limit = panel_field.dataset.usagenumber;
|
| 694 |
const perElLimit = Core.WPBC_BFB_UsageLimitService.parse_usage_limit( raw_limit );
|
| 695 |
// Effective limit across all palettes is the global limit for this key.
|
| 696 |
const globalLimit = this.get_limit_for_key( usageKey );
|
| 697 |
const limit = Number.isFinite( globalLimit ) ? globalLimit : perElLimit; // prefer global min
|
| 698 |
|
| 699 |
const current = usage[usageKey] || 0;
|
| 700 |
const disable = Number.isFinite( limit ) && current >= limit;
|
| 701 |
|
| 702 |
panel_field.style.pointerEvents = disable ? 'none' : '';
|
| 703 |
panel_field.style.opacity = disable ? '0.4' : '';
|
| 704 |
panel_field.setAttribute( 'aria-disabled', disable ? 'true' : 'false' );
|
| 705 |
if ( disable ) {
|
| 706 |
panel_field.setAttribute( 'tabindex', '-1' );
|
| 707 |
} else {
|
| 708 |
panel_field.removeAttribute( 'tabindex' );
|
| 709 |
}
|
| 710 |
} );
|
| 711 |
} );
|
| 712 |
}
|
| 713 |
|
| 714 |
|
| 715 |
/**
|
| 716 |
* Return how many valid instances with this usage key exist in the canvas.
|
| 717 |
*
|
| 718 |
* @param {string} key - Usage key of a palette item.
|
| 719 |
* @returns {number} Count of existing non-invalid instances.
|
| 720 |
*/
|
| 721 |
count_for_key( key ) {
|
| 722 |
if ( ! key ) {
|
| 723 |
return 0;
|
| 724 |
}
|
| 725 |
return ( this.pages_container?.querySelectorAll(
|
| 726 |
`.wpbc_bfb__panel--preview .wpbc_bfb__field[data-usage_key="${Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( key )}"]:not(.is-invalid),
|
| 727 |
.wpbc_bfb__panel--preview .wpbc_bfb__field[data-type="${Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( key )}"]:not(.is-invalid)`
|
| 728 |
) || [] ).length;
|
| 729 |
}
|
| 730 |
|
| 731 |
/**
|
| 732 |
* Alias for limit lookup (readability).
|
| 733 |
*
|
| 734 |
* @param {string} key - Usage key of a palette item.
|
| 735 |
* @returns {number} Limit value or Infinity.
|
| 736 |
*/
|
| 737 |
limit_for_key( key ) {
|
| 738 |
return this.get_limit_for_key( key );
|
| 739 |
}
|
| 740 |
|
| 741 |
/**
|
| 742 |
* Remaining slots for this key (Infinity if unlimited).
|
| 743 |
*
|
| 744 |
* @param {string} key - Usage key of a palette item.
|
| 745 |
* @returns {number} Remaining count (>= 0) or Infinity.
|
| 746 |
*/
|
| 747 |
remaining_for_key( key ) {
|
| 748 |
const limit = this.limit_for_key( key );
|
| 749 |
if ( limit === Infinity ) {
|
| 750 |
return Infinity;
|
| 751 |
}
|
| 752 |
const used = this.count_for_key( key );
|
| 753 |
return Math.max( 0, limit - used );
|
| 754 |
}
|
| 755 |
|
| 756 |
/**
|
| 757 |
* True if you can add `delta` more items for this key.
|
| 758 |
*
|
| 759 |
* @param {string} key - Usage key of a palette item.
|
| 760 |
* @param {number} [delta=1] - How many items you intend to add.
|
| 761 |
* @returns {boolean} Whether adding is allowed.
|
| 762 |
*/
|
| 763 |
can_add( key, delta = 1 ) {
|
| 764 |
const rem = this.remaining_for_key( key );
|
| 765 |
return ( rem === Infinity ) ? true : ( rem >= delta );
|
| 766 |
}
|
| 767 |
|
| 768 |
/**
|
| 769 |
* UI-facing gate: alert when exceeded. Returns boolean allowed/blocked.
|
| 770 |
*
|
| 771 |
* @param {string} key - Usage key of a palette item.
|
| 772 |
* @param {{label?: string, delta?: number}} [opts={}] - Optional UI info.
|
| 773 |
* @returns {boolean} True if allowed, false if blocked.
|
| 774 |
*/
|
| 775 |
gate_or_alert( key, { label = key, delta = 1 } = {} ) {
|
| 776 |
if ( this.can_add( key, delta ) ) {
|
| 777 |
return true;
|
| 778 |
}
|
| 779 |
const limit = this.limit_for_key( key );
|
| 780 |
alert( `Only ${limit} instance${limit > 1 ? 's' : ''} of "${label}" allowed.` );
|
| 781 |
return false;
|
| 782 |
}
|
| 783 |
|
| 784 |
/**
|
| 785 |
* Backward-compatible alias used elsewhere in the codebase. - Check whether another instance with the given
|
| 786 |
* usage key can be added.
|
| 787 |
*
|
| 788 |
* @param {string} key - Usage key of a palette item.
|
| 789 |
* @returns {boolean} Whether adding one more is allowed.
|
| 790 |
*/
|
| 791 |
is_usage_ok( key ) {
|
| 792 |
return this.can_add( key, 1 );
|
| 793 |
}
|
| 794 |
|
| 795 |
};
|
| 796 |
|
| 797 |
/**
|
| 798 |
* Constant event names for the builder.
|
| 799 |
*/
|
| 800 |
Core.WPBC_BFB_Events = Object.freeze({
|
| 801 |
SELECT : 'wpbc:bfb:select',
|
| 802 |
CLEAR_SELECTION : 'wpbc:bfb:clear-selection',
|
| 803 |
FIELD_ADD : 'wpbc:bfb:field:add',
|
| 804 |
FIELD_REMOVE : 'wpbc:bfb:field:remove',
|
| 805 |
STRUCTURE_CHANGE : 'wpbc:bfb:structure:change',
|
| 806 |
STRUCTURE_LOADED : 'wpbc:bfb:structure:loaded'
|
| 807 |
});
|
| 808 |
|
| 809 |
/**
|
| 810 |
* Lightweight event bus that emits to both the pages container and document.
|
| 811 |
*/
|
| 812 |
Core.WPBC_BFB_EventBus = class {
|
| 813 |
/**
|
| 814 |
* @param {HTMLElement} scope_el - Element to dispatch bubbled events from.
|
| 815 |
*/
|
| 816 |
constructor( scope_el ) {
|
| 817 |
this.scope_el = scope_el;
|
| 818 |
}
|
| 819 |
|
| 820 |
/**
|
| 821 |
* Emit a DOM CustomEvent with payload.
|
| 822 |
*
|
| 823 |
* @param {string} type - Event type (use Core.WPBC_BFB_Events. when possible).
|
| 824 |
* @param {Object} [detail={}] - Arbitrary serializable payload.
|
| 825 |
* @returns {void}
|
| 826 |
*/
|
| 827 |
emit( type, detail = {} ) {
|
| 828 |
if ( ! this.scope_el ) {
|
| 829 |
return;
|
| 830 |
}
|
| 831 |
this.scope_el.dispatchEvent( new CustomEvent( type, { detail: { ...detail }, bubbles: true } ) );
|
| 832 |
}
|
| 833 |
|
| 834 |
/**
|
| 835 |
* Subscribe to an event on document.
|
| 836 |
*
|
| 837 |
* @param {string} type - Event type.
|
| 838 |
* @param {(ev:CustomEvent)=>void} handler - Handler function.
|
| 839 |
* @returns {void}
|
| 840 |
*/
|
| 841 |
on( type, handler ) {
|
| 842 |
document.addEventListener( type, handler );
|
| 843 |
}
|
| 844 |
|
| 845 |
/**
|
| 846 |
* Unsubscribe from an event on document.
|
| 847 |
*
|
| 848 |
* @param {string} type - Event type.
|
| 849 |
* @param {(ev:CustomEvent)=>void} handler - Handler function.
|
| 850 |
* @returns {void}
|
| 851 |
*/
|
| 852 |
off( type, handler ) {
|
| 853 |
document.removeEventListener( type, handler );
|
| 854 |
}
|
| 855 |
};
|
| 856 |
|
| 857 |
/**
|
| 858 |
* SortableJS manager: single point for consistent DnD config.
|
| 859 |
*/
|
| 860 |
Core.WPBC_BFB_SortableManager = class {
|
| 861 |
|
| 862 |
/**
|
| 863 |
* @param {WPBC_Form_Builder} builder - The active builder instance.
|
| 864 |
* @param {{ groupName?: string, animation?: number, ghostClass?: string, chosenClass?: string, dragClass?: |
| 865 |
* string, candidate_dwell_ms?: number, candidate_commit_distance?: number, |
| 866 |
* candidate_dwell_distance?: number }} [opts={}] - Visual and drag-stability options. |
| 867 |
*/
|
| 868 |
constructor( builder, opts = {} ) {
|
| 869 |
this.builder = builder;
|
| 870 |
const gid = this.builder?.instance_id || Math.random().toString( 36 ).slice( 2, 8 );
|
| 871 |
this.opts = {
|
| 872 |
// groupName : 'form',
|
| 873 |
groupName: `form-${gid}`,
|
| 874 |
animation : 150,
|
| 875 |
ghostClass : 'wpbc_bfb__drag-ghost', |
| 876 |
chosenClass: 'wpbc_bfb__highlight', |
| 877 |
dragClass : 'wpbc_bfb__drag-active', |
| 878 |
candidate_dwell_ms : 90, |
| 879 |
candidate_commit_distance : 10, |
| 880 |
candidate_dwell_distance : 2, |
| 881 |
...opts |
| 882 |
}; |
| 883 |
/** @type {Set<HTMLElement>} */
|
| 884 |
this._containers = new Set();
|
| 885 |
|
| 886 |
/**
|
| 887 |
* Guard against lost mouseup / pointerup events.
|
| 888 |
*
|
| 889 |
* @type {boolean}
|
| 890 |
*/
|
| 891 |
this._drag_fail_safe_bound = false; |
| 892 |
|
| 893 |
/** |
| 894 |
* State for the current Form Builder canvas drag. |
| 895 |
* |
| 896 |
* @type {?Object} |
| 897 |
*/ |
| 898 |
this._drag_state = null; |
| 899 |
|
| 900 |
this._bind_drag_fail_safe();
|
| 901 |
}
|
| 902 |
|
| 903 |
/**
|
| 904 |
* Cleanup drag UI state.
|
| 905 |
*
|
| 906 |
* This is a defensive cleanup for cases when Chrome or a browser extension
|
| 907 |
* loses the final mouseup / pointerup event during fallback dragging.
|
| 908 |
*
|
| 909 |
* @returns {void}
|
| 910 |
*/
|
| 911 |
_cleanup_drag_ui() { |
| 912 |
const drag_state = this._drag_state; |
| 913 |
|
| 914 |
if ( drag_state?.item ) { |
| 915 |
drag_state.item.classList.remove( 'wpbc_bfb__drop-indicator' ); |
| 916 |
} |
| 917 |
if ( drag_state?.source_spacer?.parentNode ) { |
| 918 |
drag_state.source_spacer.parentNode.removeChild( drag_state.source_spacer ); |
| 919 |
} |
| 920 |
this._release_canvas_geometry_locks( drag_state ); |
| 921 |
|
| 922 |
this._drag_state = null; |
| 923 |
this._toggle_dnd_root_flags( false ); |
| 924 |
this.builder?._remove_dragging_class?.(); |
| 925 |
|
| 926 |
// Remove only fallback mirrors. Do not touch real dragged elements.
|
| 927 |
document.querySelectorAll( '.sortable-fallback[data-drag-role], .wpbc_bfb__simple_list_fallback' )
|
| 928 |
.forEach( (el) => {
|
| 929 |
if ( el.parentNode ) {
|
| 930 |
el.parentNode.removeChild( el );
|
| 931 |
}
|
| 932 |
} ); |
| 933 |
} |
| 934 |
|
| 935 |
/** |
| 936 |
* Capture the block size of every canvas layout container before drag reflow starts. |
| 937 |
* |
| 938 |
* SortableJS temporarily moves the real node between containers. That changes CSS |
| 939 |
* `:empty` matching and can otherwise shrink an empty destination row or grow a |
| 940 |
* populated destination by the insertion-line height. The captured values are |
| 941 |
* applied only for the active drag session and never become saved form data. |
| 942 |
* |
| 943 |
* @returns {Array<Object>} Restorable geometry-lock records for visible canvas containers. |
| 944 |
*/ |
| 945 |
_capture_canvas_geometry_locks() { |
| 946 |
const pages_container = this.builder?.pages_container; |
| 947 |
if ( ! pages_container?.querySelectorAll ) { |
| 948 |
return []; |
| 949 |
} |
| 950 |
|
| 951 |
const lock_selector = [ |
| 952 |
'.wpbc_bfb__form_preview_section_container', |
| 953 |
'.wpbc_bfb__row', |
| 954 |
'.wpbc_bfb__column' |
| 955 |
].join( ', ' ); |
| 956 |
const block_size_property = '--wpbc-bfb-drag-locked-block-size'; |
| 957 |
|
| 958 |
return Array.from( pages_container.querySelectorAll( lock_selector ) ) |
| 959 |
.map( ( element ) => { |
| 960 |
const block_size = element.getBoundingClientRect?.().height; |
| 961 |
if ( ! Number.isFinite( block_size ) || block_size <= 0 ) { |
| 962 |
return null; |
| 963 |
} |
| 964 |
|
| 965 |
return { |
| 966 |
element : element, |
| 967 |
block_size : Math.round( block_size * 1000 ) / 1000, |
| 968 |
had_lock_class : element.classList?.contains( 'wpbc_bfb__drag-geometry-lock' ), |
| 969 |
previous_block_size : element.style?.getPropertyValue?.( block_size_property ) || '', |
| 970 |
previous_block_size_priority: element.style?.getPropertyPriority?.( block_size_property ) || '' |
| 971 |
}; |
| 972 |
} ) |
| 973 |
.filter( Boolean ); |
| 974 |
} |
| 975 |
|
| 976 |
/** |
| 977 |
* Freeze captured canvas container heights for the active SortableJS session. |
| 978 |
* |
| 979 |
* The lock is applied before global drag classes or the compact insertion marker |
| 980 |
* can change flex alignment and empty-container selectors. |
| 981 |
* |
| 982 |
* @returns {void} |
| 983 |
*/ |
| 984 |
_apply_canvas_geometry_locks() { |
| 985 |
const geometry_locks = this._drag_state?.geometry_locks || []; |
| 986 |
|
| 987 |
geometry_locks.forEach( ( geometry_lock ) => { |
| 988 |
geometry_lock.element.style?.setProperty( |
| 989 |
'--wpbc-bfb-drag-locked-block-size', |
| 990 |
`${geometry_lock.block_size}px` |
| 991 |
); |
| 992 |
geometry_lock.element.classList?.add( 'wpbc_bfb__drag-geometry-lock' ); |
| 993 |
} ); |
| 994 |
} |
| 995 |
|
| 996 |
/** |
| 997 |
* Restore all inline state used by the drag-session geometry lock. |
| 998 |
* |
| 999 |
* @param {?Object} drag_state - Drag state whose geometry records must be restored. |
| 1000 |
* @returns {void} |
| 1001 |
*/ |
| 1002 |
_release_canvas_geometry_locks( drag_state ) { |
| 1003 |
const block_size_property = '--wpbc-bfb-drag-locked-block-size'; |
| 1004 |
const geometry_locks = drag_state?.geometry_locks || []; |
| 1005 |
|
| 1006 |
geometry_locks.forEach( ( geometry_lock ) => { |
| 1007 |
if ( geometry_lock.previous_block_size ) { |
| 1008 |
geometry_lock.element.style?.setProperty( |
| 1009 |
block_size_property, |
| 1010 |
geometry_lock.previous_block_size, |
| 1011 |
geometry_lock.previous_block_size_priority |
| 1012 |
); |
| 1013 |
} else { |
| 1014 |
geometry_lock.element.style?.removeProperty?.( block_size_property ); |
| 1015 |
} |
| 1016 |
|
| 1017 |
if ( ! geometry_lock.had_lock_class ) { |
| 1018 |
geometry_lock.element.classList?.remove( 'wpbc_bfb__drag-geometry-lock' ); |
| 1019 |
} |
| 1020 |
} ); |
| 1021 |
} |
| 1022 |
|
| 1023 |
/** |
| 1024 |
* Capture the original canvas geometry before SortableJS applies its ghost class. |
| 1025 |
* |
| 1026 |
* The saved rectangle is later represented by a non-data spacer. This keeps the |
| 1027 |
* source layout stable while the real dragged node becomes a compact insertion |
| 1028 |
* indicator in another container. |
| 1029 |
* |
| 1030 |
* @param {Sortable.SortableEvent} evt - Sortable choose event. |
| 1031 |
* @returns {void} |
| 1032 |
*/ |
| 1033 |
_prepare_drag_state( evt ) { |
| 1034 |
if ( ! evt?.item || ! evt?.from ) { |
| 1035 |
this._drag_state = null; |
| 1036 |
return; |
| 1037 |
} |
| 1038 |
|
| 1039 |
const source_rect = evt.item.getBoundingClientRect(); |
| 1040 |
const from_palette = !! this.builder?.palette_uls?.includes?.( evt.from ); |
| 1041 |
|
| 1042 |
this._drag_state = { |
| 1043 |
item : evt.item, |
| 1044 |
from_palette : from_palette, |
| 1045 |
source_parent : evt.from, |
| 1046 |
source_next_sibling : evt.item.nextSibling, |
| 1047 |
source_rect : { |
| 1048 |
width : source_rect.width, |
| 1049 |
height: source_rect.height |
| 1050 |
}, |
| 1051 |
geometry_locks : this._capture_canvas_geometry_locks(), |
| 1052 |
source_spacer : null, |
| 1053 |
accepted_candidate : null, |
| 1054 |
pending_candidate : null, |
| 1055 |
pending_since : 0, |
| 1056 |
pending_pointer : null |
| 1057 |
}; |
| 1058 |
} |
| 1059 |
|
| 1060 |
/** |
| 1061 |
* Create a measured, non-data footprint at the dragged item's source position. |
| 1062 |
* |
| 1063 |
* The spacer intentionally does not use field or section classes, so Form Builder |
| 1064 |
* serialization and usage accounting cannot treat it as saved form content. |
| 1065 |
* |
| 1066 |
* @returns {void} |
| 1067 |
*/ |
| 1068 |
_create_drag_source_spacer() { |
| 1069 |
const drag_state = this._drag_state; |
| 1070 |
|
| 1071 |
if ( |
| 1072 |
! drag_state || |
| 1073 |
drag_state.from_palette || |
| 1074 |
! drag_state.item || |
| 1075 |
! drag_state.source_parent || |
| 1076 |
drag_state.source_spacer |
| 1077 |
) { |
| 1078 |
return; |
| 1079 |
} |
| 1080 |
|
| 1081 |
const spacer = document.createElement( 'div' ); |
| 1082 |
const width = Math.max( 1, drag_state.source_rect?.width || 1 ); |
| 1083 |
const height = Math.max( 1, drag_state.source_rect?.height || 1 ); |
| 1084 |
|
| 1085 |
spacer.className = 'wpbc_bfb__drag-source-spacer'; |
| 1086 |
spacer.setAttribute( 'aria-hidden', 'true' ); |
| 1087 |
spacer.setAttribute( 'data-wpbc-bfb-drag-source-spacer', 'true' ); |
| 1088 |
spacer.style.setProperty( '--wpbc-bfb-drag-source-inline-size', `${width}px` ); |
| 1089 |
spacer.style.setProperty( '--wpbc-bfb-drag-source-block-size', `${height}px` ); |
| 1090 |
|
| 1091 |
const reference_node = drag_state.source_next_sibling?.parentNode === drag_state.source_parent |
| 1092 |
? drag_state.source_next_sibling |
| 1093 |
: null; |
| 1094 |
|
| 1095 |
drag_state.source_parent.insertBefore( spacer, reference_node ); |
| 1096 |
drag_state.source_spacer = spacer; |
| 1097 |
} |
| 1098 |
|
| 1099 |
/** |
| 1100 |
* Start the stable drag representation after SortableJS creates its off-flow mirror. |
| 1101 |
* |
| 1102 |
* @param {Sortable.SortableEvent} evt - Sortable start event. |
| 1103 |
* @returns {void} |
| 1104 |
*/ |
| 1105 |
_start_drag( evt ) { |
| 1106 |
if ( ! this._drag_state ) { |
| 1107 |
this._prepare_drag_state( evt ); |
| 1108 |
} |
| 1109 |
|
| 1110 |
this._apply_canvas_geometry_locks(); |
| 1111 |
this.builder?._add_dragging_class?.(); |
| 1112 |
|
| 1113 |
const from_palette = !! this._drag_state?.from_palette; |
| 1114 |
this._toggle_dnd_root_flags( true, from_palette ); |
| 1115 |
this._tag_drag_mirror( evt ); |
| 1116 |
|
| 1117 |
if ( ! from_palette && evt?.item ) { |
| 1118 |
this._create_drag_source_spacer(); |
| 1119 |
evt.item.classList.add( 'wpbc_bfb__drop-indicator' ); |
| 1120 |
} |
| 1121 |
} |
| 1122 |
|
| 1123 |
/** |
| 1124 |
* Finish a Form Builder drag and remove transient layout helpers. |
| 1125 |
* |
| 1126 |
* @returns {void} |
| 1127 |
*/ |
| 1128 |
_finish_drag() { |
| 1129 |
this._cleanup_drag_ui(); |
| 1130 |
} |
| 1131 |
|
| 1132 |
/** |
| 1133 |
* Check whether a SortableJS canvas candidate is stable enough to accept. |
| 1134 |
* |
| 1135 |
* The candidate includes the destination container, related sibling, and insertion |
| 1136 |
* side. A new candidate must receive real pointer movement before it can replace |
| 1137 |
* the accepted position, preventing layout movement alone from causing flip-flops. |
| 1138 |
* |
| 1139 |
* @param {Object} evt - Sortable move event. |
| 1140 |
* @param {MouseEvent|PointerEvent|TouchEvent} original_event - Original pointer event. |
| 1141 |
* @returns {boolean} Whether SortableJS may move the in-flow insertion indicator. |
| 1142 |
*/ |
| 1143 |
_allow_canvas_move( evt, original_event ) { |
| 1144 |
const { to, from } = evt || {}; |
| 1145 |
if ( ! to || ! from ) { |
| 1146 |
return true; |
| 1147 |
} |
| 1148 |
|
| 1149 |
if ( ! to.closest( '.wpbc_bfb__panel--preview' ) ) { |
| 1150 |
return true; |
| 1151 |
} |
| 1152 |
|
| 1153 |
const touch_event = original_event?.touches?.[0] || original_event?.changedTouches?.[0]; |
| 1154 |
const event_x = touch_event?.clientX ?? original_event?.clientX; |
| 1155 |
const event_y = touch_event?.clientY ?? original_event?.clientY; |
| 1156 |
const dragged_rect = evt.draggedRect || evt.dragged?.getBoundingClientRect?.(); |
| 1157 |
const pointer_x = Number.isFinite( event_x ) |
| 1158 |
? event_x |
| 1159 |
: (dragged_rect ? dragged_rect.left + (dragged_rect.width / 2) : 0); |
| 1160 |
const pointer_y = Number.isFinite( event_y ) |
| 1161 |
? event_y |
| 1162 |
: (dragged_rect ? dragged_rect.top + (dragged_rect.height / 2) : 0); |
| 1163 |
|
| 1164 |
// Cross-container column changes require a deliberate move inside the new column. |
| 1165 |
if ( to !== from && to.classList?.contains( 'wpbc_bfb__column' ) ) { |
| 1166 |
const container_rect = to.getBoundingClientRect(); |
| 1167 |
const padding_x = Core.WPBC_BFB_Sanitize.clamp( container_rect.width * 0.20, 12, 36 ); |
| 1168 |
const padding_y = Core.WPBC_BFB_Sanitize.clamp( container_rect.height * 0.10, 6, 16 ); |
| 1169 |
const visually_empty = ! to.querySelector( |
| 1170 |
':scope > .wpbc_bfb__field:not(.wpbc_bfb__drop-indicator), ' + |
| 1171 |
':scope > .wpbc_bfb__section:not(.wpbc_bfb__drop-indicator)' |
| 1172 |
) || container_rect.height < 64; |
| 1173 |
const inner_top = container_rect.top + (visually_empty ? 4 : padding_y); |
| 1174 |
const inner_bottom = container_rect.bottom - (visually_empty ? 4 : padding_y); |
| 1175 |
const inner_left = container_rect.left + padding_x; |
| 1176 |
const inner_right = container_rect.right - padding_x; |
| 1177 |
|
| 1178 |
if ( pointer_x <= inner_left || pointer_x >= inner_right || pointer_y <= inner_top || pointer_y >= inner_bottom ) { |
| 1179 |
return false; |
| 1180 |
} |
| 1181 |
} |
| 1182 |
|
| 1183 |
const drag_state = this._drag_state; |
| 1184 |
if ( ! drag_state ) { |
| 1185 |
return true; |
| 1186 |
} |
| 1187 |
|
| 1188 |
const candidate = { |
| 1189 |
to : to, |
| 1190 |
related : evt.related || null, |
| 1191 |
will_insert_after : !! evt.willInsertAfter |
| 1192 |
}; |
| 1193 |
const candidate_matches = ( first, second ) => !! first && !! second && |
| 1194 |
first.to === second.to && |
| 1195 |
first.related === second.related && |
| 1196 |
first.will_insert_after === second.will_insert_after; |
| 1197 |
|
| 1198 |
if ( candidate_matches( candidate, drag_state.accepted_candidate ) ) { |
| 1199 |
evt.dragged?.classList.add( 'wpbc_bfb__drop-indicator' ); |
| 1200 |
return true; |
| 1201 |
} |
| 1202 |
|
| 1203 |
const now = window.performance?.now?.() ?? Date.now(); |
| 1204 |
if ( ! candidate_matches( candidate, drag_state.pending_candidate ) ) { |
| 1205 |
drag_state.pending_candidate = candidate; |
| 1206 |
drag_state.pending_since = now; |
| 1207 |
drag_state.pending_pointer = { x: pointer_x, y: pointer_y }; |
| 1208 |
return false; |
| 1209 |
} |
| 1210 |
|
| 1211 |
const pointer_distance = Math.hypot( |
| 1212 |
pointer_x - drag_state.pending_pointer.x, |
| 1213 |
pointer_y - drag_state.pending_pointer.y |
| 1214 |
); |
| 1215 |
const candidate_age = now - drag_state.pending_since; |
| 1216 |
const crossed_commit_distance = pointer_distance >= this.opts.candidate_commit_distance; |
| 1217 |
const completed_dwell_move = candidate_age >= this.opts.candidate_dwell_ms && |
| 1218 |
pointer_distance >= this.opts.candidate_dwell_distance; |
| 1219 |
|
| 1220 |
if ( ! crossed_commit_distance && ! completed_dwell_move ) { |
| 1221 |
return false; |
| 1222 |
} |
| 1223 |
|
| 1224 |
drag_state.accepted_candidate = candidate; |
| 1225 |
drag_state.pending_candidate = null; |
| 1226 |
drag_state.pending_since = 0; |
| 1227 |
drag_state.pending_pointer = null; |
| 1228 |
evt.dragged?.classList.add( 'wpbc_bfb__drop-indicator' ); |
| 1229 |
|
| 1230 |
return true; |
| 1231 |
} |
| 1232 |
|
| 1233 |
/**
|
| 1234 |
* Bind global fail-safe listeners for drag cleanup.
|
| 1235 |
*
|
| 1236 |
* @returns {void}
|
| 1237 |
*/
|
| 1238 |
_bind_drag_fail_safe() {
|
| 1239 |
if ( this._drag_fail_safe_bound ) {
|
| 1240 |
return;
|
| 1241 |
}
|
| 1242 |
|
| 1243 |
this._drag_fail_safe_bound = true;
|
| 1244 |
|
| 1245 |
const finish_drag = () => {
|
| 1246 |
window.requestAnimationFrame( () => {
|
| 1247 |
this._cleanup_drag_ui();
|
| 1248 |
} );
|
| 1249 |
};
|
| 1250 |
|
| 1251 |
[ 'mouseup', 'pointerup', 'touchend', 'dragend' ].forEach( (evt_name) => {
|
| 1252 |
document.addEventListener( evt_name, finish_drag, true );
|
| 1253 |
} );
|
| 1254 |
|
| 1255 |
window.addEventListener( 'blur', finish_drag, true );
|
| 1256 |
|
| 1257 |
document.addEventListener(
|
| 1258 |
'visibilitychange',
|
| 1259 |
() => {
|
| 1260 |
if ( document.hidden ) {
|
| 1261 |
finish_drag();
|
| 1262 |
}
|
| 1263 |
},
|
| 1264 |
true
|
| 1265 |
);
|
| 1266 |
}
|
| 1267 |
|
| 1268 |
/**
|
| 1269 |
* Tag the drag mirror (element under cursor) with role: 'palette' | 'canvas'.
|
| 1270 |
* Works with Sortable's fallback mirror (.sortable-fallback / .sortable-drag) and with your dragClass
|
| 1271 |
* (.wpbc_bfb__drag-active).
|
| 1272 |
*/
|
| 1273 |
_tag_drag_mirror( evt ) {
|
| 1274 |
const fromPalette = this.builder?.palette_uls?.includes?.( evt.from );
|
| 1275 |
const role = fromPalette ? 'palette' : 'canvas';
|
| 1276 |
// Wait a tick so the mirror exists. - The window.requestAnimationFrame() method tells the browser you wish to perform an animation.
|
| 1277 |
requestAnimationFrame( () => {
|
| 1278 |
const mirror = document.querySelector( '.sortable-fallback, .sortable-drag, .' + this.opts.dragClass ); |
| 1279 |
if ( mirror ) { |
| 1280 |
mirror.setAttribute( 'data-drag-role', role ); |
| 1281 |
mirror.setAttribute( 'aria-hidden', 'true' ); |
| 1282 |
} |
| 1283 |
} );
|
| 1284 |
}
|
| 1285 |
|
| 1286 |
_toggle_dnd_root_flags( active, from_palette = false ) {
|
| 1287 |
|
| 1288 |
// set to root element of an HTML document, which is the <html>.
|
| 1289 |
const root = document.documentElement;
|
| 1290 |
if ( active ) {
|
| 1291 |
root.classList.add( 'wpbc_bfb__dnd-active' );
|
| 1292 |
if ( from_palette ) {
|
| 1293 |
root.classList.add( 'wpbc_bfb__drag-from-palette' );
|
| 1294 |
}
|
| 1295 |
} else {
|
| 1296 |
root.classList.remove( 'wpbc_bfb__dnd-active', 'wpbc_bfb__drag-from-palette' );
|
| 1297 |
}
|
| 1298 |
}
|
| 1299 |
|
| 1300 |
|
| 1301 |
/**
|
| 1302 |
* Ensure a simple vertical sortable list.
|
| 1303 |
*
|
| 1304 |
* This configuration is intended for inspector/sidebar lists such as:
|
| 1305 |
* - dropdown choices
|
| 1306 |
* - radio options
|
| 1307 |
* - checkbox options
|
| 1308 |
*
|
| 1309 |
* It is intentionally much simpler than the canvas DnD config and does not
|
| 1310 |
* use the column edge-fence / sticky-target logic.
|
| 1311 |
*
|
| 1312 |
* @param {HTMLElement} container - Sortable list container.
|
| 1313 |
* @param {{ handle_selector?: string, draggable_selector?: string, onUpdate?: Function }} [handlers={}] -
|
| 1314 |
* Optional handlers/selectors.
|
| 1315 |
* @returns {void}
|
| 1316 |
*/
|
| 1317 |
ensure_simple_list( container, handlers = {} ) {
|
| 1318 |
if ( ! container || typeof Sortable === 'undefined' ) {
|
| 1319 |
return;
|
| 1320 |
}
|
| 1321 |
if ( Sortable.get?.( container ) ) {
|
| 1322 |
return;
|
| 1323 |
}
|
| 1324 |
|
| 1325 |
const common = {
|
| 1326 |
animation : this.opts.animation,
|
| 1327 |
ghostClass : this.opts.ghostClass,
|
| 1328 |
chosenClass : this.opts.chosenClass,
|
| 1329 |
dragClass : this.opts.dragClass,
|
| 1330 |
forceFallback : true,
|
| 1331 |
// For a single scrollable sidebar list this is usually more stable.
|
| 1332 |
fallbackOnBody : false,
|
| 1333 |
fallbackTolerance: 8,
|
| 1334 |
removeCloneOnHide: true,
|
| 1335 |
onStart : () => {
|
| 1336 |
this.builder?._add_dragging_class?.();
|
| 1337 |
this._toggle_dnd_root_flags( true, false );
|
| 1338 |
},
|
| 1339 |
onEnd : () => {
|
| 1340 |
setTimeout( () => {
|
| 1341 |
this.builder?._remove_dragging_class?.();
|
| 1342 |
}, 50 );
|
| 1343 |
this._toggle_dnd_root_flags( false );
|
| 1344 |
this._cleanup_drag_ui(); |
| 1345 |
}
|
| 1346 |
};
|
| 1347 |
|
| 1348 |
Sortable.create(
|
| 1349 |
container,
|
| 1350 |
{
|
| 1351 |
...common,
|
| 1352 |
group : { name: this.opts.groupName, pull: false, put: false },
|
| 1353 |
sort : true,
|
| 1354 |
direction : 'vertical',
|
| 1355 |
handle : handlers.handle_selector || '.wpbc_bfb__drag-handle',
|
| 1356 |
draggable : handlers.draggable_selector || '.wpbc_bfb__sortable-row',
|
| 1357 |
fallbackClass : 'wpbc_bfb__simple_list_fallback',
|
| 1358 |
filter : [
|
| 1359 |
'input',
|
| 1360 |
'textarea',
|
| 1361 |
'select',
|
| 1362 |
'button',
|
| 1363 |
'a',
|
| 1364 |
'.wpbc_bfb__no-drag-zone',
|
| 1365 |
'.wpbc_bfb__no-drag-zone *'
|
| 1366 |
].join( ',' ),
|
| 1367 |
preventOnFilter : false,
|
| 1368 |
invertSwap : false,
|
| 1369 |
swapThreshold : 0.30,
|
| 1370 |
invertedSwapThreshold : 0.60,
|
| 1371 |
emptyInsertThreshold : 8,
|
| 1372 |
dragoverBubble : false,
|
| 1373 |
scroll : true,
|
| 1374 |
scrollSensitivity : 60,
|
| 1375 |
scrollSpeed : 14,
|
| 1376 |
onUpdate : handlers.onUpdate || function () {}
|
| 1377 |
}
|
| 1378 |
);
|
| 1379 |
|
| 1380 |
this._containers.add( container );
|
| 1381 |
}
|
| 1382 |
|
| 1383 |
|
| 1384 |
/**
|
| 1385 |
* Ensure Sortable is attached to a container with role 'palette' or 'canvas'.
|
| 1386 |
*
|
| 1387 |
* -- Handle selectors: handle: '.section-drag-handle, .wpbc_bfb__drag-handle, .wpbc_bfb__drag-anywhere,
|
| 1388 |
* [data-draggable="true"]'
|
| 1389 |
* -- Draggable gate: draggable fields, sections, and the transient measured source spacer. |
| 1390 |
* -- Filter (overlay-safe): ignore everything in overlay except the handle -
|
| 1391 |
* '.wpbc_bfb__overlay-controls
|
| 1392 |
* *:not(.wpbc_bfb__drag-handle):not(.section-drag-handle):not(.wpbc_icn_drag_indicator)'
|
| 1393 |
* -- No-drag wrapper: use .wpbc_bfb__no-drag-zone inside renderers for inputs/widgets.
|
| 1394 |
* -- Focus guard (optional): flip [data-draggable] on focusin/focusout to prevent accidental drags while
|
| 1395 |
* typing.
|
| 1396 |
*
|
| 1397 |
* @param {HTMLElement} container - The element to enhance with Sortable.
|
| 1398 |
* @param {'palette'|'canvas'} role - Behavior profile to apply.
|
| 1399 |
* @param {{ onAdd?: Function }} [handlers={}] - Optional handlers.
|
| 1400 |
* @returns {void}
|
| 1401 |
*/
|
| 1402 |
ensure( container, role, handlers = {} ) {
|
| 1403 |
if ( ! container || typeof Sortable === 'undefined' ) {
|
| 1404 |
return;
|
| 1405 |
}
|
| 1406 |
if ( Sortable.get?.( container ) ) {
|
| 1407 |
return;
|
| 1408 |
}
|
| 1409 |
|
| 1410 |
const sortable_kind = handlers.sortable_kind || '';
|
| 1411 |
|
| 1412 |
if ( sortable_kind === 'simple_list' ) {
|
| 1413 |
this.ensure_simple_list( container, handlers );
|
| 1414 |
return;
|
| 1415 |
}
|
| 1416 |
|
| 1417 |
const common = {
|
| 1418 |
animation : this.opts.animation,
|
| 1419 |
ghostClass : this.opts.ghostClass,
|
| 1420 |
chosenClass: this.opts.chosenClass,
|
| 1421 |
dragClass : this.opts.dragClass,
|
| 1422 |
// == Element under the cursor == Ensure we drag a real DOM mirror you can style via CSS (cross-browser).
|
| 1423 |
forceFallback : true,
|
| 1424 |
fallbackOnBody : true,
|
| 1425 |
fallbackTolerance: 8,
|
| 1426 |
removeCloneOnHide: true, |
| 1427 |
onChoose: (evt) => this._prepare_drag_state( evt ), |
| 1428 |
onStart : (evt) => this._start_drag( evt ), |
| 1429 |
onEnd : () => this._finish_drag(), |
| 1430 |
onMove : (evt, original_event) => this._allow_canvas_move( evt, original_event ) |
| 1431 |
};
|
| 1432 |
|
| 1433 |
if ( role === 'palette' ) {
|
| 1434 |
Sortable.create( container, {
|
| 1435 |
...common,
|
| 1436 |
group : { name: this.opts.groupName, pull: 'clone', put: false },
|
| 1437 |
sort : false
|
| 1438 |
} );
|
| 1439 |
this._containers.add( container );
|
| 1440 |
return;
|
| 1441 |
}
|
| 1442 |
|
| 1443 |
// role === 'canvas'.
|
| 1444 |
Sortable.create( container, { |
| 1445 |
...common, |
| 1446 |
// Stable insertion geometry is preferable to animating hit-test targets. |
| 1447 |
animation: 0, |
| 1448 |
group : { |
| 1449 |
name: this.opts.groupName,
|
| 1450 |
pull: true,
|
| 1451 |
put : (to, from, draggedEl) => {
|
| 1452 |
return draggedEl.classList.contains( 'wpbc_bfb__field' ) ||
|
| 1453 |
draggedEl.classList.contains( 'wpbc_bfb__section' );
|
| 1454 |
}
|
| 1455 |
},
|
| 1456 |
// ---------- DnD Handlers -------------- // Grab anywhere on fields that opt-in with the class or attribute. - Sections still require their dedicated handle.
|
| 1457 |
handle : '.section-drag-handle, .wpbc_bfb__drag-handle, .wpbc_bfb__drag-anywhere, [data-draggable="true"]',
|
| 1458 |
// The transient spacer participates in hit testing but never serialization. |
| 1459 |
draggable: [ |
| 1460 |
'.wpbc_bfb__field:not([data-draggable="false"])', |
| 1461 |
'.wpbc_bfb__section', |
| 1462 |
'.wpbc_bfb__drag-source-spacer' |
| 1463 |
].join( ', ' ), |
| 1464 |
// ---------- Filters - No DnD ---------- // Declarative “no-drag zones”: anything inside these wrappers won’t start a drag.
|
| 1465 |
filter: [
|
| 1466 |
'.wpbc_bfb__no-drag-zone',
|
| 1467 |
'.wpbc_bfb__no-drag-zone *',
|
| 1468 |
'.wpbc_bfb__column-resizer', // Ignore the resizer rails during DnD (prevents edge “snap”).
|
| 1469 |
// In the overlay toolbar, block everything EXCEPT the drag handle (and its icon).
|
| 1470 |
'.wpbc_bfb__overlay-controls *:not(.wpbc_bfb__drag-handle):not(.section-drag-handle):not(.wpbc_icn_drag_indicator)'
|
| 1471 |
].join( ',' ),
|
| 1472 |
preventOnFilter : false,
|
| 1473 |
// ---------- anti-jitter tuning ----------
|
| 1474 |
direction : 'vertical', // columns are vertical lists.
|
| 1475 |
invertSwap : true, // use swap on inverted overlap.
|
| 1476 |
swapThreshold : 0.65, // be less eager to swap.
|
| 1477 |
invertedSwapThreshold: 0.85, // require deeper overlap when inverted.
|
| 1478 |
emptyInsertThreshold : 24, // don’t jump into empty containers too early.
|
| 1479 |
dragoverBubble : false, // keep dragover local.
|
| 1480 |
scroll : true,
|
| 1481 |
scrollSensitivity : 40,
|
| 1482 |
scrollSpeed : 10, |
| 1483 |
// ----------------------------------------
|
| 1484 |
// onAdd: handlers.onAdd || this.builder.handle_on_add.bind( this.builder )
|
| 1485 |
onAdd: (evt) => {
|
| 1486 |
if ( this._on_add_section( evt ) ) {
|
| 1487 |
return;
|
| 1488 |
}
|
| 1489 |
// Fallback: original handler for normal fields.
|
| 1490 |
(handlers.onAdd || this.builder.handle_on_add.bind( this.builder ))( evt );
|
| 1491 |
},
|
| 1492 |
onUpdate: () => {
|
| 1493 |
this.builder.bus?.emit?.( Core.WPBC_BFB_Events.STRUCTURE_CHANGE, { reason: 'sort-update' } );
|
| 1494 |
}
|
| 1495 |
} );
|
| 1496 |
|
| 1497 |
this._containers.add( container );
|
| 1498 |
}
|
| 1499 |
|
| 1500 |
/**
|
| 1501 |
* Handle adding/moving sections via Sortable onAdd.
|
| 1502 |
* Returns true if handled (i.e., it was a section), false to let the default field handler run.
|
| 1503 |
*
|
| 1504 |
* - Palette -> canvas: remove the placeholder clone and build a fresh section via add_section()
|
| 1505 |
* - Canvas -> canvas: keep the moved DOM (and its children), just re-wire overlays/sortables/metadata
|
| 1506 |
*
|
| 1507 |
* @param {Sortable.SortableEvent} evt
|
| 1508 |
* @returns {boolean}
|
| 1509 |
*/
|
| 1510 |
_on_add_section(evt) {
|
| 1511 |
|
| 1512 |
const item = evt.item;
|
| 1513 |
if ( ! item ) {
|
| 1514 |
return false;
|
| 1515 |
}
|
| 1516 |
|
| 1517 |
// Identify sections both from palette items (li clones) and real canvas nodes.
|
| 1518 |
const data = Core.WPBC_Form_Builder_Helper.get_all_data_attributes( item );
|
| 1519 |
const isSection = item.classList.contains( 'wpbc_bfb__section' ) || (data?.type || item.dataset?.type) === 'section';
|
| 1520 |
|
| 1521 |
if ( ! isSection ) {
|
| 1522 |
return false;
|
| 1523 |
}
|
| 1524 |
|
| 1525 |
const fromPalette = this.builder?.palette_uls?.includes?.( evt.from ) === true;
|
| 1526 |
|
| 1527 |
if ( ! fromPalette ) {
|
| 1528 |
// Canvas -> canvas move: DO NOT rebuild/remove; preserve children.
|
| 1529 |
this.builder.add_overlay_toolbar?.( item ); // ensure overlay exists
|
| 1530 |
this.builder.pages_sections?.init_all_nested_sortables?.( item ); // ensure inner sortables
|
| 1531 |
|
| 1532 |
// Ensure metadata present/updated
|
| 1533 |
item.dataset.type = 'section';
|
| 1534 |
const cols = item.querySelectorAll( ':scope > .wpbc_bfb__row > .wpbc_bfb__column' ).length || 1;
|
| 1535 |
item.dataset.columns = String( cols );
|
| 1536 |
|
| 1537 |
// Select & notify subscribers (layout/min guards, etc.)
|
| 1538 |
this.builder.select_field?.( item );
|
| 1539 |
this.builder.bus?.emit?.( Core.WPBC_BFB_Events.STRUCTURE_CHANGE, { el: item, reason: 'section-move' } );
|
| 1540 |
this.builder.usage?.update_palette_ui?.();
|
| 1541 |
return true; // handled.
|
| 1542 |
}
|
| 1543 |
|
| 1544 |
// Palette -> canvas: build a brand-new section using the same path as the dropdown/menu
|
| 1545 |
const to = evt.to?.closest?.( '.wpbc_bfb__column, .wpbc_bfb__form_preview_section_container' ) || evt.to;
|
| 1546 |
const cols = parseInt( data?.columns || item.dataset.columns || 1, 10 ) || 1;
|
| 1547 |
|
| 1548 |
// Remove the palette clone placeholder.
|
| 1549 |
item.parentNode && item.parentNode.removeChild( item );
|
| 1550 |
|
| 1551 |
// Create the real section.
|
| 1552 |
this.builder.pages_sections.add_section( to, cols );
|
| 1553 |
|
| 1554 |
// Insert at the precise drop index.
|
| 1555 |
const section = to.lastElementChild; // add_section appends to end.
|
| 1556 |
if ( evt.newIndex != null && evt.newIndex < to.children.length - 1 ) {
|
| 1557 |
const ref = to.children[evt.newIndex] || null;
|
| 1558 |
to.insertBefore( section, ref );
|
| 1559 |
}
|
| 1560 |
|
| 1561 |
// Finalize: overlay, selection, events, usage refresh.
|
| 1562 |
this.builder.add_overlay_toolbar?.( section );
|
| 1563 |
this.builder.select_field?.( section );
|
| 1564 |
this.builder.bus?.emit?.( Core.WPBC_BFB_Events.FIELD_ADD, {
|
| 1565 |
el : section,
|
| 1566 |
id : section.dataset.id,
|
| 1567 |
uid: section.dataset.uid
|
| 1568 |
} );
|
| 1569 |
this.builder.usage?.update_palette_ui?.();
|
| 1570 |
|
| 1571 |
return true;
|
| 1572 |
}
|
| 1573 |
|
| 1574 |
/**
|
| 1575 |
* Destroy all Sortable instances created by this manager.
|
| 1576 |
*
|
| 1577 |
* @returns {void}
|
| 1578 |
*/
|
| 1579 |
destroyAll() {
|
| 1580 |
this._containers.forEach( ( el ) => {
|
| 1581 |
const inst = Sortable.get?.( el );
|
| 1582 |
if ( inst ) {
|
| 1583 |
inst.destroy();
|
| 1584 |
}
|
| 1585 |
} );
|
| 1586 |
this._containers.clear();
|
| 1587 |
}
|
| 1588 |
};
|
| 1589 |
|
| 1590 |
/**
|
| 1591 |
* Small DOM contract and renderer helper
|
| 1592 |
*
|
| 1593 |
* @type {Readonly<{
|
| 1594 |
* SELECTORS: {pagePanel: string, field: string, validField: string, section: string, column:
|
| 1595 |
* string, row: string, overlay: string}, CLASSES: {selected: string}, ATTR: {id: string, name: string, htmlId:
|
| 1596 |
* string, usageKey: string, uid: string}}
|
| 1597 |
* >}
|
| 1598 |
*/
|
| 1599 |
Core.WPBC_BFB_DOM = Object.freeze( {
|
| 1600 |
SELECTORS: {
|
| 1601 |
pagePanel : '.wpbc_bfb__panel--preview',
|
| 1602 |
field : '.wpbc_bfb__field',
|
| 1603 |
validField: '.wpbc_bfb__field:not(.is-invalid)',
|
| 1604 |
section : '.wpbc_bfb__section',
|
| 1605 |
column : '.wpbc_bfb__column',
|
| 1606 |
row : '.wpbc_bfb__row',
|
| 1607 |
overlay : '.wpbc_bfb__overlay-controls'
|
| 1608 |
},
|
| 1609 |
CLASSES : {
|
| 1610 |
selected: 'is-selected'
|
| 1611 |
},
|
| 1612 |
ATTR : {
|
| 1613 |
id : 'data-id',
|
| 1614 |
name : 'data-name',
|
| 1615 |
htmlId : 'data-html_id',
|
| 1616 |
usageKey: 'data-usage_key',
|
| 1617 |
uid : 'data-uid'
|
| 1618 |
}
|
| 1619 |
} );
|
| 1620 |
|
| 1621 |
Core.WPBC_Form_Builder_Helper = class {
|
| 1622 |
|
| 1623 |
/**
|
| 1624 |
* Create an HTML element.
|
| 1625 |
*
|
| 1626 |
* @param {string} tag - HTML tag name.
|
| 1627 |
* @param {string} [class_name=''] - Optional CSS class name.
|
| 1628 |
* @param {string} [inner_html=''] - Optional innerHTML.
|
| 1629 |
* @returns {HTMLElement} Created element.
|
| 1630 |
*/
|
| 1631 |
static create_element( tag, class_name = '', inner_html = '' ) {
|
| 1632 |
const el = document.createElement( tag );
|
| 1633 |
if ( class_name ) {
|
| 1634 |
el.className = class_name;
|
| 1635 |
}
|
| 1636 |
if ( inner_html ) {
|
| 1637 |
el.innerHTML = inner_html;
|
| 1638 |
}
|
| 1639 |
return el;
|
| 1640 |
}
|
| 1641 |
|
| 1642 |
/**
|
| 1643 |
* Set multiple `data-*` attributes on a given element.
|
| 1644 |
*
|
| 1645 |
* @param {HTMLElement} el - Target element.
|
| 1646 |
* @param {Object} data_obj - Key-value pairs for data attributes.
|
| 1647 |
* @returns {void}
|
| 1648 |
*/
|
| 1649 |
static set_data_attributes( el, data_obj ) {
|
| 1650 |
Object.entries( data_obj ).forEach( ( [ key, val ] ) => {
|
| 1651 |
// Previously: 2025-09-01 17:09:
|
| 1652 |
// const value = (typeof val === 'object') ? JSON.stringify( val ) : val;
|
| 1653 |
//New:
|
| 1654 |
let value;
|
| 1655 |
if ( typeof val === 'object' && val !== null ) {
|
| 1656 |
try {
|
| 1657 |
value = JSON.stringify( val );
|
| 1658 |
} catch {
|
| 1659 |
value = '';
|
| 1660 |
}
|
| 1661 |
} else {
|
| 1662 |
value = val;
|
| 1663 |
}
|
| 1664 |
|
| 1665 |
el.setAttribute( 'data-' + key, value );
|
| 1666 |
} );
|
| 1667 |
}
|
| 1668 |
|
| 1669 |
/**
|
| 1670 |
* Get all `data-*` attributes from an element and parse JSON where possible.
|
| 1671 |
*
|
| 1672 |
* @param {HTMLElement} el - Element to extract data from.
|
| 1673 |
* @returns {Object} Parsed key-value map of data attributes.
|
| 1674 |
*/
|
| 1675 |
static get_all_data_attributes( el ) {
|
| 1676 |
const data = {};
|
| 1677 |
|
| 1678 |
if ( ! el || ! el.attributes ) {
|
| 1679 |
return data;
|
| 1680 |
}
|
| 1681 |
|
| 1682 |
Array.from( el.attributes ).forEach(
|
| 1683 |
( attr ) => {
|
| 1684 |
if ( attr.name.startsWith( 'data-' ) ) {
|
| 1685 |
const key = attr.name.replace( /^data-/, '' );
|
| 1686 |
try {
|
| 1687 |
data[key] = JSON.parse( attr.value );
|
| 1688 |
} catch ( e ) {
|
| 1689 |
data[key] = attr.value;
|
| 1690 |
}
|
| 1691 |
}
|
| 1692 |
}
|
| 1693 |
);
|
| 1694 |
|
| 1695 |
// Only default the label if it's truly absent (undefined/null), not when it's an empty string.
|
| 1696 |
const hasExplicitLabel = Object.prototype.hasOwnProperty.call( data, 'label' );
|
| 1697 |
if ( ! hasExplicitLabel && data.id ) {
|
| 1698 |
data.label = data.id.charAt( 0 ).toUpperCase() + data.id.slice( 1 );
|
| 1699 |
}
|
| 1700 |
|
| 1701 |
return data;
|
| 1702 |
}
|
| 1703 |
|
| 1704 |
/**
|
| 1705 |
* Render a simple label + type preview (used for unknown or fallback fields).
|
| 1706 |
*
|
| 1707 |
* @param {Object} field_data - Field data object.
|
| 1708 |
* @returns {string} HTML content.
|
| 1709 |
*/
|
| 1710 |
static render_field_inner_html( field_data ) {
|
| 1711 |
// Make the fallback preview respect an empty label.
|
| 1712 |
const hasLabel = Object.prototype.hasOwnProperty.call( field_data, 'label' );
|
| 1713 |
const label = hasLabel ? String( field_data.label ) : String( field_data.id || '(no label)' );
|
| 1714 |
|
| 1715 |
const type = String( field_data.type || 'unknown' );
|
| 1716 |
const is_required = field_data.required === true || field_data.required === 'true' || field_data.required === 1 || field_data.required === '1';
|
| 1717 |
|
| 1718 |
const wrapper = document.createElement( 'div' );
|
| 1719 |
|
| 1720 |
const spanLabel = document.createElement( 'span' );
|
| 1721 |
spanLabel.className = 'wpbc_bfb__field-label';
|
| 1722 |
spanLabel.textContent = label + (is_required ? ' *' : '');
|
| 1723 |
wrapper.appendChild( spanLabel );
|
| 1724 |
|
| 1725 |
const spanType = document.createElement( 'span' );
|
| 1726 |
spanType.className = 'wpbc_bfb__field-type';
|
| 1727 |
spanType.textContent = type;
|
| 1728 |
wrapper.appendChild( spanType );
|
| 1729 |
|
| 1730 |
return wrapper.innerHTML;
|
| 1731 |
}
|
| 1732 |
|
| 1733 |
/**
|
| 1734 |
* Debounce a function.
|
| 1735 |
*
|
| 1736 |
* @param {Function} fn - Function to debounce.
|
| 1737 |
* @param {number} wait - Delay in ms.
|
| 1738 |
* @returns {Function} Debounced function.
|
| 1739 |
*/
|
| 1740 |
static debounce( fn, wait = 120 ) {
|
| 1741 |
let t = null;
|
| 1742 |
return function debounced( ...args ) {
|
| 1743 |
if ( t ) {
|
| 1744 |
clearTimeout( t );
|
| 1745 |
}
|
| 1746 |
t = setTimeout( () => fn.apply( this, args ), wait );
|
| 1747 |
};
|
| 1748 |
}
|
| 1749 |
|
| 1750 |
};
|
| 1751 |
|
| 1752 |
// Renderer registry. Allows late registration and avoids tight coupling to a global map.
|
| 1753 |
Core.WPBC_BFB_Field_Renderer_Registry = (function () {
|
| 1754 |
const map = new Map();
|
| 1755 |
return {
|
| 1756 |
register( type, ClassRef ) {
|
| 1757 |
map.set( String( type ), ClassRef );
|
| 1758 |
},
|
| 1759 |
get( type ) {
|
| 1760 |
return map.get( String( type ) );
|
| 1761 |
}
|
| 1762 |
};
|
| 1763 |
})();
|
| 1764 |
|
| 1765 |
}( window ));
|
| 1766 |
|
| 1767 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 1768 |
// == File /includes/page-form-builder/_out/core/bfb-fields.js == | 2025-09-10 15:47
|
| 1769 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 1770 |
(function ( w ) {
|
| 1771 |
'use strict';
|
| 1772 |
|
| 1773 |
// Single global namespace (idempotent & load-order safe).
|
| 1774 |
const Core = ( w.WPBC_BFB_Core = w.WPBC_BFB_Core || {} );
|
| 1775 |
const UI = ( Core.UI = Core.UI || {} );
|
| 1776 |
|
| 1777 |
/**
|
| 1778 |
* Base class for field renderers (static-only contract).
|
| 1779 |
* ================================================================================================================
|
| 1780 |
* Contract exposed to the builder (static methods on the CLASS itself):
|
| 1781 |
* - render(el, data, ctx) // REQUIRED
|
| 1782 |
* - on_field_drop(data, el, meta) // OPTIONAL (default provided)
|
| 1783 |
*
|
| 1784 |
* Helpers for subclasses:
|
| 1785 |
* - get_defaults() -> per-field defaults (MUST override in subclass to set type/label)
|
| 1786 |
* - normalize_data(d) -> shallow merge with defaults
|
| 1787 |
* - get_template(id) -> per-id cached wp.template compiler
|
| 1788 |
*
|
| 1789 |
* Subclass usage:
|
| 1790 |
* class WPBC_BFB_Field_Text extends Core.WPBC_BFB_Field_Base { static get_defaults(){ ... } }
|
| 1791 |
* WPBC_BFB_Field_Text.template_id = 'wpbc-bfb-field-text';
|
| 1792 |
* ================================================================================================================
|
| 1793 |
*/
|
| 1794 |
Core.WPBC_BFB_Field_Base = class {
|
| 1795 |
|
| 1796 |
/**
|
| 1797 |
* Default field data (generic baseline).
|
| 1798 |
* Subclasses MUST override to provide { type, label } appropriate for the field.
|
| 1799 |
* @returns {Object}
|
| 1800 |
*/
|
| 1801 |
static get_defaults() {
|
| 1802 |
return {
|
| 1803 |
type : 'field',
|
| 1804 |
label : 'Field',
|
| 1805 |
name : 'field',
|
| 1806 |
html_id : '',
|
| 1807 |
placeholder : '',
|
| 1808 |
required : false,
|
| 1809 |
minlength : '',
|
| 1810 |
maxlength : '',
|
| 1811 |
pattern : '',
|
| 1812 |
cssclass : '',
|
| 1813 |
help : ''
|
| 1814 |
};
|
| 1815 |
}
|
| 1816 |
|
| 1817 |
/**
|
| 1818 |
* Shallow-merge incoming data with defaults.
|
| 1819 |
* @param {Object} data
|
| 1820 |
* @returns {Object}
|
| 1821 |
*/
|
| 1822 |
static normalize_data( data ) {
|
| 1823 |
var d = data || {};
|
| 1824 |
var defaults = this.get_defaults();
|
| 1825 |
var out = {};
|
| 1826 |
var k;
|
| 1827 |
|
| 1828 |
for ( k in defaults ) {
|
| 1829 |
if ( Object.prototype.hasOwnProperty.call( defaults, k ) ) {
|
| 1830 |
out[k] = defaults[k];
|
| 1831 |
}
|
| 1832 |
}
|
| 1833 |
for ( k in d ) {
|
| 1834 |
if ( Object.prototype.hasOwnProperty.call( d, k ) ) {
|
| 1835 |
out[k] = d[k];
|
| 1836 |
}
|
| 1837 |
}
|
| 1838 |
return out;
|
| 1839 |
}
|
| 1840 |
|
| 1841 |
/**
|
| 1842 |
* Compile and cache a wp.template by id (per-id cache).
|
| 1843 |
* @param {string} template_id
|
| 1844 |
* @returns {Function|null}
|
| 1845 |
*/
|
| 1846 |
static get_template(template_id) {
|
| 1847 |
|
| 1848 |
// Accept either "wpbc-bfb-field-text" or "tmpl-wpbc-bfb-field-text".
|
| 1849 |
if ( ! template_id || ! window.wp || ! wp.template ) {
|
| 1850 |
return null;
|
| 1851 |
}
|
| 1852 |
const domId = template_id.startsWith( 'tmpl-' ) ? template_id : ('tmpl-' + template_id);
|
| 1853 |
if ( ! document.getElementById( domId ) ) {
|
| 1854 |
return null;
|
| 1855 |
}
|
| 1856 |
|
| 1857 |
if ( ! Core.__bfb_tpl_cache_map ) {
|
| 1858 |
Core.__bfb_tpl_cache_map = {};
|
| 1859 |
}
|
| 1860 |
|
| 1861 |
// Normalize id for the compiler & cache. // wp.template expects id WITHOUT the "tmpl-" prefix !
|
| 1862 |
const key = template_id.replace( /^tmpl-/, '' );
|
| 1863 |
if ( Core.__bfb_tpl_cache_map[key] ) {
|
| 1864 |
return Core.__bfb_tpl_cache_map[key];
|
| 1865 |
}
|
| 1866 |
|
| 1867 |
const compiler = wp.template( key ); // <-- normalized id here
|
| 1868 |
if ( compiler ) {
|
| 1869 |
Core.__bfb_tpl_cache_map[key] = compiler;
|
| 1870 |
}
|
| 1871 |
|
| 1872 |
return compiler;
|
| 1873 |
}
|
| 1874 |
|
| 1875 |
/**
|
| 1876 |
* REQUIRED: render preview into host element (full redraw; idempotent).
|
| 1877 |
* Subclasses should set static `template_id` to a valid wp.template id.
|
| 1878 |
* @param {HTMLElement} el
|
| 1879 |
* @param {Object} data
|
| 1880 |
* @param {{mode?:string,builder?:any,tpl?:Function,sanit?:any}} ctx
|
| 1881 |
* @returns {void}
|
| 1882 |
*/
|
| 1883 |
static render( el, data, ctx ) {
|
| 1884 |
if ( ! el ) {
|
| 1885 |
return;
|
| 1886 |
}
|
| 1887 |
|
| 1888 |
var compile = this.get_template( this.template_id );
|
| 1889 |
var d = this.normalize_data( data );
|
| 1890 |
|
| 1891 |
var s = (ctx && ctx.sanit) ? ctx.sanit : Core.WPBC_BFB_Sanitize;
|
| 1892 |
|
| 1893 |
// Sanitize critical attributes before templating.
|
| 1894 |
if ( s ) {
|
| 1895 |
d.html_id = d.html_id ? s.sanitize_html_id( String( d.html_id ) ) : '';
|
| 1896 |
d.name = s.sanitize_html_name( String( d.name || d.id || 'field' ) );
|
| 1897 |
} else {
|
| 1898 |
d.html_id = d.html_id ? String( d.html_id ) : '';
|
| 1899 |
d.name = String( d.name || d.id || 'field' );
|
| 1900 |
}
|
| 1901 |
|
| 1902 |
// Fall back to generic preview if template not available.
|
| 1903 |
if ( compile ) {
|
| 1904 |
el.innerHTML = compile( d );
|
| 1905 |
|
| 1906 |
// After render, set attribute values via DOM so quotes/newlines are handled correctly.
|
| 1907 |
const input = el.querySelector( 'input, textarea, select' );
|
| 1908 |
if ( input ) {
|
| 1909 |
if ( d.placeholder != null ) input.setAttribute( 'placeholder', String( d.placeholder ) );
|
| 1910 |
if ( d.title != null ) input.setAttribute( 'title', String( d.title ) );
|
| 1911 |
}
|
| 1912 |
|
| 1913 |
} else {
|
| 1914 |
el.innerHTML = Core.WPBC_Form_Builder_Helper.render_field_inner_html( d );
|
| 1915 |
}
|
| 1916 |
|
| 1917 |
el.dataset.type = d.type || 'field';
|
| 1918 |
el.setAttribute( 'data-label', (d.label != null ? String( d.label ) : '') ); // allow "".
|
| 1919 |
}
|
| 1920 |
|
| 1921 |
|
| 1922 |
/**
|
| 1923 |
* OPTIONAL hook executed after field is dropped/loaded/preview.
|
| 1924 |
* Default extended:
|
| 1925 |
* - On first drop: stamp default label (existing behavior) and mark field as "fresh" for auto-name.
|
| 1926 |
* - On load: mark as loaded so later label edits do not rename the saved name.
|
| 1927 |
*/
|
| 1928 |
static on_field_drop(data, el, meta) {
|
| 1929 |
|
| 1930 |
const context = (meta && meta.context) ? String( meta.context ) : '';
|
| 1931 |
|
| 1932 |
// -----------------------------------------------------------------------------------------
|
| 1933 |
// NEW: Seed default "help" (and keep it in Structure) for all field packs that define it.
|
| 1934 |
// This fixes the mismatch where:
|
| 1935 |
// - UI shows default help via normalize_data() / templates
|
| 1936 |
// - but get_structure() / exporters see `help` as undefined/empty.
|
| 1937 |
//
|
| 1938 |
// Behavior:
|
| 1939 |
// - Runs ONLY on initial drop (context === 'drop').
|
| 1940 |
// - If get_defaults() exposes a non-empty "help", and data.help is
|
| 1941 |
// missing / null / empty string -> we persist the default into `data`
|
| 1942 |
// and notify Structure so exports see it.
|
| 1943 |
// - On "load" we do nothing, so existing forms where user *cleared*
|
| 1944 |
// help will not be overridden.
|
| 1945 |
// -----------------------------------------------------------------------------------------
|
| 1946 |
if ( context === 'drop' && data ) {
|
| 1947 |
try {
|
| 1948 |
const defs = (typeof this.get_defaults === 'function') ? this.get_defaults() : null;
|
| 1949 |
if ( defs && Object.prototype.hasOwnProperty.call( defs, 'help' ) ) {
|
| 1950 |
const current = Object.prototype.hasOwnProperty.call( data, 'help' ) ? data.help : undefined;
|
| 1951 |
const hasValue = (current !== undefined && current !== null && String( current ) !== '');
|
| 1952 |
const defaultVal = defs.help;
|
| 1953 |
|
| 1954 |
if ( ! hasValue && defaultVal != null && String( defaultVal ) !== '' ) {
|
| 1955 |
// 1) persist into data object (used by Structure).
|
| 1956 |
data.help = defaultVal;
|
| 1957 |
|
| 1958 |
// 2) mirror into dataset (for any DOM-based consumers).
|
| 1959 |
if ( el ) {
|
| 1960 |
el.dataset.help = String( defaultVal );
|
| 1961 |
|
| 1962 |
// 3) notify Structure / listeners (if available).
|
| 1963 |
try {
|
| 1964 |
Core.Structure?.update_field_prop?.( el, 'help', defaultVal );
|
| 1965 |
el.dispatchEvent(
|
| 1966 |
new CustomEvent( 'wpbc_bfb_field_data_changed', { bubbles: true, detail : { key: 'help', value: defaultVal } } )
|
| 1967 |
);
|
| 1968 |
} catch ( _inner ) {}
|
| 1969 |
}
|
| 1970 |
}
|
| 1971 |
}
|
| 1972 |
} catch ( _e ) {}
|
| 1973 |
}
|
| 1974 |
// -----------------------------------------------------------------------------------------
|
| 1975 |
|
| 1976 |
if ( context === 'drop' && !Object.prototype.hasOwnProperty.call( data, 'label' ) ) {
|
| 1977 |
const defs = this.get_defaults();
|
| 1978 |
data.label = defs.label || 'Field';
|
| 1979 |
el.setAttribute( 'data-label', data.label );
|
| 1980 |
}
|
| 1981 |
// Mark provenance flags.
|
| 1982 |
if ( context === 'drop' ) {
|
| 1983 |
el.dataset.fresh = '1'; // can auto-name on first label edit.
|
| 1984 |
el.dataset.autoname = '1';
|
| 1985 |
el.dataset.was_loaded = '0';
|
| 1986 |
// Seed a provisional unique name immediately.
|
| 1987 |
try {
|
| 1988 |
const b = meta?.builder;
|
| 1989 |
if ( b?.id && (!el.hasAttribute( 'data-name' ) || !el.getAttribute( 'data-name' )) ) {
|
| 1990 |
const S = Core.WPBC_BFB_Sanitize;
|
| 1991 |
const base = S.sanitize_html_name( el.getAttribute( 'data-id' ) || data?.id || data?.type || 'field' );
|
| 1992 |
const uniq = b.id.ensure_unique_field_name( base, el );
|
| 1993 |
el.setAttribute( 'data-name', uniq );
|
| 1994 |
el.dataset.name_user_touched = '0';
|
| 1995 |
}
|
| 1996 |
} catch ( _ ) {}
|
| 1997 |
|
| 1998 |
} else if ( context === 'load' ) {
|
| 1999 |
el.dataset.fresh = '0';
|
| 2000 |
el.dataset.autoname = '0';
|
| 2001 |
el.dataset.was_loaded = '1'; // never rename names for loaded fields.
|
| 2002 |
}
|
| 2003 |
}
|
| 2004 |
|
| 2005 |
// --- Auto Rename "Fresh" field, on entering the new Label ---
|
| 2006 |
|
| 2007 |
/**
|
| 2008 |
* Create a conservative field "name" from a human label.
|
| 2009 |
* Uses the same constraints as sanitize_html_name (letters/digits/_- and leading letter).
|
| 2010 |
*/
|
| 2011 |
static name_from_label(label) {
|
| 2012 |
const s = Core.WPBC_BFB_Sanitize.sanitize_html_name( String( label ?? '' ) );
|
| 2013 |
return s.toLowerCase() || 'field';
|
| 2014 |
}
|
| 2015 |
|
| 2016 |
/**
|
| 2017 |
* Auto-fill data-name from label ONLY for freshly dropped fields that were not edited yet.
|
| 2018 |
* - Never runs for sections.
|
| 2019 |
* - Never runs for loaded/existing fields.
|
| 2020 |
* - Stops as soon as user edits the Name manually.
|
| 2021 |
*
|
| 2022 |
* @param {WPBC_Form_Builder} builder
|
| 2023 |
* @param {HTMLElement} el - .wpbc_bfb__field element
|
| 2024 |
* @param {string} labelVal
|
| 2025 |
*/
|
| 2026 |
static maybe_autoname_from_label(builder, el, labelVal) {
|
| 2027 |
if ( !builder || !el ) return;
|
| 2028 |
if ( el.classList.contains( 'wpbc_bfb__section' ) ) return;
|
| 2029 |
|
| 2030 |
const allowAuto = el.dataset.autoname === '1';
|
| 2031 |
|
| 2032 |
const userTouched = el.dataset.name_user_touched === '1';
|
| 2033 |
const isLoaded = el.dataset.was_loaded === '1';
|
| 2034 |
|
| 2035 |
if ( !allowAuto || userTouched || isLoaded ) return;
|
| 2036 |
|
| 2037 |
// Only override placeholder-y names
|
| 2038 |
const S = Core.WPBC_BFB_Sanitize;
|
| 2039 |
|
| 2040 |
const base = this.name_from_label( labelVal );
|
| 2041 |
const unique = builder.id.ensure_unique_field_name( base, el );
|
| 2042 |
el.setAttribute( 'data-name', unique );
|
| 2043 |
|
| 2044 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 2045 |
const nameCtrl = ins?.querySelector( '[data-inspector-key="name"]' );
|
| 2046 |
if ( nameCtrl && 'value' in nameCtrl && nameCtrl.value !== unique ) nameCtrl.value = unique;
|
| 2047 |
}
|
| 2048 |
|
| 2049 |
|
| 2050 |
};
|
| 2051 |
|
| 2052 |
/**
|
| 2053 |
* Select_Base (shared base for select-like packs)
|
| 2054 |
*
|
| 2055 |
* @type {Core.WPBC_BFB_Select_Base}
|
| 2056 |
*/
|
| 2057 |
Core.WPBC_BFB_Select_Base = class extends Core.WPBC_BFB_Field_Base {
|
| 2058 |
|
| 2059 |
static template_id = null; // main preview template id
|
| 2060 |
static option_row_template_id = 'wpbc-bfb-inspector-select-option-row'; // row tpl id
|
| 2061 |
static kind = 'select';
|
| 2062 |
static __root_wired = false;
|
| 2063 |
static __root_node = null;
|
| 2064 |
|
| 2065 |
// Single source of selectors used by the inspector UI.
|
| 2066 |
static ui = {
|
| 2067 |
list : '.wpbc_bfb__options_list',
|
| 2068 |
holder : '.wpbc_bfb__options_state[data-inspector-key="options"]',
|
| 2069 |
row : '.wpbc_bfb__options_row',
|
| 2070 |
label : '.wpbc_bfb__opt-label',
|
| 2071 |
value : '.wpbc_bfb__opt-value',
|
| 2072 |
toggle : '.wpbc_bfb__opt-selected-chk',
|
| 2073 |
add_btn: '.js-add-option',
|
| 2074 |
|
| 2075 |
drag_handle : '.wpbc_bfb__drag-handle',
|
| 2076 |
multiple_chk : '.js-opt-multiple[data-inspector-key="multiple"]',
|
| 2077 |
default_text : '.js-default-value[data-inspector-key="default_value"]',
|
| 2078 |
placeholder_input: '.js-placeholder[data-inspector-key="placeholder"]',
|
| 2079 |
placeholder_note : '.js-placeholder-note',
|
| 2080 |
size_input : '.inspector__input[data-inspector-key="size"]',
|
| 2081 |
|
| 2082 |
// Dropdown menu integration.
|
| 2083 |
menu_root : '.wpbc_ui_el__dropdown',
|
| 2084 |
menu_toggle: '[data-toggle="wpbc_dropdown"]',
|
| 2085 |
menu_action: '.ul_dropdown_menu_li_action[data-action]',
|
| 2086 |
// Value-differs toggle.
|
| 2087 |
value_differs_chk: '.js-value-differs[data-inspector-key="value_differs"]',
|
| 2088 |
};
|
| 2089 |
|
| 2090 |
/**
|
| 2091 |
* Build option value from label.
|
| 2092 |
* - If `differs === true` -> generate token (slug-like machine value).
|
| 2093 |
* - If `differs === false` -> keep human text; escape only dangerous chars.
|
| 2094 |
* @param {string} label
|
| 2095 |
* @param {boolean} differs
|
| 2096 |
* @returns {string}
|
| 2097 |
*/
|
| 2098 |
static build_value_from_label(label, differs) {
|
| 2099 |
const S = Core.WPBC_BFB_Sanitize;
|
| 2100 |
if ( differs ) {
|
| 2101 |
return (S && typeof S.to_token === 'function')
|
| 2102 |
? S.to_token( String( label || '' ) )
|
| 2103 |
: String( label || '' ).trim().toLowerCase().replace( /\s+/g, '_' ).replace( /[^\w-]/g, '' );
|
| 2104 |
}
|
| 2105 |
// single-input mode: keep human text; template will escape safely.
|
| 2106 |
return String( label == null ? '' : label );
|
| 2107 |
}
|
| 2108 |
|
| 2109 |
/**
|
| 2110 |
* Is the “value differs from label” toggle enabled?
|
| 2111 |
* @param {HTMLElement} panel
|
| 2112 |
* @returns {boolean}
|
| 2113 |
*/
|
| 2114 |
static is_value_differs_enabled(panel) {
|
| 2115 |
const chk = panel?.querySelector( this.ui.value_differs_chk );
|
| 2116 |
return !!(chk && chk.checked);
|
| 2117 |
}
|
| 2118 |
|
| 2119 |
/**
|
| 2120 |
* Ensure visibility/enabled state of Value inputs based on the toggle.
|
| 2121 |
* When disabled -> hide Value inputs and keep them mirrored from Label.
|
| 2122 |
* @param {HTMLElement} panel
|
| 2123 |
* @returns {void}
|
| 2124 |
*/
|
| 2125 |
static sync_value_inputs_visibility(panel) {
|
| 2126 |
const differs = this.is_value_differs_enabled( panel );
|
| 2127 |
const rows = panel?.querySelectorAll( this.ui.row ) || [];
|
| 2128 |
|
| 2129 |
for ( let i = 0; i < rows.length; i++ ) {
|
| 2130 |
const r = rows[i];
|
| 2131 |
const lbl_in = r.querySelector( this.ui.label );
|
| 2132 |
const val_in = r.querySelector( this.ui.value );
|
| 2133 |
if ( !val_in ) continue;
|
| 2134 |
|
| 2135 |
if ( differs ) {
|
| 2136 |
// Re-enable & show value input
|
| 2137 |
val_in.removeAttribute( 'disabled' );
|
| 2138 |
val_in.style.display = '';
|
| 2139 |
|
| 2140 |
// If we have a cached custom value and the row wasn't edited while OFF, restore it
|
| 2141 |
const hasCache = !!val_in.dataset.cached_value;
|
| 2142 |
const userEdited = r.dataset.value_user_touched === '1';
|
| 2143 |
|
| 2144 |
if ( hasCache && !userEdited ) {
|
| 2145 |
val_in.value = val_in.dataset.cached_value;
|
| 2146 |
} else if ( !hasCache ) {
|
| 2147 |
// No cache: if value is just a mirrored label, offer a tokenized default
|
| 2148 |
const lbl = lbl_in ? lbl_in.value : '';
|
| 2149 |
const mirrored = this.build_value_from_label( lbl, /*differs=*/false );
|
| 2150 |
if ( val_in.value === mirrored ) {
|
| 2151 |
val_in.value = this.build_value_from_label( lbl, /*differs=*/true );
|
| 2152 |
}
|
| 2153 |
}
|
| 2154 |
} else {
|
| 2155 |
// ON -> OFF: cache once, then mirror
|
| 2156 |
if ( !val_in.dataset.cached_value ) {
|
| 2157 |
val_in.dataset.cached_value = val_in.value || '';
|
| 2158 |
}
|
| 2159 |
const lbl = lbl_in ? lbl_in.value : '';
|
| 2160 |
val_in.value = this.build_value_from_label( lbl, /*differs=*/false );
|
| 2161 |
|
| 2162 |
val_in.setAttribute( 'disabled', 'disabled' );
|
| 2163 |
val_in.style.display = 'none';
|
| 2164 |
// NOTE: do NOT mark as user_touched here
|
| 2165 |
}
|
| 2166 |
}
|
| 2167 |
}
|
| 2168 |
|
| 2169 |
|
| 2170 |
/**
|
| 2171 |
* Return whether this row’s value has been edited by user.
|
| 2172 |
* @param {HTMLElement} row
|
| 2173 |
* @returns {boolean}
|
| 2174 |
*/
|
| 2175 |
static is_row_value_user_touched(row) {
|
| 2176 |
return row?.dataset?.value_user_touched === '1';
|
| 2177 |
}
|
| 2178 |
|
| 2179 |
/**
|
| 2180 |
* Mark this row’s value as edited by user.
|
| 2181 |
* @param {HTMLElement} row
|
| 2182 |
*/
|
| 2183 |
static mark_row_value_user_touched(row) {
|
| 2184 |
if ( row ) row.dataset.value_user_touched = '1';
|
| 2185 |
}
|
| 2186 |
|
| 2187 |
/**
|
| 2188 |
* Initialize “freshness” flags on a row (value untouched).
|
| 2189 |
* Call on creation/append of rows.
|
| 2190 |
* @param {HTMLElement} row
|
| 2191 |
*/
|
| 2192 |
static init_row_fresh_flags(row) {
|
| 2193 |
if ( row ) {
|
| 2194 |
if ( !row.dataset.value_user_touched ) {
|
| 2195 |
row.dataset.value_user_touched = '0';
|
| 2196 |
}
|
| 2197 |
}
|
| 2198 |
}
|
| 2199 |
|
| 2200 |
// ---- defaults (packs can override) ----
|
| 2201 |
static get_defaults() {
|
| 2202 |
return {
|
| 2203 |
type : this.kind,
|
| 2204 |
label : 'Select',
|
| 2205 |
name : '',
|
| 2206 |
html_id : '',
|
| 2207 |
placeholder : '--- Select ---',
|
| 2208 |
required : false,
|
| 2209 |
multiple : false,
|
| 2210 |
size : null,
|
| 2211 |
cssclass : '',
|
| 2212 |
help : '',
|
| 2213 |
default_value: '',
|
| 2214 |
options : [
|
| 2215 |
{ label: 'Option 1', value: 'Option 1', selected: false },
|
| 2216 |
{ label: 'Option 2', value: 'Option 2', selected: false },
|
| 2217 |
{ label: 'Option 3', value: 'Option 3', selected: false },
|
| 2218 |
{ label: 'Option 4', value: 'Option 4', selected: false }
|
| 2219 |
],
|
| 2220 |
min_width : '240px'
|
| 2221 |
};
|
| 2222 |
}
|
| 2223 |
|
| 2224 |
// ---- preview render (idempotent) ----
|
| 2225 |
static render(el, data, ctx) {
|
| 2226 |
if ( !el ) return;
|
| 2227 |
|
| 2228 |
const d = this.normalize_data( data );
|
| 2229 |
|
| 2230 |
if ( d.min_width != null ) {
|
| 2231 |
el.dataset.min_width = String( d.min_width );
|
| 2232 |
try {
|
| 2233 |
el.style.setProperty( '--wpbc-col-min', String( d.min_width ) );
|
| 2234 |
} catch ( _ ) {
|
| 2235 |
}
|
| 2236 |
}
|
| 2237 |
if ( d.html_id != null ) el.dataset.html_id = String( d.html_id || '' );
|
| 2238 |
if ( d.cssclass != null ) el.dataset.cssclass = String( d.cssclass || '' );
|
| 2239 |
if ( d.placeholder != null ) el.dataset.placeholder = String( d.placeholder || '' );
|
| 2240 |
|
| 2241 |
const tpl = this.get_template( this.template_id );
|
| 2242 |
if ( typeof tpl !== 'function' ) {
|
| 2243 |
el.innerHTML = '<div class="wpbc_bfb__error" role="alert">Template not found: ' + this.template_id + '.</div>';
|
| 2244 |
return;
|
| 2245 |
}
|
| 2246 |
|
| 2247 |
try {
|
| 2248 |
el.innerHTML = tpl( d );
|
| 2249 |
} catch ( e ) {
|
| 2250 |
window._wpbc?.dev?.error?.( 'Select_Base.render', e );
|
| 2251 |
el.innerHTML = '<div class="wpbc_bfb__error" role="alert">Error rendering field preview.</div>';
|
| 2252 |
return;
|
| 2253 |
}
|
| 2254 |
|
| 2255 |
el.dataset.type = d.type || this.kind;
|
| 2256 |
el.setAttribute( 'data-label', (d.label != null ? String( d.label ) : '') );
|
| 2257 |
|
| 2258 |
try {
|
| 2259 |
Core.UI?.WPBC_BFB_Overlay?.ensure?.( ctx?.builder, el );
|
| 2260 |
} catch ( _ ) {
|
| 2261 |
}
|
| 2262 |
|
| 2263 |
if ( !el.dataset.options && Array.isArray( d.options ) && d.options.length ) {
|
| 2264 |
try {
|
| 2265 |
el.dataset.options = JSON.stringify( d.options );
|
| 2266 |
} catch ( _ ) {
|
| 2267 |
}
|
| 2268 |
}
|
| 2269 |
}
|
| 2270 |
|
| 2271 |
// ---- drop seeding (options + placeholder) ----
|
| 2272 |
static on_field_drop(data, el, meta) {
|
| 2273 |
try {
|
| 2274 |
super.on_field_drop?.( data, el, meta );
|
| 2275 |
} catch ( _ ) {
|
| 2276 |
}
|
| 2277 |
|
| 2278 |
const is_drop = (meta && meta.context === 'drop');
|
| 2279 |
|
| 2280 |
if ( is_drop ) {
|
| 2281 |
if ( !Array.isArray( data.options ) || !data.options.length ) {
|
| 2282 |
const opts = (this.get_defaults().options || []).map( (o) => ({
|
| 2283 |
label : o.label,
|
| 2284 |
value : o.value,
|
| 2285 |
selected: !!o.selected
|
| 2286 |
}) );
|
| 2287 |
data.options = opts;
|
| 2288 |
try {
|
| 2289 |
el.dataset.options = JSON.stringify( opts );
|
| 2290 |
el.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', { bubbles: true,
|
| 2291 |
detail : {
|
| 2292 |
key : 'options',
|
| 2293 |
value: opts
|
| 2294 |
}
|
| 2295 |
} ) );
|
| 2296 |
Core.Structure?.update_field_prop?.( el, 'options', opts );
|
| 2297 |
} catch ( _ ) {
|
| 2298 |
}
|
| 2299 |
}
|
| 2300 |
|
| 2301 |
const ph = (data.placeholder ?? '').toString().trim();
|
| 2302 |
if ( !ph ) {
|
| 2303 |
const dflt = this.get_defaults().placeholder || '--- Select ---';
|
| 2304 |
data.placeholder = dflt;
|
| 2305 |
try {
|
| 2306 |
el.dataset.placeholder = String( dflt );
|
| 2307 |
el.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', { bubbles: true,
|
| 2308 |
detail : {
|
| 2309 |
key : 'placeholder',
|
| 2310 |
value: dflt
|
| 2311 |
}
|
| 2312 |
} ) );
|
| 2313 |
Core.Structure?.update_field_prop?.( el, 'placeholder', dflt );
|
| 2314 |
} catch ( _ ) {
|
| 2315 |
}
|
| 2316 |
}
|
| 2317 |
}
|
| 2318 |
}
|
| 2319 |
|
| 2320 |
// ==============================
|
| 2321 |
// Inspector helpers (snake_case)
|
| 2322 |
// ==============================
|
| 2323 |
static get_panel_root(el) {
|
| 2324 |
return el?.closest?.( '.wpbc_bfb__inspector__body' ) || el?.closest?.( '.wpbc_bfb__inspector' ) || null;
|
| 2325 |
}
|
| 2326 |
|
| 2327 |
static get_list(panel) {
|
| 2328 |
return panel ? panel.querySelector( this.ui.list ) : null;
|
| 2329 |
}
|
| 2330 |
|
| 2331 |
static get_holder(panel) {
|
| 2332 |
return panel ? panel.querySelector( this.ui.holder ) : null;
|
| 2333 |
}
|
| 2334 |
|
| 2335 |
static make_uid() {
|
| 2336 |
return 'wpbc_ins_auto_opt_' + Math.random().toString( 36 ).slice( 2, 10 );
|
| 2337 |
}
|
| 2338 |
|
| 2339 |
static append_row(panel, data) {
|
| 2340 |
const list = this.get_list( panel );
|
| 2341 |
if ( !list ) return;
|
| 2342 |
|
| 2343 |
const idx = list.children.length;
|
| 2344 |
const rowd = Object.assign( { label: '', value: '', selected: false, index: idx }, (data || {}) );
|
| 2345 |
if ( !rowd.uid ) rowd.uid = this.make_uid();
|
| 2346 |
|
| 2347 |
const tpl_id = this.option_row_template_id;
|
| 2348 |
const tpl = (window.wp && wp.template) ? wp.template( tpl_id ) : null;
|
| 2349 |
const html = tpl ? tpl( rowd ) : null;
|
| 2350 |
|
| 2351 |
// In append_row() -> fallback HTML.
|
| 2352 |
const wrap = document.createElement( 'div' );
|
| 2353 |
wrap.innerHTML = html || (
|
| 2354 |
'<div class="wpbc_bfb__options_row" data-index="' + (rowd.index || 0) + '">' +
|
| 2355 |
'<span class="wpbc_bfb__drag-handle"><span class="wpbc_icn_drag_indicator"></span></span>' +
|
| 2356 |
'<input type="text" class="wpbc_bfb__opt-label" placeholder="Label" value="' + (rowd.label || '') + '">' +
|
| 2357 |
'<input type="text" class="wpbc_bfb__opt-value" placeholder="Value" value="' + (rowd.value || '') + '">' +
|
| 2358 |
'<div class="wpbc_bfb__opt-selected">' +
|
| 2359 |
'<div class="inspector__control wpbc_ui__toggle">' +
|
| 2360 |
'<input type="checkbox" class="wpbc_bfb__opt-selected-chk inspector__input" id="' + rowd.uid + '" role="switch" ' + (rowd.selected ? 'checked aria-checked="true"' : 'aria-checked="false"') + '>' +
|
| 2361 |
'<label class="wpbc_ui__toggle_icon_radio" for="' + rowd.uid + '"></label>' +
|
| 2362 |
'<label class="wpbc_ui__toggle_label" for="' + rowd.uid + '">Default</label>' +
|
| 2363 |
'</div>' +
|
| 2364 |
'</div>' +
|
| 2365 |
// 3-dot dropdown (uses existing plugin dropdown JS).
|
| 2366 |
'<div class="wpbc_ui_el wpbc_ui_el_container wpbc_ui_el__dropdown">' +
|
| 2367 |
'<a href="javascript:void(0)" data-toggle="wpbc_dropdown" aria-expanded="false" class="ul_dropdown_menu_toggle">' +
|
| 2368 |
'<i class="menu_icon icon-1x wpbc_icn_more_vert"></i>' +
|
| 2369 |
'</a>' +
|
| 2370 |
'<ul class="ul_dropdown_menu" role="menu" style="right:0px; left:auto;">' +
|
| 2371 |
'<li>' +
|
| 2372 |
'<a class="ul_dropdown_menu_li_action" data-action="add_after" href="javascript:void(0)">' +
|
| 2373 |
'Add New' +
|
| 2374 |
'<i class="menu_icon icon-1x wpbc_icn_add_circle"></i>' +
|
| 2375 |
'</a>' +
|
| 2376 |
'</li>' +
|
| 2377 |
'<li>' +
|
| 2378 |
'<a class="ul_dropdown_menu_li_action" data-action="duplicate" href="javascript:void(0)">' +
|
| 2379 |
'Duplicate' +
|
| 2380 |
'<i class="menu_icon icon-1x wpbc_icn_content_copy"></i>' +
|
| 2381 |
'</a>' +
|
| 2382 |
'</li>' +
|
| 2383 |
'<li class="divider"></li>' +
|
| 2384 |
'<li>' +
|
| 2385 |
'<a class="ul_dropdown_menu_li_action" data-action="remove" href="javascript:void(0)">' +
|
| 2386 |
'Remove' +
|
| 2387 |
'<i class="menu_icon icon-1x wpbc_icn_delete_outline"></i>' +
|
| 2388 |
'</a>' +
|
| 2389 |
'</li>' +
|
| 2390 |
'</ul>' +
|
| 2391 |
'</div>' +
|
| 2392 |
'</div>'
|
| 2393 |
);
|
| 2394 |
|
| 2395 |
const node = wrap.firstElementChild;
|
| 2396 |
if (! node) {
|
| 2397 |
return;
|
| 2398 |
}
|
| 2399 |
// pre-hide Value input if toggle is OFF **before** appending.
|
| 2400 |
const differs = this.is_value_differs_enabled( panel );
|
| 2401 |
const valIn = node.querySelector( this.ui.value );
|
| 2402 |
const lblIn = node.querySelector( this.ui.label );
|
| 2403 |
|
| 2404 |
if ( !differs && valIn ) {
|
| 2405 |
if ( !valIn.dataset.cached_value ) {
|
| 2406 |
valIn.dataset.cached_value = valIn.value || '';
|
| 2407 |
}
|
| 2408 |
if ( lblIn ) valIn.value = this.build_value_from_label( lblIn.value, false );
|
| 2409 |
valIn.setAttribute( 'disabled', 'disabled' );
|
| 2410 |
valIn.style.display = 'none';
|
| 2411 |
}
|
| 2412 |
|
| 2413 |
|
| 2414 |
this.init_row_fresh_flags( node );
|
| 2415 |
list.appendChild( node );
|
| 2416 |
|
| 2417 |
// Keep your existing post-append sync as a safety net
|
| 2418 |
this.sync_value_inputs_visibility( panel );
|
| 2419 |
}
|
| 2420 |
|
| 2421 |
static close_dropdown(anchor_el) {
|
| 2422 |
try {
|
| 2423 |
var root = anchor_el?.closest?.( this.ui.menu_root );
|
| 2424 |
if ( root ) {
|
| 2425 |
// If your dropdown toggler toggles a class like 'open', close it.
|
| 2426 |
root.classList.remove( 'open' );
|
| 2427 |
// Or if it relies on aria-expanded on the toggle.
|
| 2428 |
var t = root.querySelector( this.ui.menu_toggle );
|
| 2429 |
if ( t ) {
|
| 2430 |
t.setAttribute( 'aria-expanded', 'false' );
|
| 2431 |
}
|
| 2432 |
}
|
| 2433 |
} catch ( _ ) { }
|
| 2434 |
}
|
| 2435 |
|
| 2436 |
static insert_after(new_node, ref_node) {
|
| 2437 |
if ( ref_node?.parentNode ) {
|
| 2438 |
if ( ref_node.nextSibling ) {
|
| 2439 |
ref_node.parentNode.insertBefore( new_node, ref_node.nextSibling );
|
| 2440 |
} else {
|
| 2441 |
ref_node.parentNode.appendChild( new_node );
|
| 2442 |
}
|
| 2443 |
}
|
| 2444 |
}
|
| 2445 |
|
| 2446 |
static commit_options(panel) {
|
| 2447 |
const list = this.get_list( panel );
|
| 2448 |
const holder = this.get_holder( panel );
|
| 2449 |
if ( !list || !holder ) return;
|
| 2450 |
|
| 2451 |
const differs = this.is_value_differs_enabled( panel );
|
| 2452 |
|
| 2453 |
const rows = list.querySelectorAll( this.ui.row );
|
| 2454 |
const options = [];
|
| 2455 |
for ( let i = 0; i < rows.length; i++ ) {
|
| 2456 |
const r = rows[i];
|
| 2457 |
const lbl_in = r.querySelector( this.ui.label );
|
| 2458 |
const val_in = r.querySelector( this.ui.value );
|
| 2459 |
const chk = r.querySelector( this.ui.toggle );
|
| 2460 |
|
| 2461 |
const lbl = (lbl_in && lbl_in.value) || '';
|
| 2462 |
let val = (val_in && val_in.value) || '';
|
| 2463 |
|
| 2464 |
// If single-input mode -> hard mirror to label.
|
| 2465 |
if ( ! differs ) {
|
| 2466 |
// single-input mode: mirror Label, minimal escaping (no slug).
|
| 2467 |
val = this.build_value_from_label( lbl, /*differs=*/false );
|
| 2468 |
if ( val_in ) {
|
| 2469 |
val_in.value = val; // keep hidden input in sync for any previews/debug.
|
| 2470 |
}
|
| 2471 |
}
|
| 2472 |
|
| 2473 |
const sel = !!(chk && chk.checked);
|
| 2474 |
options.push( { label: lbl, value: val, selected: sel } );
|
| 2475 |
}
|
| 2476 |
|
| 2477 |
try {
|
| 2478 |
holder.value = JSON.stringify( options );
|
| 2479 |
holder.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 2480 |
holder.dispatchEvent( new Event( 'change', { bubbles: true } ) );
|
| 2481 |
panel.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', {
|
| 2482 |
bubbles: true, detail: {
|
| 2483 |
key: 'options', value: options
|
| 2484 |
}
|
| 2485 |
} ) );
|
| 2486 |
} catch ( _ ) {
|
| 2487 |
}
|
| 2488 |
|
| 2489 |
this.sync_default_value_lock( panel );
|
| 2490 |
this.sync_placeholder_lock( panel );
|
| 2491 |
|
| 2492 |
// Mirror to the selected field element so canvas/export sees current options immediately.
|
| 2493 |
const field = panel.__selectbase_field
|
| 2494 |
|| document.querySelector( '.wpbc_bfb__field.is-selected, .wpbc_bfb__field--selected' );
|
| 2495 |
if ( field ) {
|
| 2496 |
try {
|
| 2497 |
field.dataset.options = JSON.stringify( options );
|
| 2498 |
} catch ( _ ) {
|
| 2499 |
}
|
| 2500 |
Core.Structure?.update_field_prop?.( field, 'options', options );
|
| 2501 |
field.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', {
|
| 2502 |
bubbles: true, detail: { key: 'options', value: options }
|
| 2503 |
} ) );
|
| 2504 |
}
|
| 2505 |
}
|
| 2506 |
|
| 2507 |
|
| 2508 |
static ensure_sortable(panel) {
|
| 2509 |
|
| 2510 |
const list = this.get_list( panel );
|
| 2511 |
if ( ! list ) {
|
| 2512 |
return;
|
| 2513 |
}
|
| 2514 |
|
| 2515 |
try {
|
| 2516 |
const existing = window.Sortable?.get?.( list );
|
| 2517 |
if ( existing ) {
|
| 2518 |
return;
|
| 2519 |
}
|
| 2520 |
|
| 2521 |
const builder = window.wpbc_bfb_api?.get_builder?.() || window.wpbc_bfb || null;
|
| 2522 |
|
| 2523 |
// Prefer the shared Sortable manager so the sidebar list uses
|
| 2524 |
// the dedicated "simple_list" config instead of the canvas config.
|
| 2525 |
if ( builder && builder.sortable && typeof builder.sortable.ensure === 'function' ) {
|
| 2526 |
|
| 2527 |
builder.sortable.ensure(
|
| 2528 |
list,
|
| 2529 |
'canvas',
|
| 2530 |
{
|
| 2531 |
sortable_kind : 'simple_list',
|
| 2532 |
handle_selector : this.ui.drag_handle,
|
| 2533 |
draggable_selector: this.ui.row,
|
| 2534 |
onUpdate : () => {
|
| 2535 |
this.commit_options( panel );
|
| 2536 |
}
|
| 2537 |
}
|
| 2538 |
);
|
| 2539 |
|
| 2540 |
} else if ( window.Sortable?.create ) {
|
| 2541 |
// Fallback if builder is not ready for some reason.
|
| 2542 |
window.Sortable.create(
|
| 2543 |
list,
|
| 2544 |
{
|
| 2545 |
handle : this.ui.drag_handle,
|
| 2546 |
draggable : this.ui.row,
|
| 2547 |
animation : 120,
|
| 2548 |
forceFallback : true,
|
| 2549 |
fallbackOnBody : false,
|
| 2550 |
fallbackTolerance: 8,
|
| 2551 |
removeCloneOnHide: true,
|
| 2552 |
onUpdate : () => {
|
| 2553 |
this.commit_options( panel );
|
| 2554 |
}
|
| 2555 |
}
|
| 2556 |
);
|
| 2557 |
}
|
| 2558 |
|
| 2559 |
list.dataset.sortable_init = '1';
|
| 2560 |
|
| 2561 |
} catch ( e ) {
|
| 2562 |
window._wpbc?.dev?.error?.( 'Select_Base.ensure_sortable', e );
|
| 2563 |
}
|
| 2564 |
}
|
| 2565 |
|
| 2566 |
static rebuild_if_empty(panel) {
|
| 2567 |
const list = this.get_list( panel );
|
| 2568 |
const holder = this.get_holder( panel );
|
| 2569 |
if ( !list || !holder || list.children.length ) return;
|
| 2570 |
|
| 2571 |
let data = [];
|
| 2572 |
try {
|
| 2573 |
data = JSON.parse( holder.value || '[]' );
|
| 2574 |
} catch ( _ ) {
|
| 2575 |
data = [];
|
| 2576 |
}
|
| 2577 |
|
| 2578 |
if ( !Array.isArray( data ) || !data.length ) {
|
| 2579 |
data = (this.get_defaults().options || []).slice( 0 );
|
| 2580 |
try {
|
| 2581 |
holder.value = JSON.stringify( data );
|
| 2582 |
holder.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 2583 |
holder.dispatchEvent( new Event( 'change', { bubbles: true } ) );
|
| 2584 |
} catch ( _ ) {
|
| 2585 |
}
|
| 2586 |
}
|
| 2587 |
|
| 2588 |
for ( let i = 0; i < data.length; i++ ) {
|
| 2589 |
this.append_row( panel, {
|
| 2590 |
label : data[i]?.label || '',
|
| 2591 |
value : data[i]?.value || '',
|
| 2592 |
selected: !!data[i]?.selected,
|
| 2593 |
index : i,
|
| 2594 |
uid : this.make_uid()
|
| 2595 |
} );
|
| 2596 |
}
|
| 2597 |
|
| 2598 |
this.sync_default_value_lock( panel );
|
| 2599 |
this.sync_placeholder_lock( panel );
|
| 2600 |
this.sync_value_inputs_visibility( panel );
|
| 2601 |
}
|
| 2602 |
|
| 2603 |
static has_row_defaults(panel) {
|
| 2604 |
const checks = panel?.querySelectorAll( this.ui.toggle );
|
| 2605 |
if ( !checks?.length ) return false;
|
| 2606 |
for ( let i = 0; i < checks.length; i++ ) if ( checks[i].checked ) return true;
|
| 2607 |
return false;
|
| 2608 |
}
|
| 2609 |
|
| 2610 |
static is_multiple_enabled(panel) {
|
| 2611 |
const chk = panel?.querySelector( this.ui.multiple_chk );
|
| 2612 |
return !!(chk && chk.checked);
|
| 2613 |
}
|
| 2614 |
|
| 2615 |
static has_text_default_value(panel) {
|
| 2616 |
const dv = panel?.querySelector( this.ui.default_text );
|
| 2617 |
return !!(dv && String( dv.value || '' ).trim().length);
|
| 2618 |
}
|
| 2619 |
|
| 2620 |
static sync_default_value_lock(panel) {
|
| 2621 |
const input = panel?.querySelector( this.ui.default_text );
|
| 2622 |
const note = panel?.querySelector( '.js-default-value-note' );
|
| 2623 |
if ( !input ) return;
|
| 2624 |
|
| 2625 |
const lock = this.has_row_defaults( panel );
|
| 2626 |
input.disabled = !!lock;
|
| 2627 |
if ( lock ) {
|
| 2628 |
input.setAttribute( 'aria-disabled', 'true' );
|
| 2629 |
if ( note ) note.style.display = '';
|
| 2630 |
} else {
|
| 2631 |
input.removeAttribute( 'aria-disabled' );
|
| 2632 |
if ( note ) note.style.display = 'none';
|
| 2633 |
}
|
| 2634 |
}
|
| 2635 |
|
| 2636 |
static sync_placeholder_lock(panel) {
|
| 2637 |
const input = panel?.querySelector( this.ui.placeholder_input );
|
| 2638 |
const note = panel?.querySelector( this.ui.placeholder_note );
|
| 2639 |
|
| 2640 |
// NEW: compute multiple and toggle row visibility
|
| 2641 |
const isMultiple = this.is_multiple_enabled( panel );
|
| 2642 |
const placeholderRow = input?.closest( '.inspector__row' ) || null;
|
| 2643 |
const sizeInput = panel?.querySelector( this.ui.size_input ) || null;
|
| 2644 |
const sizeRow = sizeInput?.closest( '.inspector__row' ) || null;
|
| 2645 |
|
| 2646 |
// Show placeholder only for single-select; show size only for multiple
|
| 2647 |
if ( placeholderRow ) placeholderRow.style.display = isMultiple ? 'none' : '';
|
| 2648 |
if ( sizeRow ) sizeRow.style.display = isMultiple ? '' : 'none';
|
| 2649 |
|
| 2650 |
// Existing behavior (keep as-is)
|
| 2651 |
if ( !input ) return;
|
| 2652 |
|
| 2653 |
const lock = isMultiple || this.has_row_defaults( panel ) || this.has_text_default_value( panel );
|
| 2654 |
if ( note && !note.id ) note.id = 'wpbc_placeholder_note_' + Math.random().toString( 36 ).slice( 2, 10 );
|
| 2655 |
|
| 2656 |
input.disabled = !!lock;
|
| 2657 |
if ( lock ) {
|
| 2658 |
input.setAttribute( 'aria-disabled', 'true' );
|
| 2659 |
if ( note ) {
|
| 2660 |
note.style.display = '';
|
| 2661 |
input.setAttribute( 'aria-describedby', note.id );
|
| 2662 |
}
|
| 2663 |
} else {
|
| 2664 |
input.removeAttribute( 'aria-disabled' );
|
| 2665 |
input.removeAttribute( 'aria-describedby' );
|
| 2666 |
if ( note ) note.style.display = 'none';
|
| 2667 |
}
|
| 2668 |
}
|
| 2669 |
|
| 2670 |
static enforce_single_default(panel, clicked) {
|
| 2671 |
if ( this.is_multiple_enabled( panel ) ) return;
|
| 2672 |
|
| 2673 |
const checks = panel?.querySelectorAll( this.ui.toggle );
|
| 2674 |
if ( !checks?.length ) return;
|
| 2675 |
|
| 2676 |
if ( clicked && clicked.checked ) {
|
| 2677 |
for ( let i = 0; i < checks.length; i++ ) if ( checks[i] !== clicked ) {
|
| 2678 |
checks[i].checked = false;
|
| 2679 |
checks[i].setAttribute( 'aria-checked', 'false' );
|
| 2680 |
}
|
| 2681 |
clicked.setAttribute( 'aria-checked', 'true' );
|
| 2682 |
return;
|
| 2683 |
}
|
| 2684 |
|
| 2685 |
let kept = false;
|
| 2686 |
for ( let j = 0; j < checks.length; j++ ) if ( checks[j].checked ) {
|
| 2687 |
if ( !kept ) {
|
| 2688 |
kept = true;
|
| 2689 |
} else {
|
| 2690 |
checks[j].checked = false;
|
| 2691 |
checks[j].setAttribute( 'aria-checked', 'false' );
|
| 2692 |
}
|
| 2693 |
}
|
| 2694 |
|
| 2695 |
this.sync_default_value_lock( panel );
|
| 2696 |
this.sync_placeholder_lock( panel );
|
| 2697 |
}
|
| 2698 |
|
| 2699 |
// ---- one-time bootstrap of a panel ----
|
| 2700 |
static bootstrap_panel(panel) {
|
| 2701 |
if ( !panel ) return;
|
| 2702 |
if ( !panel.querySelector( '.wpbc_bfb__options_editor' ) ) return; // only select-like UIs
|
| 2703 |
if ( panel.dataset.selectbase_bootstrapped === '1' ) {
|
| 2704 |
this.ensure_sortable( panel );
|
| 2705 |
return;
|
| 2706 |
}
|
| 2707 |
|
| 2708 |
this.rebuild_if_empty( panel );
|
| 2709 |
this.ensure_sortable( panel );
|
| 2710 |
panel.dataset.selectbase_bootstrapped = '1';
|
| 2711 |
|
| 2712 |
this.sync_default_value_lock( panel );
|
| 2713 |
this.sync_placeholder_lock( panel );
|
| 2714 |
this.sync_value_inputs_visibility( panel );
|
| 2715 |
}
|
| 2716 |
|
| 2717 |
// ---- hook into inspector lifecycle (fires ONCE) ----
|
| 2718 |
static wire_once() {
|
| 2719 |
if ( Core.__selectbase_wired ) return;
|
| 2720 |
Core.__selectbase_wired = true;
|
| 2721 |
|
| 2722 |
const on_ready_or_render = (ev) => {
|
| 2723 |
const panel = ev?.detail?.panel;
|
| 2724 |
const field = ev?.detail?.el || ev?.detail?.field || null;
|
| 2725 |
if ( !panel ) return;
|
| 2726 |
if ( field ) panel.__selectbase_field = field;
|
| 2727 |
this.bootstrap_panel( panel );
|
| 2728 |
// If the inspector root was remounted, ensure root listeners are (re)bound.
|
| 2729 |
this.wire_root_listeners();
|
| 2730 |
};
|
| 2731 |
|
| 2732 |
document.addEventListener( 'wpbc_bfb_inspector_ready', on_ready_or_render );
|
| 2733 |
document.addEventListener( 'wpbc_bfb_inspector_render', on_ready_or_render );
|
| 2734 |
|
| 2735 |
this.wire_root_listeners();
|
| 2736 |
}
|
| 2737 |
|
| 2738 |
static wire_root_listeners() {
|
| 2739 |
|
| 2740 |
// If already wired AND the stored root is still in the DOM, bail out.
|
| 2741 |
if ( this.__root_wired && this.__root_node?.isConnected ) return;
|
| 2742 |
|
| 2743 |
const root = document.getElementById( 'wpbc_bfb__inspector' );
|
| 2744 |
if ( !root ) {
|
| 2745 |
// Root missing (e.g., SPA re-render) — clear flags so we can wire later.
|
| 2746 |
this.__root_wired = false;
|
| 2747 |
this.__root_node = null;
|
| 2748 |
return;
|
| 2749 |
}
|
| 2750 |
|
| 2751 |
this.__root_node = root;
|
| 2752 |
this.__root_wired = true;
|
| 2753 |
root.dataset.selectbase_root_wired = '1';
|
| 2754 |
|
| 2755 |
const get_panel = (target) =>
|
| 2756 |
target?.closest?.( '.wpbc_bfb__inspector__body' ) ||
|
| 2757 |
root.querySelector( '.wpbc_bfb__inspector__body' ) || null;
|
| 2758 |
|
| 2759 |
// Click handlers: add / delete / duplicate
|
| 2760 |
root.addEventListener( 'click', (e) => {
|
| 2761 |
const panel = get_panel( e.target );
|
| 2762 |
if ( !panel ) return;
|
| 2763 |
|
| 2764 |
this.bootstrap_panel( panel );
|
| 2765 |
|
| 2766 |
const ui = this.ui;
|
| 2767 |
|
| 2768 |
// Existing "Add option" button (top toolbar)
|
| 2769 |
const add = e.target.closest?.( ui.add_btn );
|
| 2770 |
if ( add ) {
|
| 2771 |
this.append_row( panel, { label: '', value: '', selected: false } );
|
| 2772 |
this.commit_options( panel );
|
| 2773 |
this.sync_value_inputs_visibility( panel );
|
| 2774 |
return;
|
| 2775 |
}
|
| 2776 |
|
| 2777 |
// Dropdown menu actions.
|
| 2778 |
const menu_action = e.target.closest?.( ui.menu_action );
|
| 2779 |
if ( menu_action ) {
|
| 2780 |
e.preventDefault();
|
| 2781 |
e.stopPropagation();
|
| 2782 |
|
| 2783 |
const action = (menu_action.getAttribute( 'data-action' ) || '').toLowerCase();
|
| 2784 |
const row = menu_action.closest?.( ui.row );
|
| 2785 |
|
| 2786 |
if ( !row ) {
|
| 2787 |
this.close_dropdown( menu_action );
|
| 2788 |
return;
|
| 2789 |
}
|
| 2790 |
|
| 2791 |
if ( 'add_after' === action ) {
|
| 2792 |
// Add empty row after current
|
| 2793 |
const prev_count = this.get_list( panel )?.children.length || 0;
|
| 2794 |
this.append_row( panel, { label: '', value: '', selected: false } );
|
| 2795 |
// Move the newly added last row just after current row to preserve "add after"
|
| 2796 |
const list = this.get_list( panel );
|
| 2797 |
if ( list && list.lastElementChild && list.lastElementChild !== row ) {
|
| 2798 |
this.insert_after( list.lastElementChild, row );
|
| 2799 |
}
|
| 2800 |
this.commit_options( panel );
|
| 2801 |
this.sync_value_inputs_visibility( panel );
|
| 2802 |
} else if ( 'duplicate' === action ) {
|
| 2803 |
const lbl = (row.querySelector( ui.label ) || {}).value || '';
|
| 2804 |
const val = (row.querySelector( ui.value ) || {}).value || '';
|
| 2805 |
const sel = !!((row.querySelector( ui.toggle ) || {}).checked);
|
| 2806 |
this.append_row( panel, { label: lbl, value: val, selected: sel, uid: this.make_uid() } );
|
| 2807 |
// Place the new row right after the current.
|
| 2808 |
const list = this.get_list( panel );
|
| 2809 |
|
| 2810 |
if ( list && list.lastElementChild && list.lastElementChild !== row ) {
|
| 2811 |
this.insert_after( list.lastElementChild, row );
|
| 2812 |
}
|
| 2813 |
this.enforce_single_default( panel, null );
|
| 2814 |
this.commit_options( panel );
|
| 2815 |
this.sync_value_inputs_visibility( panel );
|
| 2816 |
} else if ( 'remove' === action ) {
|
| 2817 |
if ( row && row.parentNode ) row.parentNode.removeChild( row );
|
| 2818 |
this.commit_options( panel );
|
| 2819 |
this.sync_value_inputs_visibility( panel );
|
| 2820 |
}
|
| 2821 |
|
| 2822 |
this.close_dropdown( menu_action );
|
| 2823 |
return;
|
| 2824 |
}
|
| 2825 |
|
| 2826 |
}, true );
|
| 2827 |
|
| 2828 |
|
| 2829 |
// Input delegation.
|
| 2830 |
root.addEventListener( 'input', (e) => {
|
| 2831 |
const panel = get_panel( e.target );
|
| 2832 |
if ( ! panel ) {
|
| 2833 |
return;
|
| 2834 |
}
|
| 2835 |
const ui = this.ui;
|
| 2836 |
const is_label_or_value = e.target.classList?.contains( 'wpbc_bfb__opt-label' ) || e.target.classList?.contains( 'wpbc_bfb__opt-value' );
|
| 2837 |
const is_toggle = e.target.classList?.contains( 'wpbc_bfb__opt-selected-chk' );
|
| 2838 |
const is_multiple = e.target.matches?.( ui.multiple_chk );
|
| 2839 |
const is_default_text = e.target.matches?.( ui.default_text );
|
| 2840 |
const is_value_differs = e.target.matches?.( ui.value_differs_chk );
|
| 2841 |
|
| 2842 |
// Handle "value differs" toggle live
|
| 2843 |
if ( is_value_differs ) {
|
| 2844 |
this.sync_value_inputs_visibility( panel );
|
| 2845 |
this.commit_options( panel );
|
| 2846 |
return;
|
| 2847 |
}
|
| 2848 |
|
| 2849 |
// Track when the user edits VALUE explicitly
|
| 2850 |
if ( e.target.classList?.contains( 'wpbc_bfb__opt-value' ) ) {
|
| 2851 |
const row = e.target.closest( this.ui.row );
|
| 2852 |
this.mark_row_value_user_touched( row );
|
| 2853 |
// Keep the cache updated so toggling OFF/ON later restores the latest custom value
|
| 2854 |
e.target.dataset.cached_value = e.target.value || '';
|
| 2855 |
}
|
| 2856 |
|
| 2857 |
// Auto-fill VALUE from LABEL if value is fresh (and differs is ON); if differs is OFF, we mirror anyway in commit
|
| 2858 |
if ( e.target.classList?.contains( 'wpbc_bfb__opt-label' ) ) {
|
| 2859 |
const row = e.target.closest( ui.row );
|
| 2860 |
const val_in = row?.querySelector( ui.value );
|
| 2861 |
const differs = this.is_value_differs_enabled( panel );
|
| 2862 |
|
| 2863 |
if ( val_in ) {
|
| 2864 |
if ( !differs ) {
|
| 2865 |
// single-input mode: mirror human label with minimal escaping
|
| 2866 |
val_in.value = this.build_value_from_label( e.target.value, false );
|
| 2867 |
} else if ( !this.is_row_value_user_touched( row ) ) {
|
| 2868 |
// separate-value mode, only while fresh
|
| 2869 |
val_in.value = this.build_value_from_label( e.target.value, true );
|
| 2870 |
}
|
| 2871 |
}
|
| 2872 |
}
|
| 2873 |
|
| 2874 |
|
| 2875 |
if ( is_label_or_value || is_toggle || is_multiple ) {
|
| 2876 |
if ( is_toggle ) e.target.setAttribute( 'aria-checked', e.target.checked ? 'true' : 'false' );
|
| 2877 |
if ( is_toggle || is_multiple ) this.enforce_single_default( panel, is_toggle ? e.target : null );
|
| 2878 |
this.commit_options( panel );
|
| 2879 |
}
|
| 2880 |
|
| 2881 |
if ( is_default_text ) {
|
| 2882 |
this.sync_default_value_lock( panel );
|
| 2883 |
this.sync_placeholder_lock( panel );
|
| 2884 |
const holder = this.get_holder( panel );
|
| 2885 |
if ( holder ) {
|
| 2886 |
holder.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 2887 |
holder.dispatchEvent( new Event( 'change', { bubbles: true } ) );
|
| 2888 |
}
|
| 2889 |
}
|
| 2890 |
}, true );
|
| 2891 |
|
| 2892 |
|
| 2893 |
// Change delegation
|
| 2894 |
root.addEventListener( 'change', (e) => {
|
| 2895 |
const panel = get_panel( e.target );
|
| 2896 |
if ( !panel ) return;
|
| 2897 |
|
| 2898 |
const ui = this.ui;
|
| 2899 |
const is_toggle = e.target.classList?.contains( 'wpbc_bfb__opt-selected-chk' );
|
| 2900 |
const is_multi = e.target.matches?.( ui.multiple_chk );
|
| 2901 |
if ( !is_toggle && !is_multi ) return;
|
| 2902 |
|
| 2903 |
if ( is_toggle ) e.target.setAttribute( 'aria-checked', e.target.checked ? 'true' : 'false' );
|
| 2904 |
this.enforce_single_default( panel, is_toggle ? e.target : null );
|
| 2905 |
this.commit_options( panel );
|
| 2906 |
}, true );
|
| 2907 |
|
| 2908 |
// Lazy bootstrap
|
| 2909 |
root.addEventListener( 'mouseenter', (e) => {
|
| 2910 |
const panel = get_panel( e.target );
|
| 2911 |
if ( panel && e.target?.closest?.( this.ui.list ) ) this.bootstrap_panel( panel );
|
| 2912 |
}, true );
|
| 2913 |
|
| 2914 |
root.addEventListener( 'mousedown', (e) => {
|
| 2915 |
const panel = get_panel( e.target );
|
| 2916 |
if ( panel && e.target?.closest?.( this.ui.drag_handle ) ) this.bootstrap_panel( panel );
|
| 2917 |
}, true );
|
| 2918 |
}
|
| 2919 |
|
| 2920 |
};
|
| 2921 |
|
| 2922 |
try { Core.WPBC_BFB_Select_Base.wire_once(); } catch (_) {}
|
| 2923 |
// Try immediately (if root is already in DOM), then again on DOMContentLoaded.
|
| 2924 |
Core.WPBC_BFB_Select_Base.wire_root_listeners();
|
| 2925 |
|
| 2926 |
document.addEventListener('DOMContentLoaded', () => { Core.WPBC_BFB_Select_Base.wire_root_listeners(); });
|
| 2927 |
|
| 2928 |
}( window )); |
| 2929 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 2930 |
// == File /includes/page-form-builder/_out/core/bfb-ui.js == | 2025-09-10 15:47
|
| 2931 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 2932 |
(function (w, d) {
|
| 2933 |
'use strict';
|
| 2934 |
|
| 2935 |
// Single global namespace (idempotent & load-order safe).
|
| 2936 |
const Core = (w.WPBC_BFB_Core = w.WPBC_BFB_Core || {});
|
| 2937 |
const UI = (Core.UI = Core.UI || {});
|
| 2938 |
|
| 2939 |
// --- Highlight Element, like Generator brn - Tiny UI helpers ------------------------------------
|
| 2940 |
UI._pulse_timers = UI._pulse_timers || new Map(); // el -> timer_id
|
| 2941 |
UI._pulse_meta = UI._pulse_meta || new Map(); // el -> { token, last_ts, debounce_id, color_set }
|
| 2942 |
// Pulse tuning (milliseconds).
|
| 2943 |
UI.PULSE_THROTTLE_MS = Number.isFinite( UI.PULSE_THROTTLE_MS ) ? UI.PULSE_THROTTLE_MS : 500;
|
| 2944 |
UI.PULSE_DEBOUNCE_MS = Number.isFinite( UI.PULSE_DEBOUNCE_MS ) ? UI.PULSE_DEBOUNCE_MS : 750;
|
| 2945 |
|
| 2946 |
// Debounce STRUCTURE_CHANGE for continuous inspector controls (sliders / scrubbing).
|
| 2947 |
// Tune: 180..350 is usually a sweet spot.
|
| 2948 |
UI.STRUCTURE_CHANGE_DEBOUNCE_MS = Number.isFinite( UI.STRUCTURE_CHANGE_DEBOUNCE_MS ) ? UI.STRUCTURE_CHANGE_DEBOUNCE_MS : 180;
|
| 2949 |
// Change this to tune speed: 50..120 ms is a good range. Can be configured in <div data-len-group data-len-throttle="180">...</div>.
|
| 2950 |
UI.VALUE_SLIDER_THROTTLE_MS = Number.isFinite( UI.VALUE_SLIDER_THROTTLE_MS ) ? UI.VALUE_SLIDER_THROTTLE_MS : 120;
|
| 2951 |
|
| 2952 |
/**
|
| 2953 |
* Cancel any running pulse sequence for an element.
|
| 2954 |
* Uses token invalidation so already-scheduled callbacks become no-ops.
|
| 2955 |
*
|
| 2956 |
* @param {HTMLElement} el
|
| 2957 |
*/
|
| 2958 |
UI.cancel_pulse = function (el) {
|
| 2959 |
if ( !el ) { return; }
|
| 2960 |
try {
|
| 2961 |
clearTimeout( UI._pulse_timers.get( el ) );
|
| 2962 |
} catch ( _ ) {}
|
| 2963 |
UI._pulse_timers.delete( el );
|
| 2964 |
|
| 2965 |
var meta = UI._pulse_meta.get( el ) || {};
|
| 2966 |
meta.token = (Number.isFinite( meta.token ) ? meta.token : 0) + 1;
|
| 2967 |
meta.color_set = false;
|
| 2968 |
try { el.classList.remove( 'wpbc_bfb__scroll-pulse', 'wpbc_bfb__highlight-pulse' ); } catch ( _ ) {}
|
| 2969 |
try { el.style.removeProperty( '--wpbc-bfb-pulse-color' ); } catch ( _ ) {}
|
| 2970 |
UI._pulse_meta.set( el, meta );
|
| 2971 |
try { clearTimeout( meta.debounce_id ); } catch ( _ ) {}
|
| 2972 |
meta.debounce_id = 0;
|
| 2973 |
};
|
| 2974 |
|
| 2975 |
/**
|
| 2976 |
* Force-restart a CSS animation on a class.
|
| 2977 |
* @param {HTMLElement} el
|
| 2978 |
* @param {string} cls
|
| 2979 |
*/
|
| 2980 |
UI._restart_css_animation = function (el, cls) {
|
| 2981 |
if ( ! el ) { return; }
|
| 2982 |
try {
|
| 2983 |
el.classList.remove( cls );
|
| 2984 |
} catch ( _ ) {}
|
| 2985 |
// Force reflow so the next add() retriggers the keyframes.
|
| 2986 |
void el.offsetWidth;
|
| 2987 |
try {
|
| 2988 |
el.classList.add( cls );
|
| 2989 |
} catch ( _ ) {}
|
| 2990 |
};
|
| 2991 |
|
| 2992 |
/**
|
| 2993 |
Single pulse (back-compat).
|
| 2994 |
@param {HTMLElement} el
|
| 2995 |
@param {number} dur_ms
|
| 2996 |
*/
|
| 2997 |
UI.pulse_once = function (el, dur_ms) {
|
| 2998 |
if ( ! el ) { return; }
|
| 2999 |
var cls = 'wpbc_bfb__scroll-pulse';
|
| 3000 |
var ms = Number.isFinite( dur_ms ) ? dur_ms : 700;
|
| 3001 |
|
| 3002 |
UI.cancel_pulse( el );
|
| 3003 |
|
| 3004 |
var meta = UI._pulse_meta.get( el ) || {};
|
| 3005 |
var token = (Number.isFinite( meta.token ) ? meta.token : 0) + 1;
|
| 3006 |
meta.token = token;
|
| 3007 |
UI._pulse_meta.set( el, meta );
|
| 3008 |
|
| 3009 |
UI._restart_css_animation( el, cls );
|
| 3010 |
var t = setTimeout( function () {
|
| 3011 |
// ignore if a newer pulse started.
|
| 3012 |
var m = UI._pulse_meta.get( el ) || {};
|
| 3013 |
if ( m.token !== token ) { return; }
|
| 3014 |
try {
|
| 3015 |
el.classList.remove( cls );
|
| 3016 |
} catch ( _ ) {}
|
| 3017 |
UI._pulse_timers.delete( el );
|
| 3018 |
}, ms );
|
| 3019 |
UI._pulse_timers.set( el, t );
|
| 3020 |
};
|
| 3021 |
|
| 3022 |
/**
|
| 3023 |
Multi-blink sequence with optional per-call color override.
|
| 3024 |
@param {HTMLElement} el
|
| 3025 |
@param {number} [times=3]
|
| 3026 |
@param {number} [on_ms=280]
|
| 3027 |
@param {number} [off_ms=180]
|
| 3028 |
@param {string} [hex_color] Optional CSS color (e.g. '#ff4d4f' or 'rgb(...)').
|
| 3029 |
*/
|
| 3030 |
UI.pulse_sequence = function (el, times, on_ms, off_ms, hex_color) {
|
| 3031 |
if ( !el || !d.body.contains( el ) ) {
|
| 3032 |
return;
|
| 3033 |
}
|
| 3034 |
var cls = 'wpbc_bfb__highlight-pulse';
|
| 3035 |
var count = Number.isFinite( times ) ? times : 2;
|
| 3036 |
var on = Number.isFinite( on_ms ) ? on_ms : 280;
|
| 3037 |
var off = Number.isFinite( off_ms ) ? off_ms : 180;
|
| 3038 |
|
| 3039 |
// Throttle: avoid reflow spam if called repeatedly while typing/dragging.
|
| 3040 |
var meta = UI._pulse_meta.get( el ) || {};
|
| 3041 |
var now = Date.now();
|
| 3042 |
var throttle_ms = Number.isFinite( UI.PULSE_THROTTLE_MS ) ? UI.PULSE_THROTTLE_MS : 120;
|
| 3043 |
if ( Number.isFinite( meta.last_ts ) && (now - meta.last_ts) < throttle_ms ) {
|
| 3044 |
return;
|
| 3045 |
}
|
| 3046 |
meta.last_ts = now;
|
| 3047 |
|
| 3048 |
// cancel any running pulse and reset class (token invalidation).
|
| 3049 |
UI.cancel_pulse( el );
|
| 3050 |
|
| 3051 |
// new token for this run
|
| 3052 |
var token = (Number.isFinite( meta.token ) ? meta.token : 0) + 1;
|
| 3053 |
meta.token = token;
|
| 3054 |
|
| 3055 |
var have_color = !!hex_color && typeof hex_color === 'string';
|
| 3056 |
if ( have_color ) {
|
| 3057 |
try {
|
| 3058 |
el.style.setProperty( '--wpbc-bfb-pulse-color', hex_color );
|
| 3059 |
} catch ( _ ) {}
|
| 3060 |
meta.color_set = true;
|
| 3061 |
}
|
| 3062 |
UI._pulse_meta.set( el, meta );
|
| 3063 |
|
| 3064 |
var i = 0;
|
| 3065 |
(function tick() {
|
| 3066 |
var m = UI._pulse_meta.get( el ) || {};
|
| 3067 |
if ( m.token !== token ) {
|
| 3068 |
// canceled/replaced
|
| 3069 |
return;
|
| 3070 |
}
|
| 3071 |
if ( i >= count ) {
|
| 3072 |
UI._pulse_timers.delete( el );
|
| 3073 |
if ( have_color ) {
|
| 3074 |
try {
|
| 3075 |
el.style.removeProperty( '--wpbc-bfb-pulse-color' );
|
| 3076 |
} catch ( _ ) {}
|
| 3077 |
}
|
| 3078 |
return;
|
| 3079 |
}
|
| 3080 |
UI._restart_css_animation( el, cls );
|
| 3081 |
UI._pulse_timers.set( el, setTimeout( function () { // ON -> OFF
|
| 3082 |
var m2 = UI._pulse_meta.get( el ) || {};
|
| 3083 |
if ( m2.token !== token ) { return; }
|
| 3084 |
try {
|
| 3085 |
el.classList.remove( cls );
|
| 3086 |
} catch ( _ ) {
|
| 3087 |
}
|
| 3088 |
UI._pulse_timers.set( el, setTimeout( function () { // OFF gap -> next
|
| 3089 |
var m3 = UI._pulse_meta.get( el ) || {};
|
| 3090 |
if ( m3.token !== token ) { return; }
|
| 3091 |
i++;
|
| 3092 |
tick();
|
| 3093 |
}, off ) );
|
| 3094 |
}, on ) );
|
| 3095 |
})();
|
| 3096 |
};
|
| 3097 |
|
| 3098 |
|
| 3099 |
/**
|
| 3100 |
* Debounced query + pulse.
|
| 3101 |
* Useful for `input` events (sliders / typing) to avoid forced reflow spam.
|
| 3102 |
*
|
| 3103 |
* @param {HTMLElement|string} root_or_selector
|
| 3104 |
* @param {string} selector
|
| 3105 |
* @param {number} wait_ms
|
| 3106 |
* @param {number} [a]
|
| 3107 |
* @param {number} [b]
|
| 3108 |
* @param {number} [c]
|
| 3109 |
* @param {string} [color]
|
| 3110 |
*/
|
| 3111 |
UI.pulse_query_debounced = function (root_or_selector, selector, wait_ms, a, b, c, color) {
|
| 3112 |
var root = (typeof root_or_selector === 'string') ? d : (root_or_selector || d);
|
| 3113 |
var sel = (typeof root_or_selector === 'string') ? root_or_selector : selector;
|
| 3114 |
if ( !sel ) { return; }
|
| 3115 |
var el = root.querySelector( sel );
|
| 3116 |
if ( !el ) { return; }
|
| 3117 |
|
| 3118 |
var def_ms = Number.isFinite( UI.PULSE_DEBOUNCE_MS ) ? UI.PULSE_DEBOUNCE_MS : 120;
|
| 3119 |
var ms = Number.isFinite( wait_ms ) ? wait_ms : def_ms;
|
| 3120 |
var meta = UI._pulse_meta.get( el ) || {};
|
| 3121 |
try { clearTimeout( meta.debounce_id ); } catch ( _ ) {}
|
| 3122 |
meta.debounce_id = setTimeout( function () {
|
| 3123 |
UI.pulse_sequence( el, a, b, c, color );
|
| 3124 |
}, ms );
|
| 3125 |
UI._pulse_meta.set( el, meta );
|
| 3126 |
};
|
| 3127 |
|
| 3128 |
/**
|
| 3129 |
Query + pulse:
|
| 3130 |
(BC) If only 3rd arg is a number and no 4th/5th -> single long pulse.
|
| 3131 |
Otherwise -> strong sequence (defaults 3×280/180).
|
| 3132 |
Optional 6th arg: color.
|
| 3133 |
@param {HTMLElement|string} root_or_selector
|
| 3134 |
@param {string} [selector]
|
| 3135 |
@param {number} [a]
|
| 3136 |
@param {number} [b]
|
| 3137 |
|
| 3138 |
@param {number} [c]
|
| 3139 |
|
| 3140 |
@param {string} [color]
|
| 3141 |
*/
|
| 3142 |
UI.pulse_query = function (root_or_selector, selector, a, b, c, color) {
|
| 3143 |
var root = (typeof root_or_selector === 'string') ? d : (root_or_selector || d);
|
| 3144 |
var sel = (typeof root_or_selector === 'string') ? root_or_selector : selector;
|
| 3145 |
if ( !sel ) {
|
| 3146 |
return;
|
| 3147 |
}
|
| 3148 |
|
| 3149 |
var el = root.querySelector( sel );
|
| 3150 |
if ( !el ) {
|
| 3151 |
return;
|
| 3152 |
}
|
| 3153 |
|
| 3154 |
// Back-compat: UI.pulseQuery(root, sel, dur_ms)
|
| 3155 |
if ( Number.isFinite( a ) && b === undefined && c === undefined ) {
|
| 3156 |
return UI.pulse_once( el, a );
|
| 3157 |
}
|
| 3158 |
// New: sequence; params optional; supports optional color.
|
| 3159 |
UI.pulse_sequence( el, a, b, c, color );
|
| 3160 |
};
|
| 3161 |
|
| 3162 |
/**
|
| 3163 |
Convenience helper (snake_case) to call a strong pulse with options.
|
| 3164 |
|
| 3165 |
@param {HTMLElement} el
|
| 3166 |
|
| 3167 |
@param {Object} [opts]
|
| 3168 |
|
| 3169 |
@param {number} [opts.times=3]
|
| 3170 |
|
| 3171 |
@param {number} [opts.on_ms=280]
|
| 3172 |
|
| 3173 |
@param {number} [opts.off_ms=180]
|
| 3174 |
|
| 3175 |
@param {string} [opts.color]
|
| 3176 |
*/
|
| 3177 |
UI.pulse_sequence_strong = function (el, opts) {
|
| 3178 |
opts = opts || {};
|
| 3179 |
UI.pulse_sequence(
|
| 3180 |
el,
|
| 3181 |
Number.isFinite( opts.times ) ? opts.times : 3,
|
| 3182 |
Number.isFinite( opts.on_ms ) ? opts.on_ms : 280,
|
| 3183 |
Number.isFinite( opts.off_ms ) ? opts.off_ms : 180,
|
| 3184 |
opts.color
|
| 3185 |
);
|
| 3186 |
};
|
| 3187 |
|
| 3188 |
|
| 3189 |
/**
|
| 3190 |
* Base class for BFB modules.
|
| 3191 |
*/
|
| 3192 |
UI.WPBC_BFB_Module = class {
|
| 3193 |
/** @param {WPBC_Form_Builder} builder */
|
| 3194 |
constructor(builder) {
|
| 3195 |
this.builder = builder;
|
| 3196 |
}
|
| 3197 |
|
| 3198 |
/** Initialize the module. */
|
| 3199 |
init() {
|
| 3200 |
}
|
| 3201 |
|
| 3202 |
/** Cleanup the module. */
|
| 3203 |
destroy() {
|
| 3204 |
}
|
| 3205 |
};
|
| 3206 |
|
| 3207 |
/**
|
| 3208 |
* Central overlay/controls manager for fields/sections.
|
| 3209 |
* Pure UI composition; all actions route back into the builder instance.
|
| 3210 |
*/
|
| 3211 |
UI.WPBC_BFB_Overlay = class { |
| 3212 |
|
| 3213 |
/** |
| 3214 |
* Synchronize every overlay settings button with the real Inspector state. |
| 3215 |
* |
| 3216 |
* A selected canvas item can remain selected while another right-bar panel is |
| 3217 |
* visible. Combining both states prevents a stale pressed button after the |
| 3218 |
* administrator switches away from the Inspector. |
| 3219 |
* |
| 3220 |
* @param {WPBC_Form_Builder} builder - Active Form Builder instance. |
| 3221 |
* @param {HTMLButtonElement[]|NodeListOf<HTMLButtonElement>|null} [settings_buttons=null] |
| 3222 |
* Optional bounded controls to reconcile during incremental rendering. |
| 3223 |
* @returns {void} |
| 3224 |
*/ |
| 3225 |
static sync_settings_button_states(builder, settings_buttons = null) { |
| 3226 |
|
| 3227 |
const pages_container = builder?.pages_container; |
| 3228 |
if ( !pages_container?.querySelectorAll ) { |
| 3229 |
return; |
| 3230 |
} |
| 3231 |
|
| 3232 |
const inspector = document.getElementById( 'wpbc_bfb__inspector' ); |
| 3233 |
const inspector_is_open = !!inspector |
| 3234 |
&& !inspector.hasAttribute( 'hidden' ) |
| 3235 |
&& inspector.getAttribute( 'aria-hidden' ) !== 'true'; |
| 3236 |
const selectable_query = `${Core.WPBC_BFB_DOM.SELECTORS.field}, ${Core.WPBC_BFB_DOM.SELECTORS.section}`; |
| 3237 |
|
| 3238 |
const buttons = settings_buttons || pages_container.querySelectorAll( '.wpbc_bfb__settings-btn' ); |
| 3239 |
|
| 3240 |
Array.from( buttons ).forEach( (settings_button) => { |
| 3241 |
const owner = settings_button.closest( selectable_query ); |
| 3242 |
const is_pressed = inspector_is_open |
| 3243 |
&& !!owner?.classList?.contains( Core.WPBC_BFB_DOM.CLASSES.selected ); |
| 3244 |
|
| 3245 |
settings_button.setAttribute( 'aria-pressed', is_pressed ? 'true' : 'false' ); |
| 3246 |
} ); |
| 3247 |
} |
| 3248 |
|
| 3249 |
/** |
| 3250 |
* Ensure an overlay exists and is wired up on the element. |
| 3251 |
* @param {WPBC_Form_Builder} builder
|
| 3252 |
* @param {HTMLElement} el - field or section element
|
| 3253 |
*/
|
| 3254 |
static ensure(builder, el) {
|
| 3255 |
|
| 3256 |
if ( !el ) {
|
| 3257 |
return;
|
| 3258 |
}
|
| 3259 |
const isSection = el.classList.contains( 'wpbc_bfb__section' );
|
| 3260 |
|
| 3261 |
// let overlay = el.querySelector( Core.WPBC_BFB_DOM.SELECTORS.overlay );
|
| 3262 |
let overlay = el.querySelector( `:scope > ${Core.WPBC_BFB_DOM.SELECTORS.overlay}` );
|
| 3263 |
if ( !overlay ) {
|
| 3264 |
overlay = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__overlay-controls' );
|
| 3265 |
el.prepend( overlay );
|
| 3266 |
}
|
| 3267 |
|
| 3268 |
// Drag handle.
|
| 3269 |
if ( !overlay.querySelector( '.wpbc_bfb__drag-handle' ) ) {
|
| 3270 |
const dragClass = isSection ? 'wpbc_bfb__drag-handle section-drag-handle' : 'wpbc_bfb__drag-handle';
|
| 3271 |
overlay.appendChild(
|
| 3272 |
Core.WPBC_Form_Builder_Helper.create_element( 'span', dragClass, '<span class="wpbc_icn_drag_indicator"></span>' )
|
| 3273 |
);
|
| 3274 |
} |
| 3275 |
|
| 3276 |
// SETTINGS button (shown for both fields & sections). |
| 3277 |
let settings_btn = overlay.querySelector( '.wpbc_bfb__settings-btn' ); |
| 3278 |
if ( !settings_btn ) { |
| 3279 |
settings_btn = Core.WPBC_Form_Builder_Helper.create_element( 'button', 'wpbc_bfb__settings-btn', '<i class="menu_icon icon-1x wpbc_icn_near_me wpbc_icn_rotate_270"></i>' ); |
| 3280 |
settings_btn.type = 'button'; |
| 3281 |
settings_btn.title = 'Open settings'; |
| 3282 |
settings_btn.setAttribute( 'aria-label', settings_btn.title ); |
| 3283 |
settings_btn.setAttribute( 'aria-controls', 'wpbc_bfb__inspector' ); |
| 3284 |
settings_btn.setAttribute( 'aria-pressed', 'false' ); |
| 3285 |
settings_btn.onclick = (e) => { |
| 3286 |
e.preventDefault();
|
| 3287 |
// Select THIS element and scroll it into view.
|
| 3288 |
builder.select_field( el, { scrollIntoView: true } );
|
| 3289 |
|
| 3290 |
// Auto-open Inspector from the overlay “Settings” button.
|
| 3291 |
wpbc_bfb__dispatch_event_safe(
|
| 3292 |
'wpbc_bfb:show_panel',
|
| 3293 |
{
|
| 3294 |
panel_id: 'wpbc_bfb__inspector',
|
| 3295 |
tab_id : 'wpbc_tab_inspector'
|
| 3296 |
}
|
| 3297 |
);
|
| 3298 |
|
| 3299 |
// Try to bring the inspector into view / focus first input.
|
| 3300 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 3301 |
if ( ins ) {
|
| 3302 |
ins.scrollIntoView( { behavior: 'smooth', block: 'nearest' } );
|
| 3303 |
// Focus first interactive control (best-effort).
|
| 3304 |
setTimeout( () => {
|
| 3305 |
const focusable = ins.querySelector( 'input,select,textarea,button,[contenteditable],[tabindex]:not([tabindex="-1"])' );
|
| 3306 |
focusable?.focus?.();
|
| 3307 |
}, 260 );
|
| 3308 |
}
|
| 3309 |
};
|
| 3310 |
|
| 3311 |
overlay.appendChild( settings_btn );
|
| 3312 |
}
|
| 3313 |
|
| 3314 |
overlay.setAttribute( 'role', 'toolbar' ); |
| 3315 |
overlay.setAttribute( 'aria-label', el.classList.contains( 'wpbc_bfb__section' ) ? 'Section tools' : 'Field tools' ); |
| 3316 |
UI.WPBC_BFB_Overlay.sync_settings_button_states( builder, [ settings_btn ] ); |
| 3317 |
|
| 3318 |
return overlay; |
| 3319 |
}
|
| 3320 |
};
|
| 3321 |
|
| 3322 |
/**
|
| 3323 |
* WPBC Layout Chips helper - visual layout picker (chips), e.g., "50%/50%", to a section overlay.
|
| 3324 |
*
|
| 3325 |
* Renders Equal/Presets/Custom chips into a host container and wires them to apply the layout.
|
| 3326 |
*/
|
| 3327 |
UI.WPBC_BFB_Layout_Chips = class {
|
| 3328 |
|
| 3329 |
/** Read per-column min (px) from CSS var set by the guard. */
|
| 3330 |
static _get_col_min_px(col) {
|
| 3331 |
const v = getComputedStyle( col ).getPropertyValue( '--wpbc-col-min' ) || '0';
|
| 3332 |
const n = parseFloat( v );
|
| 3333 |
return Number.isFinite( n ) ? Math.max( 0, n ) : 0;
|
| 3334 |
}
|
| 3335 |
|
| 3336 |
/**
|
| 3337 |
* Turn raw weights (e.g. [1,1], [2,1,1]) into effective "available-%" bases that
|
| 3338 |
* (a) sum to the row's available %, and (b) meet every column's min px.
|
| 3339 |
* Returns an array of bases (numbers) or null if impossible to satisfy mins.
|
| 3340 |
*/
|
| 3341 |
static _fit_weights_respecting_min(builder, row, weights) {
|
| 3342 |
const cols = Array.from( row.querySelectorAll( ':scope > .wpbc_bfb__column' ) );
|
| 3343 |
const n = cols.length;
|
| 3344 |
if ( !n ) return null;
|
| 3345 |
if ( !Array.isArray( weights ) || weights.length !== n ) return null;
|
| 3346 |
|
| 3347 |
// available % after gaps (from LayoutService)
|
| 3348 |
const gp = builder.col_gap_percent;
|
| 3349 |
const eff = builder.layout.compute_effective_bases_from_row( row, gp );
|
| 3350 |
const availPct = eff.available; // e.g. 94 if 2 cols and 3% gap
|
| 3351 |
const rowPx = row.getBoundingClientRect().width;
|
| 3352 |
const availPx = rowPx * (availPct / 100);
|
| 3353 |
|
| 3354 |
// collect minima in % of "available"
|
| 3355 |
const minPct = cols.map( (c) => {
|
| 3356 |
const minPx = UI.WPBC_BFB_Layout_Chips._get_col_min_px( c );
|
| 3357 |
if ( availPx <= 0 ) return 0;
|
| 3358 |
return (minPx / availPx) * availPct;
|
| 3359 |
} );
|
| 3360 |
|
| 3361 |
// If mins alone don't fit, bail.
|
| 3362 |
const sumMin = minPct.reduce( (a, b) => a + b, 0 );
|
| 3363 |
if ( sumMin > availPct - 1e-6 ) {
|
| 3364 |
return null; // impossible to respect mins; don't apply preset
|
| 3365 |
}
|
| 3366 |
|
| 3367 |
// Target percentages from weights, normalized to availPct.
|
| 3368 |
const wSum = weights.reduce( (a, w) => a + (Number( w ) || 0), 0 ) || n;
|
| 3369 |
const targetPct = weights.map( (w) => ((Number( w ) || 0) / wSum) * availPct );
|
| 3370 |
|
| 3371 |
// Lock columns that would be below min, then distribute the remainder
|
| 3372 |
// across the remaining columns proportionally to their targetPct.
|
| 3373 |
const locked = new Array( n ).fill( false );
|
| 3374 |
let lockedSum = 0;
|
| 3375 |
for ( let i = 0; i < n; i++ ) {
|
| 3376 |
if ( targetPct[i] < minPct[i] ) {
|
| 3377 |
locked[i] = true;
|
| 3378 |
lockedSum += minPct[i];
|
| 3379 |
}
|
| 3380 |
}
|
| 3381 |
|
| 3382 |
let remaining = availPct - lockedSum;
|
| 3383 |
const freeIdx = [];
|
| 3384 |
let freeTargetSum = 0;
|
| 3385 |
for ( let i = 0; i < n; i++ ) {
|
| 3386 |
if ( !locked[i] ) {
|
| 3387 |
freeIdx.push( i );
|
| 3388 |
freeTargetSum += targetPct[i];
|
| 3389 |
}
|
| 3390 |
}
|
| 3391 |
|
| 3392 |
const result = new Array( n ).fill( 0 );
|
| 3393 |
// Seed locked with their minima.
|
| 3394 |
for ( let i = 0; i < n; i++ ) {
|
| 3395 |
if ( locked[i] ) result[i] = minPct[i];
|
| 3396 |
}
|
| 3397 |
|
| 3398 |
if ( freeIdx.length === 0 ) {
|
| 3399 |
// everything locked exactly at min; any leftover (shouldn't happen)
|
| 3400 |
// would be ignored to keep simplicity and stability.
|
| 3401 |
return result;
|
| 3402 |
}
|
| 3403 |
|
| 3404 |
if ( remaining <= 0 ) {
|
| 3405 |
// nothing left to distribute; keep exactly mins on locked,
|
| 3406 |
// nothing for free (degenerate but consistent)
|
| 3407 |
return result;
|
| 3408 |
}
|
| 3409 |
|
| 3410 |
if ( freeTargetSum <= 0 ) {
|
| 3411 |
// distribute equally among free columns
|
| 3412 |
const each = remaining / freeIdx.length;
|
| 3413 |
freeIdx.forEach( (i) => (result[i] = each) );
|
| 3414 |
return result;
|
| 3415 |
}
|
| 3416 |
|
| 3417 |
// Distribute remaining proportionally to free columns' targetPct
|
| 3418 |
freeIdx.forEach( (i) => {
|
| 3419 |
result[i] = remaining * (targetPct[i] / freeTargetSum);
|
| 3420 |
} );
|
| 3421 |
return result;
|
| 3422 |
}
|
| 3423 |
|
| 3424 |
/** Apply a preset but guard it by minima; returns true if applied, false if skipped. */
|
| 3425 |
static _apply_preset_with_min_guard(builder, section_el, weights) {
|
| 3426 |
const row = section_el.querySelector( ':scope > .wpbc_bfb__row' );
|
| 3427 |
if ( !row ) return false;
|
| 3428 |
|
| 3429 |
const fitted = UI.WPBC_BFB_Layout_Chips._fit_weights_respecting_min( builder, row, weights );
|
| 3430 |
if ( !fitted ) {
|
| 3431 |
builder?._announce?.( 'Not enough space for this layout because of fields’ minimum widths.' );
|
| 3432 |
return false;
|
| 3433 |
}
|
| 3434 |
|
| 3435 |
// `fitted` already sums to the row’s available %, so we can apply bases directly.
|
| 3436 |
builder.layout.apply_bases_to_row( row, fitted );
|
| 3437 |
return true;
|
| 3438 |
}
|
| 3439 |
|
| 3440 |
|
| 3441 |
/**
|
| 3442 |
* Build and append layout chips for a section.
|
| 3443 |
*
|
| 3444 |
* @param {WPBC_Form_Builder} builder - The form builder instance.
|
| 3445 |
* @param {HTMLElement} section_el - The .wpbc_bfb__section element.
|
| 3446 |
* @param {HTMLElement} host_el - Container where chips should be rendered.
|
| 3447 |
* @returns {void}
|
| 3448 |
*/
|
| 3449 |
static render_for_section(builder, section_el, host_el) {
|
| 3450 |
|
| 3451 |
if ( !builder || !section_el || !host_el ) {
|
| 3452 |
return;
|
| 3453 |
}
|
| 3454 |
|
| 3455 |
const row = section_el.querySelector( ':scope > .wpbc_bfb__row' );
|
| 3456 |
if ( !row ) {
|
| 3457 |
return;
|
| 3458 |
}
|
| 3459 |
|
| 3460 |
const cols = row.querySelectorAll( ':scope > .wpbc_bfb__column' ).length || 1;
|
| 3461 |
|
| 3462 |
// Clear host.
|
| 3463 |
host_el.innerHTML = '';
|
| 3464 |
|
| 3465 |
// Equal chip.
|
| 3466 |
host_el.appendChild(
|
| 3467 |
UI.WPBC_BFB_Layout_Chips._make_chip( builder, section_el, Array( cols ).fill( 1 ), 'Equal' )
|
| 3468 |
);
|
| 3469 |
|
| 3470 |
// Presets based on column count.
|
| 3471 |
const presets = builder.layout.build_presets_for_columns( cols );
|
| 3472 |
presets.forEach( (weights) => {
|
| 3473 |
host_el.appendChild(
|
| 3474 |
UI.WPBC_BFB_Layout_Chips._make_chip( builder, section_el, weights, null )
|
| 3475 |
);
|
| 3476 |
} );
|
| 3477 |
|
| 3478 |
// Custom chip.
|
| 3479 |
const customBtn = document.createElement( 'button' );
|
| 3480 |
customBtn.type = 'button';
|
| 3481 |
customBtn.className = 'wpbc_bfb__layout_chip';
|
| 3482 |
customBtn.textContent = 'Custom…';
|
| 3483 |
customBtn.title = `Enter ${cols} percentages`;
|
| 3484 |
customBtn.addEventListener( 'click', () => {
|
| 3485 |
const example = (cols === 2) ? '50,50' : (cols === 3 ? '20,60,20' : '25,25,25,25');
|
| 3486 |
const text = prompt( `Enter ${cols} percentages (comma or space separated):`, example );
|
| 3487 |
if ( text == null ) return;
|
| 3488 |
const weights = builder.layout.parse_weights( text );
|
| 3489 |
if ( weights.length !== cols ) {
|
| 3490 |
alert( `Please enter exactly ${cols} numbers.` );
|
| 3491 |
return;
|
| 3492 |
}
|
| 3493 |
// OLD:
|
| 3494 |
// builder.layout.apply_layout_preset( section_el, weights, builder.col_gap_percent );
|
| 3495 |
// Guarded apply:.
|
| 3496 |
if ( !UI.WPBC_BFB_Layout_Chips._apply_preset_with_min_guard( builder, section_el, weights ) ) {
|
| 3497 |
return;
|
| 3498 |
}
|
| 3499 |
host_el.querySelectorAll( '.wpbc_bfb__layout_chip' ).forEach( c => c.classList.remove( 'is-active' ) );
|
| 3500 |
customBtn.classList.add( 'is-active' );
|
| 3501 |
} );
|
| 3502 |
host_el.appendChild( customBtn );
|
| 3503 |
}
|
| 3504 |
|
| 3505 |
/**
|
| 3506 |
* Create a single layout chip button.
|
| 3507 |
*
|
| 3508 |
* @private
|
| 3509 |
* @param {WPBC_Form_Builder} builder
|
| 3510 |
* @param {HTMLElement} section_el
|
| 3511 |
* @param {number[]} weights
|
| 3512 |
* @param {string|null} label
|
| 3513 |
* @returns {HTMLButtonElement}
|
| 3514 |
*/
|
| 3515 |
static _make_chip(builder, section_el, weights, label = null) {
|
| 3516 |
|
| 3517 |
const btn = document.createElement( 'button' );
|
| 3518 |
btn.type = 'button';
|
| 3519 |
btn.className = 'wpbc_bfb__layout_chip';
|
| 3520 |
|
| 3521 |
const title = label || builder.layout.format_preset_label( weights );
|
| 3522 |
btn.title = title;
|
| 3523 |
|
| 3524 |
// Visual miniature.
|
| 3525 |
const vis = document.createElement( 'div' );
|
| 3526 |
vis.className = 'wpbc_bfb__layout_chip-vis';
|
| 3527 |
const sum = weights.reduce( (a, b) => a + (Number( b ) || 0), 0 ) || 1;
|
| 3528 |
weights.forEach( (w) => {
|
| 3529 |
const bar = document.createElement( 'span' );
|
| 3530 |
bar.style.flex = `0 0 calc( ${((Number( w ) || 0) / sum * 100).toFixed( 3 )}% - 1.5px )`;
|
| 3531 |
vis.appendChild( bar );
|
| 3532 |
} );
|
| 3533 |
btn.appendChild( vis );
|
| 3534 |
|
| 3535 |
const txt = document.createElement( 'span' );
|
| 3536 |
txt.className = 'wpbc_bfb__layout_chip-label';
|
| 3537 |
txt.textContent = label || builder.layout.format_preset_label( weights );
|
| 3538 |
btn.appendChild( txt );
|
| 3539 |
|
| 3540 |
btn.addEventListener( 'click', () => {
|
| 3541 |
// OLD:
|
| 3542 |
// builder.layout.apply_layout_preset( section_el, weights, builder.col_gap_percent );
|
| 3543 |
|
| 3544 |
// NEW:
|
| 3545 |
if ( !UI.WPBC_BFB_Layout_Chips._apply_preset_with_min_guard( builder, section_el, weights ) ) {
|
| 3546 |
return; // do not toggle active if we didn't change layout
|
| 3547 |
}
|
| 3548 |
|
| 3549 |
btn.parentElement?.querySelectorAll( '.wpbc_bfb__layout_chip' ).forEach( c => c.classList.remove( 'is-active' ) );
|
| 3550 |
btn.classList.add( 'is-active' );
|
| 3551 |
} );
|
| 3552 |
|
| 3553 |
return btn;
|
| 3554 |
}
|
| 3555 |
};
|
| 3556 |
|
| 3557 |
/**
|
| 3558 |
* Selection controller for fields and announcements.
|
| 3559 |
*/
|
| 3560 |
UI.WPBC_BFB_Selection_Controller = class extends UI.WPBC_BFB_Module {
|
| 3561 |
|
| 3562 |
init() {
|
| 3563 |
|
| 3564 |
this._selected_uid = null;
|
| 3565 |
this.builder.select_field = this.select_field.bind( this );
|
| 3566 |
this.builder.get_selected_field = this.get_selected_field.bind( this ); |
| 3567 |
this._on_clear = this.on_clear.bind( this ); |
| 3568 |
this._on_panel_shown = this._sync_settings_button_states.bind( this ); |
| 3569 |
|
| 3570 |
// Centralized delete command used by keyboard + inspector + overlay.
|
| 3571 |
this.builder.delete_item = (el) => {
|
| 3572 |
if ( !el ) {
|
| 3573 |
return null;
|
| 3574 |
}
|
| 3575 |
const b = this.builder;
|
| 3576 |
const neighbor = b._find_neighbor_selectable?.( el ) || null;
|
| 3577 |
el.remove();
|
| 3578 |
// Use local Core constants (not a global) to avoid ReferenceErrors.
|
| 3579 |
b.bus?.emit?.( Core.WPBC_BFB_Events.FIELD_REMOVE, { el, id: el?.dataset?.id, uid: el?.dataset?.uid } );
|
| 3580 |
b.usage?.update_palette_ui?.();
|
| 3581 |
// Notify generic structure listeners, too:
|
| 3582 |
b.bus?.emit?.( Core.WPBC_BFB_Events.STRUCTURE_CHANGE, { reason: 'delete', el } );
|
| 3583 |
// Defer selection a tick so the DOM is fully settled before Inspector hydrates.
|
| 3584 |
requestAnimationFrame( () => {
|
| 3585 |
// This calls inspector.bind_to_field() and opens the Inspector panel.
|
| 3586 |
b.select_field?.( neighbor || null, { scrollIntoView: !!neighbor } );
|
| 3587 |
} );
|
| 3588 |
return neighbor;
|
| 3589 |
};
|
| 3590 |
this.builder.bus.on( Core.WPBC_BFB_Events.CLEAR_SELECTION, this._on_clear );
|
| 3591 |
this.builder.bus.on( Core.WPBC_BFB_Events.STRUCTURE_LOADED, this._on_clear );
|
| 3592 |
// delegated click selection (capture ensures we win before bubbling to containers).
|
| 3593 |
this._on_canvas_click = this._handle_canvas_click.bind( this ); |
| 3594 |
this.builder.pages_container.addEventListener( 'click', this._on_canvas_click, true ); |
| 3595 |
document.addEventListener( 'wpbc_bfb:panel_shown', this._on_panel_shown ); |
| 3596 |
this._sync_settings_button_states(); |
| 3597 |
} |
| 3598 |
|
| 3599 |
destroy() {
|
| 3600 |
this.builder.bus.off( Core.WPBC_BFB_Events.CLEAR_SELECTION, this._on_clear );
|
| 3601 |
|
| 3602 |
if ( this._on_canvas_click ) { |
| 3603 |
this.builder.pages_container.removeEventListener( 'click', this._on_canvas_click, true ); |
| 3604 |
this._on_canvas_click = null; |
| 3605 |
} |
| 3606 |
|
| 3607 |
if ( this._on_panel_shown ) { |
| 3608 |
document.removeEventListener( 'wpbc_bfb:panel_shown', this._on_panel_shown ); |
| 3609 |
this._on_panel_shown = null; |
| 3610 |
} |
| 3611 |
} |
| 3612 |
|
| 3613 |
/** |
| 3614 |
* Refresh overlay button state after selection or right-bar panel changes. |
| 3615 |
* |
| 3616 |
* @returns {void} |
| 3617 |
*/ |
| 3618 |
_sync_settings_button_states() { |
| 3619 |
UI.WPBC_BFB_Overlay.sync_settings_button_states( this.builder ); |
| 3620 |
} |
| 3621 |
|
| 3622 |
/**
|
| 3623 |
* Delegated canvas click -> select closest field/section (inner beats outer).
|
| 3624 |
* @private
|
| 3625 |
* @param {MouseEvent} e
|
| 3626 |
*/
|
| 3627 |
_handle_canvas_click(e) {
|
| 3628 |
const root = this.builder.pages_container;
|
| 3629 |
if ( !root ) return;
|
| 3630 |
|
| 3631 |
// Ignore clicks on controls/handles/resizers, etc.
|
| 3632 |
const IGNORE = [
|
| 3633 |
'.wpbc_bfb__overlay-controls',
|
| 3634 |
'.wpbc_bfb__layout_picker',
|
| 3635 |
'.wpbc_bfb__drag-handle',
|
| 3636 |
'.wpbc_bfb__field-remove-btn',
|
| 3637 |
'.wpbc_bfb__field-move-up',
|
| 3638 |
'.wpbc_bfb__field-move-down',
|
| 3639 |
'.wpbc_bfb__column-resizer'
|
| 3640 |
].join( ',' );
|
| 3641 |
|
| 3642 |
if ( e.target.closest( IGNORE ) ) {
|
| 3643 |
return; // let those controls do their own thing.
|
| 3644 |
}
|
| 3645 |
|
| 3646 |
// Find the closest selectable (field OR section) from the click target.
|
| 3647 |
let hit = e.target.closest?.(
|
| 3648 |
`${Core.WPBC_BFB_DOM.SELECTORS.validField}, ${Core.WPBC_BFB_DOM.SELECTORS.section}, .wpbc_bfb__column`
|
| 3649 |
);
|
| 3650 |
|
| 3651 |
if ( !hit || !root.contains( hit ) ) {
|
| 3652 |
this.select_field( null ); // Clear selection on blank click.
|
| 3653 |
return; // Empty space is handled elsewhere.
|
| 3654 |
}
|
| 3655 |
|
| 3656 |
// NEW: if user clicked a COLUMN -> remember tab key on its SECTION, but still select the section.
|
| 3657 |
let preselect_tab_key = null;
|
| 3658 |
if ( hit.classList.contains( 'wpbc_bfb__column' ) ) {
|
| 3659 |
const row = hit.closest( '.wpbc_bfb__row' );
|
| 3660 |
const cols = row ? Array.from( row.querySelectorAll( ':scope > .wpbc_bfb__column' ) ) : [];
|
| 3661 |
const idx = Math.max( 0, cols.indexOf( hit ) );
|
| 3662 |
const sec = hit.closest( '.wpbc_bfb__section' );
|
| 3663 |
if ( sec ) {
|
| 3664 |
preselect_tab_key = String( idx + 1 ); // tabs are 1-based in ui-column-styles.js
|
| 3665 |
// Hint for the renderer (it reads this BEFORE rendering and restores the tab).
|
| 3666 |
sec.dataset.col_styles_active_tab = preselect_tab_key;
|
| 3667 |
// promote selection to the section (same UX as before).
|
| 3668 |
hit = sec;
|
| 3669 |
// NEW: visually mark which column is being edited
|
| 3670 |
if ( UI && UI.WPBC_BFB_Column_Styles && UI.WPBC_BFB_Column_Styles.set_selected_col_flag ) {
|
| 3671 |
UI.WPBC_BFB_Column_Styles.set_selected_col_flag( sec, preselect_tab_key );
|
| 3672 |
}
|
| 3673 |
}
|
| 3674 |
}
|
| 3675 |
|
| 3676 |
// Select and stop bubbling so outer containers don’t reselect a parent.
|
| 3677 |
this.select_field( hit );
|
| 3678 |
e.stopPropagation();
|
| 3679 |
|
| 3680 |
// Also set the tab after the inspector renders (works even if it was already open).
|
| 3681 |
if ( preselect_tab_key ) {
|
| 3682 |
(window.requestAnimationFrame || setTimeout)( function () {
|
| 3683 |
try {
|
| 3684 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 3685 |
const tabs = ins && ins.querySelector( '[data-bfb-slot="column_styles"] [data-wpbc-tabs]' );
|
| 3686 |
if ( tabs && window.wpbc_ui_tabs && typeof window.wpbc_ui_tabs.set_active === 'function' ) {
|
| 3687 |
window.wpbc_ui_tabs.set_active( tabs, preselect_tab_key );
|
| 3688 |
}
|
| 3689 |
} catch ( _e ) {
|
| 3690 |
}
|
| 3691 |
}, 0 );
|
| 3692 |
|
| 3693 |
// Politely ask the Inspector to focus/open the "Column Styles" group and tab.
|
| 3694 |
wpbc_bfb__dispatch_event_safe(
|
| 3695 |
'wpbc_bfb:inspector_focus',
|
| 3696 |
{
|
| 3697 |
group : 'column_styles',
|
| 3698 |
tab_key: preselect_tab_key
|
| 3699 |
}
|
| 3700 |
);
|
| 3701 |
}
|
| 3702 |
}
|
| 3703 |
|
| 3704 |
|
| 3705 |
/**
|
| 3706 |
* Select a field element or clear selection.
|
| 3707 |
*
|
| 3708 |
* @param {HTMLElement|null} field_el
|
| 3709 |
* @param {{scrollIntoView?: boolean}} [opts = {}]
|
| 3710 |
*/
|
| 3711 |
select_field(field_el, { scrollIntoView = false } = {}) {
|
| 3712 |
const root = this.builder.pages_container;
|
| 3713 |
const prevEl = this.get_selected_field?.() || null; // the one we’re leaving.
|
| 3714 |
|
| 3715 |
// Ignore elements not in the canvas.
|
| 3716 |
if ( field_el && !root.contains( field_el ) ) {
|
| 3717 |
field_el = null; // treat as "no selection".
|
| 3718 |
}
|
| 3719 |
|
| 3720 |
// NEW: if we are leaving a section, clear its column highlight
|
| 3721 |
if (
|
| 3722 |
prevEl && prevEl !== field_el &&
|
| 3723 |
prevEl.classList?.contains( 'wpbc_bfb__section' ) &&
|
| 3724 |
UI?.WPBC_BFB_Column_Styles?.clear_selected_col_flag
|
| 3725 |
) {
|
| 3726 |
UI.WPBC_BFB_Column_Styles.clear_selected_col_flag( prevEl );
|
| 3727 |
}
|
| 3728 |
|
| 3729 |
// If we're leaving a field, permanently stop auto-name for it.
|
| 3730 |
if ( prevEl && prevEl !== field_el && prevEl.classList?.contains( 'wpbc_bfb__field' ) ) {
|
| 3731 |
prevEl.dataset.autoname = '0';
|
| 3732 |
prevEl.dataset.fresh = '0';
|
| 3733 |
}
|
| 3734 |
|
| 3735 |
root.querySelectorAll( '.is-selected' ).forEach( (n) => {
|
| 3736 |
n.classList.remove( 'is-selected' );
|
| 3737 |
} );
|
| 3738 |
if ( !field_el ) {
|
| 3739 |
const prev = this._selected_uid || null;
|
| 3740 |
this._selected_uid = null;
|
| 3741 |
this.builder.inspector?.clear?.();
|
| 3742 |
root.classList.remove( 'has-selection' );
|
| 3743 |
this.builder.bus.emit( Core.WPBC_BFB_Events.CLEAR_SELECTION, { prev_uid: prev, source: 'builder' } );
|
| 3744 |
|
| 3745 |
// Auto-open "Add Fields" when nothing is selected.
|
| 3746 |
wpbc_bfb__dispatch_event_safe( |
| 3747 |
'wpbc_bfb:show_panel', |
| 3748 |
{
|
| 3749 |
panel_id: 'wpbc_bfb__palette_add_new',
|
| 3750 |
tab_id : 'wpbc_tab_library'
|
| 3751 |
} |
| 3752 |
); |
| 3753 |
this._sync_settings_button_states(); |
| 3754 |
|
| 3755 |
return; |
| 3756 |
}
|
| 3757 |
field_el.classList.add( 'is-selected' );
|
| 3758 |
this._selected_uid = field_el.getAttribute( 'data-uid' ) || null;
|
| 3759 |
|
| 3760 |
// Fallback: ensure sections announce themselves as type="section".
|
| 3761 |
if ( field_el.classList.contains( 'wpbc_bfb__section' ) && !field_el.dataset.type ) {
|
| 3762 |
field_el.dataset.type = 'section';
|
| 3763 |
}
|
| 3764 |
|
| 3765 |
if ( scrollIntoView ) {
|
| 3766 |
field_el.scrollIntoView( { behavior: 'smooth', block: 'center' } );
|
| 3767 |
}
|
| 3768 |
this.builder.inspector?.bind_to_field?.( field_el );
|
| 3769 |
|
| 3770 |
// Fallback: ensure inspector enhancers (incl. ValueSlider) run every bind.
|
| 3771 |
try {
|
| 3772 |
const ins = document.getElementById( 'wpbc_bfb__inspector' )
|
| 3773 |
|| document.querySelector( '.wpbc_bfb__inspector' );
|
| 3774 |
if ( ins ) {
|
| 3775 |
UI.InspectorEnhancers?.scan?.( ins ); // runs all enhancers
|
| 3776 |
UI.WPBC_BFB_ValueSlider?.init_on?.( ins ); // extra belt-and-suspenders
|
| 3777 |
}
|
| 3778 |
} catch ( _ ) {
|
| 3779 |
}
|
| 3780 |
|
| 3781 |
// NEW: when selecting a section, reflect its active tab as the highlighted column.
|
| 3782 |
if ( field_el.classList.contains( 'wpbc_bfb__section' ) &&
|
| 3783 |
UI?.WPBC_BFB_Column_Styles?.set_selected_col_flag ) {
|
| 3784 |
var k = (field_el.dataset && field_el.dataset.col_styles_active_tab)
|
| 3785 |
? field_el.dataset.col_styles_active_tab : '1';
|
| 3786 |
UI.WPBC_BFB_Column_Styles.set_selected_col_flag( field_el, k );
|
| 3787 |
}
|
| 3788 |
|
| 3789 |
// Keep sections & fields in the same flow:
|
| 3790 |
// 1) Generic hydrator for simple dataset-backed controls.
|
| 3791 |
if ( field_el ) {
|
| 3792 |
UI.WPBC_BFB_Inspector_Bridge._generic_hydrate_controls?.( this.builder, field_el );
|
| 3793 |
UI.WPBC_BFB_Inspector_Bridge._hydrate_special_controls?.( this.builder, field_el );
|
| 3794 |
}
|
| 3795 |
|
| 3796 |
// Auto-open Inspector when a user selects a field/section .
|
| 3797 |
wpbc_bfb__dispatch_event_safe( |
| 3798 |
'wpbc_bfb:show_panel', |
| 3799 |
{
|
| 3800 |
panel_id: 'wpbc_bfb__inspector',
|
| 3801 |
tab_id : 'wpbc_tab_inspector'
|
| 3802 |
} |
| 3803 |
); |
| 3804 |
this._sync_settings_button_states(); |
| 3805 |
|
| 3806 |
root.classList.add( 'has-selection' ); |
| 3807 |
this.builder.bus.emit( Core.WPBC_BFB_Events.SELECT, { uid: this._selected_uid, el: field_el } );
|
| 3808 |
const label = field_el?.querySelector( '.wpbc_bfb__field-label' )?.textContent || (field_el.classList.contains( 'wpbc_bfb__section' ) ? 'section' : '') || field_el?.dataset?.id || 'item';
|
| 3809 |
this.builder._announce( 'Selected ' + label + '.' );
|
| 3810 |
}
|
| 3811 |
|
| 3812 |
/** @returns {HTMLElement|null} */
|
| 3813 |
get_selected_field() {
|
| 3814 |
if ( !this._selected_uid ) {
|
| 3815 |
return null;
|
| 3816 |
}
|
| 3817 |
const esc_attr = Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( this._selected_uid );
|
| 3818 |
return this.builder.pages_container.querySelector( `.wpbc_bfb__field[data-uid="${esc_attr}"], .wpbc_bfb__section[data-uid="${esc_attr}"]` );
|
| 3819 |
}
|
| 3820 |
|
| 3821 |
/** @param {CustomEvent} ev */
|
| 3822 |
on_clear(ev) {
|
| 3823 |
const src = ev?.detail?.source ?? ev?.source;
|
| 3824 |
if ( src !== 'builder' ) {
|
| 3825 |
this.select_field( null );
|
| 3826 |
}
|
| 3827 |
}
|
| 3828 |
|
| 3829 |
};
|
| 3830 |
|
| 3831 |
/**
|
| 3832 |
* Bridges the builder with the Inspector and sanitizes id/name edits.
|
| 3833 |
*/
|
| 3834 |
UI.WPBC_BFB_Inspector_Bridge = class extends UI.WPBC_BFB_Module {
|
| 3835 |
|
| 3836 |
init() {
|
| 3837 |
this._attach_inspector();
|
| 3838 |
this._bind_id_sanitizer();
|
| 3839 |
this._open_inspector_after_field_added();
|
| 3840 |
this._bind_focus_shortcuts();
|
| 3841 |
}
|
| 3842 |
|
| 3843 |
_attach_inspector() {
|
| 3844 |
const b = this.builder;
|
| 3845 |
const attach = () => {
|
| 3846 |
if ( typeof window.WPBC_BFB_Inspector === 'function' ) {
|
| 3847 |
b.inspector = new WPBC_BFB_Inspector( document.getElementById( 'wpbc_bfb__inspector' ), b );
|
| 3848 |
this._bind_id_sanitizer();
|
| 3849 |
document.removeEventListener( 'wpbc_bfb_inspector_ready', attach );
|
| 3850 |
}
|
| 3851 |
};
|
| 3852 |
// Ensure we bind after late ready as well.
|
| 3853 |
if ( typeof window.WPBC_BFB_Inspector === 'function' ) {
|
| 3854 |
attach();
|
| 3855 |
} else {
|
| 3856 |
b.inspector = {
|
| 3857 |
bind_to_field() {
|
| 3858 |
}, clear() {
|
| 3859 |
}
|
| 3860 |
};
|
| 3861 |
document.addEventListener( 'wpbc_bfb_inspector_ready', attach );
|
| 3862 |
setTimeout( attach, 0 );
|
| 3863 |
}
|
| 3864 |
}
|
| 3865 |
|
| 3866 |
/**
|
| 3867 |
* Listen for "focus" hints from the canvas and open the right group/tab.
|
| 3868 |
* - Supports: group === 'column_styles'
|
| 3869 |
* - Also scrolls the group into view.
|
| 3870 |
*/
|
| 3871 |
_bind_focus_shortcuts() {
|
| 3872 |
/** @param {CustomEvent} e */
|
| 3873 |
const on_focus = (e) => {
|
| 3874 |
try {
|
| 3875 |
const grp_key = e && e.detail && e.detail.group;
|
| 3876 |
const tab_key = e && e.detail && e.detail.tab_key;
|
| 3877 |
if ( !grp_key ) {
|
| 3878 |
return;
|
| 3879 |
}
|
| 3880 |
|
| 3881 |
const ins = document.getElementById( 'wpbc_bfb__inspector' ) || document.querySelector( '.wpbc_bfb__inspector' );
|
| 3882 |
if ( !ins ) {
|
| 3883 |
return;
|
| 3884 |
}
|
| 3885 |
|
| 3886 |
if ( grp_key === 'column_styles' ) {
|
| 3887 |
// Find the Column Styles slot/group.
|
| 3888 |
const slot = ins.querySelector( '[data-bfb-slot="column_styles"]' ) || ins.querySelector( '[data-inspector-group-key="column_styles"]' );
|
| 3889 |
if ( slot ) {
|
| 3890 |
// Open collapsible container if present.
|
| 3891 |
const group_wrap = slot.closest( '.inspector__group' ) || slot.closest( '[data-inspector-group]' );
|
| 3892 |
if ( group_wrap && !group_wrap.classList.contains( 'is-open' ) ) {
|
| 3893 |
group_wrap.classList.add( 'is-open' );
|
| 3894 |
// Mirror ARIA state if your header uses aria-expanded.
|
| 3895 |
const header_btn = group_wrap.querySelector( '[aria-expanded]' );
|
| 3896 |
if ( header_btn ) {
|
| 3897 |
header_btn.setAttribute( 'aria-expanded', 'true' );
|
| 3898 |
}
|
| 3899 |
}
|
| 3900 |
|
| 3901 |
// Optional: set the requested tab key if tabs exist in this group.
|
| 3902 |
if ( tab_key ) {
|
| 3903 |
const tabs = slot.querySelector( '[data-wpbc-tabs]' );
|
| 3904 |
if ( tabs && window.wpbc_ui_tabs && typeof window.wpbc_ui_tabs.set_active === 'function' ) {
|
| 3905 |
window.wpbc_ui_tabs.set_active( tabs, String( tab_key ) );
|
| 3906 |
}
|
| 3907 |
}
|
| 3908 |
|
| 3909 |
// Bring into view for convenience.
|
| 3910 |
try {
|
| 3911 |
// Uncomment (Only if needed) this to AUTO SCROLL to specific COLUMN in the section:.
|
| 3912 |
// slot.scrollIntoView( { behavior: 'smooth', block: 'nearest' } );
|
| 3913 |
} catch ( _e ) {}
|
| 3914 |
}
|
| 3915 |
}
|
| 3916 |
} catch ( _e ) {}
|
| 3917 |
};
|
| 3918 |
|
| 3919 |
this._on_inspector_focus = on_focus;
|
| 3920 |
document.addEventListener( 'wpbc_bfb:inspector_focus', on_focus, true );
|
| 3921 |
}
|
| 3922 |
|
| 3923 |
destroy() {
|
| 3924 |
try {
|
| 3925 |
if ( this._on_inspector_focus ) {
|
| 3926 |
document.removeEventListener( 'wpbc_bfb:inspector_focus', this._on_inspector_focus, true );
|
| 3927 |
this._on_inspector_focus = null;
|
| 3928 |
}
|
| 3929 |
} catch ( _e ) {
|
| 3930 |
}
|
| 3931 |
}
|
| 3932 |
|
| 3933 |
|
| 3934 |
/**
|
| 3935 |
* Hydrate inspector inputs for "special" keys that we handle explicitly.
|
| 3936 |
* Works for both fields and sections.
|
| 3937 |
* @param {WPBC_Form_Builder} builder
|
| 3938 |
* @param {HTMLElement} sel
|
| 3939 |
*/
|
| 3940 |
static _hydrate_special_controls(builder, sel) {
|
| 3941 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 3942 |
if ( !ins || !sel ) return;
|
| 3943 |
|
| 3944 |
const setVal = (key, val) => {
|
| 3945 |
const ctrl = ins.querySelector( `[data-inspector-key="${key}"]` );
|
| 3946 |
if ( ctrl && 'value' in ctrl ) ctrl.value = String( val ?? '' );
|
| 3947 |
};
|
| 3948 |
|
| 3949 |
// Internal id / name / public html_id.
|
| 3950 |
setVal( 'id', sel.getAttribute( 'data-id' ) || '' );
|
| 3951 |
setVal( 'name', sel.getAttribute( 'data-name' ) || '' );
|
| 3952 |
setVal( 'html_id', sel.getAttribute( 'data-html_id' ) || '' );
|
| 3953 |
|
| 3954 |
// Section-only extras are harmless to set for fields (controls may not exist).
|
| 3955 |
setVal( 'cssclass', sel.getAttribute( 'data-cssclass' ) || '' );
|
| 3956 |
setVal( 'label', sel.getAttribute( 'data-label' ) || '' );
|
| 3957 |
}
|
| 3958 |
|
| 3959 |
|
| 3960 |
/**
|
| 3961 |
* Hydrate inspector inputs that declare a generic dataset mapping via
|
| 3962 |
* [data-inspector-key] but do NOT declare a custom value_from adapter.
|
| 3963 |
* This makes sections follow the same data flow as fields with almost no glue.
|
| 3964 |
*
|
| 3965 |
* @param {WPBC_Form_Builder} builder
|
| 3966 |
* @param {HTMLElement} sel - currently selected field/section
|
| 3967 |
*/
|
| 3968 |
static _generic_hydrate_controls(builder, sel) {
|
| 3969 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 3970 |
if ( !ins || !sel ) return;
|
| 3971 |
|
| 3972 |
const SKIP = /^(id|name|html_id|cssclass|label)$/; // handled by _hydrate_special_controls
|
| 3973 |
|
| 3974 |
// NEW: read schema for the selected element’s type.
|
| 3975 |
const schemas = window.WPBC_BFB_Schemas || {};
|
| 3976 |
const typeKey = (sel.dataset && sel.dataset.type) || '';
|
| 3977 |
const schemaEntry = schemas[typeKey] || null;
|
| 3978 |
const propsSchema = (schemaEntry && schemaEntry.schema && schemaEntry.schema.props) ? schemaEntry.schema.props : {};
|
| 3979 |
const hasOwn = Function.prototype.call.bind( Object.prototype.hasOwnProperty );
|
| 3980 |
const getDefault = (key) => {
|
| 3981 |
const meta = propsSchema[key];
|
| 3982 |
return (meta && hasOwn( meta, 'default' )) ? meta.default : undefined;
|
| 3983 |
};
|
| 3984 |
|
| 3985 |
ins.querySelectorAll( '[data-inspector-key]' ).forEach( (ctrl) => {
|
| 3986 |
const key = String( ctrl.dataset?.inspectorKey || '' ).toLowerCase();
|
| 3987 |
if ( !key || SKIP.test( key ) ) return;
|
| 3988 |
|
| 3989 |
// Element-level lock.
|
| 3990 |
const dl = (ctrl.dataset?.locked || '').trim().toLowerCase();
|
| 3991 |
if ( dl === '1' || dl === 'true' || dl === 'yes' ) return;
|
| 3992 |
|
| 3993 |
// Respect explicit adapters.
|
| 3994 |
if ( ctrl.dataset?.value_from || ctrl.dataset?.valueFrom ) return;
|
| 3995 |
|
| 3996 |
const raw = sel.dataset ? sel.dataset[key] : undefined;
|
| 3997 |
const hasRaw = sel.dataset ? hasOwn( sel.dataset, key ) : false;
|
| 3998 |
const defValue = getDefault( key );
|
| 3999 |
|
| 4000 |
// Best-effort control typing with schema default fallback when value is absent.
|
| 4001 |
|
| 4002 |
if ( ctrl instanceof HTMLInputElement && (ctrl.type === 'checkbox' || ctrl.type === 'radio') ) {
|
| 4003 |
// If dataset is missing the key entirely -> use schema default (boolean).
|
| 4004 |
if ( !hasRaw ) {
|
| 4005 |
ctrl.checked = !!defValue;
|
| 4006 |
} else {
|
| 4007 |
// An explicit empty value is the legacy persisted representation of false.
|
| 4008 |
ctrl.checked = Core.WPBC_BFB_Sanitize.coerce_boolean( raw, false );
|
| 4009 |
}
|
| 4010 |
} else if ( 'value' in ctrl ) {
|
| 4011 |
if ( hasRaw ) {
|
| 4012 |
ctrl.value = (raw != null) ? String( raw ) : '';
|
| 4013 |
} else {
|
| 4014 |
ctrl.value = (defValue == null) ? '' : String( defValue );
|
| 4015 |
}
|
| 4016 |
}
|
| 4017 |
} );
|
| 4018 |
}
|
| 4019 |
|
| 4020 |
_bind_id_sanitizer() {
|
| 4021 |
const b = this.builder;
|
| 4022 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 4023 |
if ( ! ins ) {
|
| 4024 |
return;
|
| 4025 |
}
|
| 4026 |
if ( ins.__wpbc_bfb_id_sanitizer_bound ) {
|
| 4027 |
return;
|
| 4028 |
}
|
| 4029 |
ins.__wpbc_bfb_id_sanitizer_bound = true;
|
| 4030 |
|
| 4031 |
const handler = (e) => {
|
| 4032 |
|
| 4033 |
const t = e.target;
|
| 4034 |
if ( !t || !('value' in t) ) {
|
| 4035 |
return;
|
| 4036 |
}
|
| 4037 |
const key = (t.dataset?.inspectorKey || '').toLowerCase();
|
| 4038 |
const sel = b.get_selected_field?.();
|
| 4039 |
const isSection = sel?.classList?.contains( 'wpbc_bfb__section' );
|
| 4040 |
if ( !sel ) return;
|
| 4041 |
|
| 4042 |
// Unified emitter that always includes the element reference.
|
| 4043 |
const EV = Core.WPBC_BFB_Events;
|
| 4044 |
// STRUCTURE_CHANGE can be "expensive" because other listeners may trigger full canvas refresh.
|
| 4045 |
// Debounce only continuous controls (e.g. value slider scrubbing) on the INPUT phase.
|
| 4046 |
const ensure_sc_debounce_state = () => {
|
| 4047 |
if ( b.__wpbc_bfb_sc_debounce_state ) {
|
| 4048 |
return b.__wpbc_bfb_sc_debounce_state;
|
| 4049 |
}
|
| 4050 |
b.__wpbc_bfb_sc_debounce_state = { timer_id: 0, pending_payload: null };
|
| 4051 |
return b.__wpbc_bfb_sc_debounce_state;
|
| 4052 |
};
|
| 4053 |
|
| 4054 |
const cancel_sc_debounced_emit = () => {
|
| 4055 |
const st = b.__wpbc_bfb_sc_debounce_state;
|
| 4056 |
if ( !st ) return;
|
| 4057 |
try { clearTimeout( st.timer_id ); } catch ( _ ) {}
|
| 4058 |
st.timer_id = 0;
|
| 4059 |
st.pending_payload = null;
|
| 4060 |
};
|
| 4061 |
|
| 4062 |
const bus_emit_change = (reason, extra = {}) => {
|
| 4063 |
// If we’re committing something (change/blur/etc), drop any pending "input" emit.
|
| 4064 |
cancel_sc_debounced_emit();
|
| 4065 |
b.bus?.emit?.( EV.STRUCTURE_CHANGE, { reason, el: sel, ...extra } );
|
| 4066 |
};
|
| 4067 |
|
| 4068 |
const bus_emit_change_debounced = (reason, extra = {}, wait_ms) => {
|
| 4069 |
const st = ensure_sc_debounce_state();
|
| 4070 |
const ms = Number.isFinite( wait_ms )
|
| 4071 |
? wait_ms
|
| 4072 |
: (Number.isFinite( UI.STRUCTURE_CHANGE_DEBOUNCE_MS ) ? UI.STRUCTURE_CHANGE_DEBOUNCE_MS : 240);
|
| 4073 |
|
| 4074 |
// Capture the CURRENT selected element into the payload now (stable ref).
|
| 4075 |
st.pending_payload = { reason, el: sel, ...extra, debounced: true };
|
| 4076 |
|
| 4077 |
try { clearTimeout( st.timer_id ); } catch ( _ ) {}
|
| 4078 |
st.timer_id = setTimeout( function () {
|
| 4079 |
st.timer_id = 0;
|
| 4080 |
const payload = st.pending_payload;
|
| 4081 |
st.pending_payload = null;
|
| 4082 |
if ( payload ) {
|
| 4083 |
b.bus?.emit?.( EV.STRUCTURE_CHANGE, payload );
|
| 4084 |
}
|
| 4085 |
}, ms );
|
| 4086 |
};
|
| 4087 |
|
| 4088 |
// ---- FIELD/SECTION: internal id ----
|
| 4089 |
if ( key === 'id' ) {
|
| 4090 |
const unique = b.id.set_field_id( sel, t.value );
|
| 4091 |
if ( b.preview_mode && !isSection ) {
|
| 4092 |
b.render_preview( sel );
|
| 4093 |
}
|
| 4094 |
if ( t.value !== unique ) {
|
| 4095 |
t.value = unique;
|
| 4096 |
}
|
| 4097 |
bus_emit_change( 'id-change' );
|
| 4098 |
return;
|
| 4099 |
}
|
| 4100 |
|
| 4101 |
// ---- FIELD/SECTION: public HTML id ----
|
| 4102 |
if ( key === 'html_id' ) {
|
| 4103 |
const applied = b.id.set_field_html_id( sel, t.value );
|
| 4104 |
// For sections, also set the real DOM id so anchors/CSS can target it.
|
| 4105 |
if ( isSection ) {
|
| 4106 |
sel.id = applied || '';
|
| 4107 |
} else if ( b.preview_mode ) {
|
| 4108 |
b.render_preview( sel );
|
| 4109 |
}
|
| 4110 |
if ( t.value !== applied ) {
|
| 4111 |
t.value = applied;
|
| 4112 |
}
|
| 4113 |
bus_emit_change( 'html-id-change' );
|
| 4114 |
return;
|
| 4115 |
}
|
| 4116 |
|
| 4117 |
// ---- FIELDS ONLY: name ----
|
| 4118 |
if ( key === 'name' && !isSection ) {
|
| 4119 |
|
| 4120 |
// Live typing: sanitize only (NO uniqueness yet) to avoid "-2" spam
|
| 4121 |
if ( e.type === 'input' ) {
|
| 4122 |
const before = t.value;
|
| 4123 |
const sanitized = Core.WPBC_BFB_Sanitize.sanitize_html_name( before );
|
| 4124 |
if ( before !== sanitized ) {
|
| 4125 |
// optional: preserve caret to avoid jump
|
| 4126 |
const selStart = t.selectionStart, selEnd = t.selectionEnd;
|
| 4127 |
t.value = sanitized;
|
| 4128 |
try {
|
| 4129 |
t.setSelectionRange( selStart, selEnd );
|
| 4130 |
} catch ( _ ) {
|
| 4131 |
}
|
| 4132 |
}
|
| 4133 |
return; // uniqueness on change/blur
|
| 4134 |
}
|
| 4135 |
|
| 4136 |
// Commit (change/blur)
|
| 4137 |
const raw = String( t.value ?? '' ).trim();
|
| 4138 |
|
| 4139 |
if ( !raw ) {
|
| 4140 |
// RESEED: keep name non-empty and provisional (autoname stays ON)
|
| 4141 |
const S = Core.WPBC_BFB_Sanitize;
|
| 4142 |
const base = S.sanitize_html_name( sel.getAttribute( 'data-id' ) || sel.dataset.id || sel.dataset.type || 'field' );
|
| 4143 |
const uniq = b.id.ensure_unique_field_name( base, sel );
|
| 4144 |
|
| 4145 |
sel.setAttribute( 'data-name', uniq );
|
| 4146 |
sel.dataset.autoname = '1';
|
| 4147 |
sel.dataset.name_user_touched = '0';
|
| 4148 |
|
| 4149 |
// Keep DOM in sync if we’re not re-rendering
|
| 4150 |
if ( !b.preview_mode ) {
|
| 4151 |
const ctrl = sel.querySelector( 'input,textarea,select' );
|
| 4152 |
if ( ctrl ) ctrl.setAttribute( 'name', uniq );
|
| 4153 |
} else {
|
| 4154 |
b.render_preview( sel );
|
| 4155 |
}
|
| 4156 |
|
| 4157 |
if ( t.value !== uniq ) t.value = uniq;
|
| 4158 |
bus_emit_change( 'name-reseed' );
|
| 4159 |
return;
|
| 4160 |
}
|
| 4161 |
|
| 4162 |
// Non-empty commit: user takes control; disable autoname going forward
|
| 4163 |
sel.dataset.name_user_touched = '1';
|
| 4164 |
sel.dataset.autoname = '0';
|
| 4165 |
|
| 4166 |
const sanitized = Core.WPBC_BFB_Sanitize.sanitize_html_name( raw );
|
| 4167 |
const unique = b.id.set_field_name( sel, sanitized );
|
| 4168 |
|
| 4169 |
if ( !b.preview_mode ) {
|
| 4170 |
const ctrl = sel.querySelector( 'input,textarea,select' );
|
| 4171 |
if ( ctrl ) ctrl.setAttribute( 'name', unique );
|
| 4172 |
} else {
|
| 4173 |
b.render_preview( sel );
|
| 4174 |
}
|
| 4175 |
|
| 4176 |
if ( t.value !== unique ) t.value = unique;
|
| 4177 |
bus_emit_change( 'name-change' );
|
| 4178 |
return;
|
| 4179 |
}
|
| 4180 |
|
| 4181 |
// ---- SECTIONS & FIELDS: cssclass (live apply; no re-render) ----
|
| 4182 |
if ( key === 'cssclass' ) {
|
| 4183 |
const next = Core.WPBC_BFB_Sanitize.sanitize_css_classlist( t.value || '' );
|
| 4184 |
const desiredArr = next.split( /\s+/ ).filter( Boolean );
|
| 4185 |
const desiredSet = new Set( desiredArr );
|
| 4186 |
|
| 4187 |
// Core classes are never touched.
|
| 4188 |
const isCore = (cls) => cls === 'is-selected' || cls.startsWith( 'wpbc_' );
|
| 4189 |
|
| 4190 |
// Snapshot before mutating (DOMTokenList is live).
|
| 4191 |
const beforeClasses = Array.from( sel.classList );
|
| 4192 |
const customBefore = beforeClasses.filter( (c) => !isCore( c ) );
|
| 4193 |
|
| 4194 |
// Remove stray non-core classes not in desired.
|
| 4195 |
customBefore.forEach( (c) => {
|
| 4196 |
if ( !desiredSet.has( c ) ) sel.classList.remove( c );
|
| 4197 |
} );
|
| 4198 |
|
| 4199 |
// Add missing desired classes in one go.
|
| 4200 |
const missing = desiredArr.filter( (c) => !customBefore.includes( c ) );
|
| 4201 |
if ( missing.length ) sel.classList.add( ...missing );
|
| 4202 |
|
| 4203 |
// Keep dataset in sync (avoid useless attribute writes).
|
| 4204 |
if ( sel.getAttribute( 'data-cssclass' ) !== next ) {
|
| 4205 |
sel.setAttribute( 'data-cssclass', next );
|
| 4206 |
}
|
| 4207 |
|
| 4208 |
// Emit only if something actually changed.
|
| 4209 |
const afterClasses = Array.from( sel.classList );
|
| 4210 |
const changed = afterClasses.length !== beforeClasses.length || beforeClasses.some( (c, i) => c !== afterClasses[i] );
|
| 4211 |
|
| 4212 |
const detail = { key: 'cssclass', phase: e.type };
|
| 4213 |
if ( isSection ) {
|
| 4214 |
bus_emit_change( 'cssclass-change', detail );
|
| 4215 |
} else {
|
| 4216 |
bus_emit_change( 'prop-change', detail );
|
| 4217 |
}
|
| 4218 |
return;
|
| 4219 |
}
|
| 4220 |
|
| 4221 |
|
| 4222 |
// ---- SECTIONS: label ----
|
| 4223 |
if ( isSection && key === 'label' ) {
|
| 4224 |
const val = String( t.value ?? '' );
|
| 4225 |
sel.setAttribute( 'data-label', val );
|
| 4226 |
bus_emit_change( 'label-change' );
|
| 4227 |
return;
|
| 4228 |
}
|
| 4229 |
|
| 4230 |
// ---- FIELDS: label (auto-name while typing; freeze on commit) ----
|
| 4231 |
if ( !isSection && key === 'label' ) {
|
| 4232 |
const val = String( t.value ?? '' );
|
| 4233 |
sel.dataset.label = val;
|
| 4234 |
|
| 4235 |
// while typing, allow auto-name (if flags permit)
|
| 4236 |
try {
|
| 4237 |
Core.WPBC_BFB_Field_Base.maybe_autoname_from_label( b, sel, val );
|
| 4238 |
} catch ( _ ) {
|
| 4239 |
}
|
| 4240 |
|
| 4241 |
// if user committed the label (blur/change), freeze future auto-name
|
| 4242 |
if ( e.type !== 'input' ) {
|
| 4243 |
sel.dataset.autoname = '0'; // stop future label->name sync
|
| 4244 |
sel.dataset.fresh = '0'; // also kill the "fresh" escape hatch
|
| 4245 |
}
|
| 4246 |
|
| 4247 |
// Optional UI nicety: disable Name when auto is ON, enable when OFF
|
| 4248 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 4249 |
const nameCtrl = ins?.querySelector( '[data-inspector-key="name"]' );
|
| 4250 |
if ( nameCtrl ) {
|
| 4251 |
const autoActive =
|
| 4252 |
(sel.dataset.autoname ?? '1') !== '0' &&
|
| 4253 |
sel.dataset.name_user_touched !== '1' &&
|
| 4254 |
sel.dataset.was_loaded !== '1';
|
| 4255 |
nameCtrl.toggleAttribute( 'disabled', autoActive );
|
| 4256 |
if ( autoActive && !nameCtrl.placeholder ) {
|
| 4257 |
nameCtrl.placeholder = b?.i18n?.auto_from_label ?? 'auto — from label';
|
| 4258 |
}
|
| 4259 |
if ( !autoActive && nameCtrl.placeholder === (b?.i18n?.auto_from_label ?? 'auto — from label') ) {
|
| 4260 |
nameCtrl.placeholder = '';
|
| 4261 |
}
|
| 4262 |
}
|
| 4263 |
|
| 4264 |
// Always re-render the preview so label changes are visible immediately.
|
| 4265 |
b.render_preview( sel );
|
| 4266 |
bus_emit_change( 'label-change' );
|
| 4267 |
return;
|
| 4268 |
}
|
| 4269 |
|
| 4270 |
|
| 4271 |
// ---- DEFAULT (GENERIC): dataset writer for both fields & sections ----
|
| 4272 |
// Any inspector control with [data-inspector-key] that doesn't have a custom
|
| 4273 |
// adapter/value_from will simply read/write sel.dataset[key].
|
| 4274 |
if ( key ) {
|
| 4275 |
|
| 4276 |
const selfLocked = /^(1|true|yes)$/i.test( (t.dataset?.locked || '').trim() );
|
| 4277 |
if ( selfLocked ) {
|
| 4278 |
return;
|
| 4279 |
}
|
| 4280 |
|
| 4281 |
// Skip keys we handled above to avoid double work.
|
| 4282 |
if ( key === 'id' || key === 'name' || key === 'html_id' || key === 'cssclass' || key === 'label' ) {
|
| 4283 |
return;
|
| 4284 |
}
|
| 4285 |
let nextVal = '';
|
| 4286 |
if ( t instanceof HTMLInputElement && (t.type === 'checkbox' || t.type === 'radio') ) {
|
| 4287 |
// Persist both boolean states explicitly so schema defaults cannot replace false.
|
| 4288 |
nextVal = t.checked ? 'true' : 'false';
|
| 4289 |
} else if ( 'value' in t ) {
|
| 4290 |
nextVal = String( t.value ?? '' );
|
| 4291 |
}
|
| 4292 |
// Persist to dataset.
|
| 4293 |
if ( sel?.dataset ) sel.dataset[key] = nextVal;
|
| 4294 |
|
| 4295 |
// Generator controls are "UI inputs" — avoid STRUCTURE_CHANGE spam while dragging/typing.
|
| 4296 |
const is_gen_key = (key.indexOf( 'gen_' ) === 0);
|
| 4297 |
|
| 4298 |
// Re-render on visual keys so preview stays in sync (calendar label/help, etc.).
|
| 4299 |
const visualKeys = new Set( [ 'help', 'placeholder', 'min_width', 'cssclass' ] );
|
| 4300 |
if ( !isSection && (visualKeys.has( key ) || key.startsWith( 'ui_' )) ) {
|
| 4301 |
// Light heuristic: only re-render on commit for heavy inputs; live for short ones is fine.
|
| 4302 |
if ( e.type === 'change' || key === 'help' || key === 'placeholder' ) {
|
| 4303 |
b.render_preview( sel );
|
| 4304 |
}
|
| 4305 |
}
|
| 4306 |
|
| 4307 |
if ( !(is_gen_key && e.type === 'input') ) {
|
| 4308 |
// Debounce continuous value slider input events to avoid full-canvas refresh spam.
|
| 4309 |
// We detect the slider group via [data-len-group] wrapper.
|
| 4310 |
const is_len_group_ctrl = !!(t && t.closest && t.closest( '[data-len-group]' ));
|
| 4311 |
|
| 4312 |
if ( is_len_group_ctrl && e.type === 'input' ) {
|
| 4313 |
bus_emit_change_debounced( 'prop-change', { key, phase: e.type } );
|
| 4314 |
} else {
|
| 4315 |
bus_emit_change( 'prop-change', { key, phase: e.type } );
|
| 4316 |
}
|
| 4317 |
}
|
| 4318 |
return;
|
| 4319 |
}
|
| 4320 |
};
|
| 4321 |
|
| 4322 |
ins.addEventListener( 'change', handler, true );
|
| 4323 |
// reflect instantly while typing as well.
|
| 4324 |
ins.addEventListener( 'input', handler, true );
|
| 4325 |
}
|
| 4326 |
|
| 4327 |
/**
|
| 4328 |
* Open Inspector after a field is added.
|
| 4329 |
* @private
|
| 4330 |
*/
|
| 4331 |
_open_inspector_after_field_added() {
|
| 4332 |
const EV = Core.WPBC_BFB_Events;
|
| 4333 |
this.builder?.bus?.on?.( EV.FIELD_ADD, (e) => {
|
| 4334 |
const el = e?.detail?.el || null;
|
| 4335 |
if ( el && this.builder?.select_field ) {
|
| 4336 |
this.builder.select_field( el, { scrollIntoView: true } );
|
| 4337 |
}
|
| 4338 |
// Show Inspector Palette.
|
| 4339 |
wpbc_bfb__dispatch_event_safe(
|
| 4340 |
'wpbc_bfb:show_panel',
|
| 4341 |
{
|
| 4342 |
panel_id: 'wpbc_bfb__inspector',
|
| 4343 |
tab_id : 'wpbc_tab_inspector'
|
| 4344 |
}
|
| 4345 |
);
|
| 4346 |
} );
|
| 4347 |
}
|
| 4348 |
};
|
| 4349 |
|
| 4350 |
/**
|
| 4351 |
* Keyboard shortcuts for selection, deletion, and movement.
|
| 4352 |
*/
|
| 4353 |
UI.WPBC_BFB_Keyboard_Controller = class extends UI.WPBC_BFB_Module {
|
| 4354 |
init() {
|
| 4355 |
this._on_key = this.on_key.bind( this );
|
| 4356 |
document.addEventListener( 'keydown', this._on_key, true );
|
| 4357 |
}
|
| 4358 |
|
| 4359 |
destroy() {
|
| 4360 |
document.removeEventListener( 'keydown', this._on_key, true );
|
| 4361 |
}
|
| 4362 |
|
| 4363 |
/** @param {KeyboardEvent} e */
|
| 4364 |
on_key(e) {
|
| 4365 |
const b = this.builder;
|
| 4366 |
const is_typing = this._is_typing_anywhere();
|
| 4367 |
if ( e.key === 'Escape' ) {
|
| 4368 |
if ( is_typing ) {
|
| 4369 |
return;
|
| 4370 |
}
|
| 4371 |
this.builder.bus.emit( Core.WPBC_BFB_Events.CLEAR_SELECTION, { source: 'esc' } );
|
| 4372 |
return;
|
| 4373 |
}
|
| 4374 |
const selected = b.get_selected_field?.();
|
| 4375 |
if ( !selected || is_typing ) {
|
| 4376 |
return;
|
| 4377 |
}
|
| 4378 |
if ( e.key === 'Delete' || e.key === 'Backspace' ) {
|
| 4379 |
e.preventDefault();
|
| 4380 |
b.delete_item?.( selected );
|
| 4381 |
return;
|
| 4382 |
}
|
| 4383 |
if ( (e.altKey || e.ctrlKey || e.metaKey) && (e.key === 'ArrowUp' || e.key === 'ArrowDown') && !e.shiftKey ) {
|
| 4384 |
e.preventDefault();
|
| 4385 |
const dir = (e.key === 'ArrowUp') ? 'up' : 'down';
|
| 4386 |
b.move_item?.( selected, dir );
|
| 4387 |
return;
|
| 4388 |
}
|
| 4389 |
if ( e.key === 'Enter' ) {
|
| 4390 |
e.preventDefault();
|
| 4391 |
b.select_field( selected, { scrollIntoView: true } );
|
| 4392 |
}
|
| 4393 |
}
|
| 4394 |
|
| 4395 |
/** @returns {boolean} */
|
| 4396 |
_is_typing_anywhere() {
|
| 4397 |
const a = document.activeElement;
|
| 4398 |
const tag = a?.tagName;
|
| 4399 |
if ( tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || (a?.isContentEditable === true) ) {
|
| 4400 |
return true;
|
| 4401 |
}
|
| 4402 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 4403 |
return !!(ins && a && ins.contains( a ));
|
| 4404 |
}
|
| 4405 |
};
|
| 4406 |
|
| 4407 |
/**
|
| 4408 |
* Column resize logic for section rows.
|
| 4409 |
*/
|
| 4410 |
UI.WPBC_BFB_Resize_Controller = class extends UI.WPBC_BFB_Module {
|
| 4411 |
init() {
|
| 4412 |
this.builder.init_resize_handler = this.handle_resize.bind( this );
|
| 4413 |
}
|
| 4414 |
|
| 4415 |
/**
|
| 4416 |
* read the CSS var (kept local so it doesn’t depend on the Min-Width module)
|
| 4417 |
*
|
| 4418 |
* @param col
|
| 4419 |
* @returns {number|number}
|
| 4420 |
* @private
|
| 4421 |
*/
|
| 4422 |
_get_col_min_px(col) {
|
| 4423 |
const v = getComputedStyle( col ).getPropertyValue( '--wpbc-col-min' ) || '0';
|
| 4424 |
const n = parseFloat( v );
|
| 4425 |
return Number.isFinite( n ) ? Math.max( 0, n ) : 0;
|
| 4426 |
}
|
| 4427 |
|
| 4428 |
/** @param {MouseEvent} e */
|
| 4429 |
handle_resize(e) {
|
| 4430 |
const b = this.builder;
|
| 4431 |
e.preventDefault();
|
| 4432 |
if ( e.button !== 0 ) return;
|
| 4433 |
|
| 4434 |
const resizer = e.currentTarget;
|
| 4435 |
const row_el = resizer.parentElement;
|
| 4436 |
const cols = Array.from( row_el.querySelectorAll( ':scope > .wpbc_bfb__column' ) );
|
| 4437 |
const left_col = resizer?.previousElementSibling;
|
| 4438 |
const right_col = resizer?.nextElementSibling;
|
| 4439 |
if ( !left_col || !right_col || !left_col.classList.contains( 'wpbc_bfb__column' ) || !right_col.classList.contains( 'wpbc_bfb__column' ) ) return;
|
| 4440 |
|
| 4441 |
const left_index = cols.indexOf( left_col );
|
| 4442 |
const right_index = cols.indexOf( right_col );
|
| 4443 |
if ( left_index === -1 || right_index !== left_index + 1 ) return;
|
| 4444 |
|
| 4445 |
const start_x = e.clientX;
|
| 4446 |
const left_start_px = left_col.getBoundingClientRect().width;
|
| 4447 |
const right_start_px = right_col.getBoundingClientRect().width;
|
| 4448 |
const pair_px = Math.max( 0, left_start_px + right_start_px );
|
| 4449 |
|
| 4450 |
const gp = b.col_gap_percent;
|
| 4451 |
const computed = b.layout.compute_effective_bases_from_row( row_el, gp );
|
| 4452 |
const available = computed.available; // % of the “full 100” after gaps
|
| 4453 |
const bases = computed.bases.slice( 0 ); // current effective %
|
| 4454 |
const pair_avail = bases[left_index] + bases[right_index];
|
| 4455 |
|
| 4456 |
// Bail if we can’t compute sane deltas.
|
| 4457 |
if (!pair_px || !Number.isFinite(pair_avail) || pair_avail <= 0) return;
|
| 4458 |
|
| 4459 |
// --- MIN CLAMPS (pixels) -------------------------------------------------
|
| 4460 |
const pctToPx = (pct) => (pair_px * (pct / pair_avail)); // pair-local percent -> px
|
| 4461 |
const genericMinPct = Math.min( 0.1, available ); // original 0.1% floor (in “available %” space)
|
| 4462 |
const genericMinPx = pctToPx( genericMinPct );
|
| 4463 |
|
| 4464 |
const leftMinPx = Math.max( this._get_col_min_px( left_col ), genericMinPx );
|
| 4465 |
const rightMinPx = Math.max( this._get_col_min_px( right_col ), genericMinPx );
|
| 4466 |
|
| 4467 |
// freeze text selection + cursor
|
| 4468 |
const prev_user_select = document.body.style.userSelect;
|
| 4469 |
document.body.style.userSelect = 'none';
|
| 4470 |
row_el.style.cursor = 'col-resize';
|
| 4471 |
|
| 4472 |
const on_mouse_move = (ev) => {
|
| 4473 |
if ( !pair_px ) return;
|
| 4474 |
|
| 4475 |
// work in pixels, clamp by each side’s min
|
| 4476 |
const delta_px = ev.clientX - start_x;
|
| 4477 |
let newLeftPx = left_start_px + delta_px;
|
| 4478 |
newLeftPx = Math.max( leftMinPx, Math.min( pair_px - rightMinPx, newLeftPx ) );
|
| 4479 |
const newRightPx = pair_px - newLeftPx;
|
| 4480 |
|
| 4481 |
// translate back to pair-local percentages
|
| 4482 |
const newLeftPct = (newLeftPx / pair_px) * pair_avail;
|
| 4483 |
const newBases = bases.slice( 0 );
|
| 4484 |
newBases[left_index] = newLeftPct;
|
| 4485 |
newBases[right_index] = pair_avail - newLeftPct;
|
| 4486 |
|
| 4487 |
b.layout.apply_bases_to_row( row_el, newBases );
|
| 4488 |
};
|
| 4489 |
|
| 4490 |
const on_mouse_up = () => {
|
| 4491 |
document.removeEventListener( 'mousemove', on_mouse_move );
|
| 4492 |
document.removeEventListener( 'mouseup', on_mouse_up );
|
| 4493 |
window.removeEventListener( 'mouseup', on_mouse_up );
|
| 4494 |
document.removeEventListener( 'mouseleave', on_mouse_up );
|
| 4495 |
document.body.style.userSelect = prev_user_select || '';
|
| 4496 |
row_el.style.cursor = '';
|
| 4497 |
|
| 4498 |
// normalize to the row’s available % again
|
| 4499 |
const normalized = b.layout.compute_effective_bases_from_row( row_el, gp );
|
| 4500 |
b.layout.apply_bases_to_row( row_el, normalized.bases );
|
| 4501 |
};
|
| 4502 |
|
| 4503 |
document.addEventListener( 'mousemove', on_mouse_move );
|
| 4504 |
document.addEventListener( 'mouseup', on_mouse_up );
|
| 4505 |
window.addEventListener( 'mouseup', on_mouse_up );
|
| 4506 |
document.addEventListener( 'mouseleave', on_mouse_up );
|
| 4507 |
}
|
| 4508 |
|
| 4509 |
};
|
| 4510 |
|
| 4511 |
/**
|
| 4512 |
* Page and section creation, rebuilding, and nested Sortable setup.
|
| 4513 |
*/
|
| 4514 |
UI.WPBC_BFB_Pages_Sections = class extends UI.WPBC_BFB_Module {
|
| 4515 |
|
| 4516 |
init() {
|
| 4517 |
this.builder.add_page = (opts) => this.add_page( opts );
|
| 4518 |
this.builder.add_section = (container, cols) => this.add_section( container, cols );
|
| 4519 |
this.builder.rebuild_section = (section_data, container) => this.rebuild_section( section_data, container );
|
| 4520 |
this.builder.init_all_nested_sortables = (el) => this.init_all_nested_sortables( el );
|
| 4521 |
this.builder.init_section_sortable = (el) => this.init_section_sortable( el );
|
| 4522 |
this.builder.pages_sections = this;
|
| 4523 |
}
|
| 4524 |
|
| 4525 |
/**
|
| 4526 |
* Give every field/section in a cloned subtree a fresh data-uid so
|
| 4527 |
* uniqueness checks don't exclude their originals.
|
| 4528 |
*/
|
| 4529 |
_retag_uids_in_subtree(root) {
|
| 4530 |
const b = this.builder;
|
| 4531 |
if ( !root ) return;
|
| 4532 |
const nodes = [];
|
| 4533 |
if ( root.classList?.contains( 'wpbc_bfb__section' ) || root.classList?.contains( 'wpbc_bfb__field' ) ) {
|
| 4534 |
nodes.push( root );
|
| 4535 |
}
|
| 4536 |
nodes.push( ...root.querySelectorAll( '.wpbc_bfb__section, .wpbc_bfb__field' ) );
|
| 4537 |
nodes.forEach( (el) => {
|
| 4538 |
const prefix = el.classList.contains( 'wpbc_bfb__section' ) ? 's' : 'f';
|
| 4539 |
el.dataset.uid = `${prefix}-${++b._uid_counter}-${Date.now()}-${Math.random().toString( 36 ).slice( 2, 7 )}`;
|
| 4540 |
} );
|
| 4541 |
}
|
| 4542 |
|
| 4543 |
/**
|
| 4544 |
* Bump "foo", "foo-2", "foo-3", ...
|
| 4545 |
*/
|
| 4546 |
_make_unique(base, taken) {
|
| 4547 |
const s = Core.WPBC_BFB_Sanitize;
|
| 4548 |
let v = String( base || '' );
|
| 4549 |
if ( !v ) v = 'field';
|
| 4550 |
const m = v.match( /-(\d+)$/ );
|
| 4551 |
let n = m ? (parseInt( m[1], 10 ) || 1) : 1;
|
| 4552 |
let stem = m ? v.replace( /-\d+$/, '' ) : v;
|
| 4553 |
while ( taken.has( v ) ) {
|
| 4554 |
n = Math.max( 2, n + 1 );
|
| 4555 |
v = `${stem}-${n}`;
|
| 4556 |
}
|
| 4557 |
taken.add( v );
|
| 4558 |
return v;
|
| 4559 |
}
|
| 4560 |
|
| 4561 |
/**
|
| 4562 |
* Strict, one-pass de-duplication for a newly-inserted subtree.
|
| 4563 |
* - Ensures unique data-id (internal), data-name (fields), data-html_id (public)
|
| 4564 |
* - Also updates DOM: <section id>, <input id>, <label for>, and input[name].
|
| 4565 |
*/
|
| 4566 |
_dedupe_subtree_strict(root) {
|
| 4567 |
const b = this.builder;
|
| 4568 |
const s = Core.WPBC_BFB_Sanitize;
|
| 4569 |
if ( !root || !b?.pages_container ) return;
|
| 4570 |
|
| 4571 |
// 1) Build "taken" sets from outside the subtree.
|
| 4572 |
const takenDataId = new Set();
|
| 4573 |
const takenDataName = new Set();
|
| 4574 |
const takenHtmlId = new Set();
|
| 4575 |
const takenDomId = new Set();
|
| 4576 |
|
| 4577 |
// All fields/sections outside root
|
| 4578 |
b.pages_container.querySelectorAll( '.wpbc_bfb__field, .wpbc_bfb__section' ).forEach( el => {
|
| 4579 |
if ( root.contains( el ) ) return;
|
| 4580 |
const did = el.getAttribute( 'data-id' );
|
| 4581 |
const dnam = el.getAttribute( 'data-name' );
|
| 4582 |
const hid = el.getAttribute( 'data-html_id' );
|
| 4583 |
if ( did ) takenDataId.add( did );
|
| 4584 |
if ( dnam ) takenDataName.add( dnam );
|
| 4585 |
if ( hid ) takenHtmlId.add( hid );
|
| 4586 |
} );
|
| 4587 |
|
| 4588 |
// All DOM ids outside root (labels, inputs, anything)
|
| 4589 |
document.querySelectorAll( '[id]' ).forEach( el => {
|
| 4590 |
if ( root.contains( el ) ) return;
|
| 4591 |
if ( el.id ) takenDomId.add( el.id );
|
| 4592 |
} );
|
| 4593 |
|
| 4594 |
const nodes = [];
|
| 4595 |
if ( root.classList?.contains( 'wpbc_bfb__section' ) || root.classList?.contains( 'wpbc_bfb__field' ) ) {
|
| 4596 |
nodes.push( root );
|
| 4597 |
}
|
| 4598 |
nodes.push( ...root.querySelectorAll( '.wpbc_bfb__section, .wpbc_bfb__field' ) );
|
| 4599 |
|
| 4600 |
// 2) Walk the subtree and fix collisions deterministically.
|
| 4601 |
nodes.forEach( el => {
|
| 4602 |
const isField = el.classList.contains( 'wpbc_bfb__field' );
|
| 4603 |
const isSection = el.classList.contains( 'wpbc_bfb__section' );
|
| 4604 |
|
| 4605 |
// INTERNAL data-id
|
| 4606 |
{
|
| 4607 |
const raw = el.getAttribute( 'data-id' ) || '';
|
| 4608 |
const base = s.sanitize_html_id( raw ) || (isSection ? 'section' : 'field');
|
| 4609 |
const uniq = this._make_unique( base, takenDataId );
|
| 4610 |
if ( uniq !== raw ) el.setAttribute( 'data-id', uniq );
|
| 4611 |
}
|
| 4612 |
|
| 4613 |
// HTML name (fields only)
|
| 4614 |
if ( isField ) {
|
| 4615 |
const raw = el.getAttribute( 'data-name' ) || '';
|
| 4616 |
if ( raw ) {
|
| 4617 |
const base = s.sanitize_html_name( raw );
|
| 4618 |
const uniq = this._make_unique( base, takenDataName );
|
| 4619 |
if ( uniq !== raw ) {
|
| 4620 |
el.setAttribute( 'data-name', uniq );
|
| 4621 |
// Update inner control immediately
|
| 4622 |
const input = el.querySelector( 'input, textarea, select' );
|
| 4623 |
if ( input ) input.setAttribute( 'name', uniq );
|
| 4624 |
}
|
| 4625 |
}
|
| 4626 |
}
|
| 4627 |
|
| 4628 |
// Public HTML id (fields + sections)
|
| 4629 |
{
|
| 4630 |
const raw = el.getAttribute( 'data-html_id' ) || '';
|
| 4631 |
if ( raw ) {
|
| 4632 |
const base = s.sanitize_html_id( raw );
|
| 4633 |
// Reserve against BOTH known data-html_id and real DOM ids.
|
| 4634 |
const combinedTaken = new Set( [ ...takenHtmlId, ...takenDomId ] );
|
| 4635 |
let candidate = this._make_unique( base, combinedTaken );
|
| 4636 |
// Record into the real sets so future checks see the reservation.
|
| 4637 |
takenHtmlId.add( candidate );
|
| 4638 |
takenDomId.add( candidate );
|
| 4639 |
|
| 4640 |
if ( candidate !== raw ) el.setAttribute( 'data-html_id', candidate );
|
| 4641 |
|
| 4642 |
// Reflect to DOM immediately
|
| 4643 |
if ( isSection ) {
|
| 4644 |
el.id = candidate || '';
|
| 4645 |
} else {
|
| 4646 |
const input = el.querySelector( 'input, textarea, select' );
|
| 4647 |
const label = el.querySelector( 'label.wpbc_bfb__field-label' );
|
| 4648 |
if ( input ) input.id = candidate || '';
|
| 4649 |
if ( label ) label.htmlFor = candidate || '';
|
| 4650 |
}
|
| 4651 |
} else if ( isSection ) {
|
| 4652 |
// Ensure no stale DOM id if data-html_id was cleared
|
| 4653 |
el.removeAttribute( 'id' );
|
| 4654 |
}
|
| 4655 |
}
|
| 4656 |
} );
|
| 4657 |
}
|
| 4658 |
|
| 4659 |
_make_add_columns_control(page_el, section_container, insert_pos = 'bottom') {
|
| 4660 |
|
| 4661 |
// Accept insert_pos ('top'|'bottom'), default 'bottom'.
|
| 4662 |
|
| 4663 |
const tpl = document.getElementById( 'wpbc_bfb__add_columns_template' );
|
| 4664 |
if ( !tpl ) {
|
| 4665 |
return null;
|
| 4666 |
}
|
| 4667 |
|
| 4668 |
// Clone *contents* (not the id), unhide, and add a page-scoped class.
|
| 4669 |
const src = (tpl.content && tpl.content.firstElementChild) ? tpl.content.firstElementChild : tpl.firstElementChild;
|
| 4670 |
if ( !src ) {
|
| 4671 |
return null;
|
| 4672 |
}
|
| 4673 |
|
| 4674 |
const clone = src.cloneNode( true );
|
| 4675 |
clone.removeAttribute( 'hidden' );
|
| 4676 |
if ( clone.id ) {
|
| 4677 |
clone.removeAttribute( 'id' );
|
| 4678 |
}
|
| 4679 |
clone.querySelectorAll( '[id]' ).forEach( n => n.removeAttribute( 'id' ) );
|
| 4680 |
|
| 4681 |
// Mark where this control inserts sections.
|
| 4682 |
clone.dataset.insert = insert_pos; // 'top' | 'bottom'
|
| 4683 |
|
| 4684 |
// // Optional UI hint for users (keeps existing markup intact).
|
| 4685 |
// const hint = clone.querySelector( '.nav-tab-text .selected_value' );
|
| 4686 |
// if ( hint ) {
|
| 4687 |
// hint.textContent = (insert_pos === 'top') ? ' (add at top)' : ' (add at bottom)';
|
| 4688 |
// }
|
| 4689 |
|
| 4690 |
// Click on options - add section with N columns.
|
| 4691 |
clone.addEventListener( 'click', (e) => {
|
| 4692 |
const a = e.target.closest( '.ul_dropdown_menu_li_action_add_sections' );
|
| 4693 |
if ( !a ) {
|
| 4694 |
return;
|
| 4695 |
}
|
| 4696 |
e.preventDefault();
|
| 4697 |
|
| 4698 |
// Read N either from data-cols or fallback to parsing text like "3 Columns".
|
| 4699 |
let cols = parseInt( a.dataset.cols || (a.textContent.match( /\b(\d+)\s*Column/i )?.[1] ?? '1'), 10 );
|
| 4700 |
cols = Math.max( 1, Math.min( 4, cols ) );
|
| 4701 |
|
| 4702 |
// NEW: honor the control's insertion position
|
| 4703 |
this.add_section( section_container, cols, insert_pos );
|
| 4704 |
|
| 4705 |
// Reflect last choice (unchanged)
|
| 4706 |
const val = clone.querySelector( '.selected_value' );
|
| 4707 |
if ( val ) {
|
| 4708 |
val.textContent = ` (${cols})`;
|
| 4709 |
}
|
| 4710 |
} );
|
| 4711 |
|
| 4712 |
return clone;
|
| 4713 |
}
|
| 4714 |
|
| 4715 |
/**
|
| 4716 |
* @param {{scroll?: boolean}} [opts = {}]
|
| 4717 |
* @returns {HTMLElement}
|
| 4718 |
*/
|
| 4719 |
add_page({ scroll = true } = {}) {
|
| 4720 |
const b = this.builder;
|
| 4721 |
const page_el = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__panel wpbc_bfb__panel--preview wpbc_bfb_form wpbc_container wpbc_form wpbc_container_booking_form' );
|
| 4722 |
page_el.setAttribute( 'data-page', ++b.page_counter );
|
| 4723 |
|
| 4724 |
// "Page 1 | X" - Render page Title with Remove X button.
|
| 4725 |
const controls_html = UI.render_wp_template( 'wpbc-bfb-tpl-page-remove', { page_number: b.page_counter } );
|
| 4726 |
page_el.innerHTML = controls_html + '<div class="wpbc_bfb__form_preview_section_container wpbc_wizard__border_container"></div>';
|
| 4727 |
|
| 4728 |
b.pages_container.appendChild( page_el );
|
| 4729 |
if ( scroll ) {
|
| 4730 |
page_el.scrollIntoView( { behavior: 'smooth', block: 'start' } );
|
| 4731 |
}
|
| 4732 |
|
| 4733 |
const section_container = page_el.querySelector( '.wpbc_bfb__form_preview_section_container' );
|
| 4734 |
const section_count_on_add_page = 2;
|
| 4735 |
this.init_section_sortable( section_container );
|
| 4736 |
this.add_section( section_container, section_count_on_add_page );
|
| 4737 |
|
| 4738 |
// Dropdown control cloned from the hidden template.
|
| 4739 |
const controls_host_top = page_el.querySelector( '.wpbc_bfb__controls' );
|
| 4740 |
const ctrl_top = this._make_add_columns_control( page_el, section_container, 'top' );
|
| 4741 |
if ( ctrl_top ) {
|
| 4742 |
controls_host_top.appendChild( ctrl_top );
|
| 4743 |
}
|
| 4744 |
// Bottom control bar after the section container.
|
| 4745 |
const controls_host_bottom = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__controls wpbc_bfb__controls--bottom' );
|
| 4746 |
section_container.after( controls_host_bottom );
|
| 4747 |
const ctrl_bottom = this._make_add_columns_control( page_el, section_container, 'bottom' );
|
| 4748 |
if ( ctrl_bottom ) {
|
| 4749 |
controls_host_bottom.appendChild( ctrl_bottom );
|
| 4750 |
}
|
| 4751 |
|
| 4752 |
return page_el;
|
| 4753 |
}
|
| 4754 |
|
| 4755 |
/**
|
| 4756 |
* @param {HTMLElement} container
|
| 4757 |
* @param {number} cols
|
| 4758 |
* @param {'top'|'bottom'} [insert_pos='bottom'] // NEW
|
| 4759 |
*/
|
| 4760 |
add_section(container, cols, insert_pos = 'bottom') {
|
| 4761 |
const b = this.builder;
|
| 4762 |
cols = Math.max( 1, parseInt( cols, 10 ) || 1 );
|
| 4763 |
|
| 4764 |
const section = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__section' );
|
| 4765 |
section.setAttribute( 'data-id', `section-${++b.section_counter}-${Date.now()}` );
|
| 4766 |
section.setAttribute( 'data-uid', `s-${++b._uid_counter}-${Date.now()}-${Math.random().toString( 36 ).slice( 2, 7 )}` );
|
| 4767 |
section.setAttribute( 'data-type', 'section' );
|
| 4768 |
section.setAttribute( 'data-label', 'Section' );
|
| 4769 |
section.setAttribute( 'data-columns', String( cols ) );
|
| 4770 |
// Do not persist or seed per-column styles by default (opt-in via inspector).
|
| 4771 |
|
| 4772 |
const row = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__row wpbc__row' );
|
| 4773 |
for ( let i = 0; i < cols; i++ ) {
|
| 4774 |
const col = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__column wpbc__field' );
|
| 4775 |
col.style.flexBasis = (100 / cols) + '%';
|
| 4776 |
// No default CSS vars here; real columns remain unaffected until user activates styles.
|
| 4777 |
b.init_sortable?.( col );
|
| 4778 |
row.appendChild( col );
|
| 4779 |
if ( i < cols - 1 ) {
|
| 4780 |
const resizer = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__column-resizer' );
|
| 4781 |
resizer.addEventListener( 'mousedown', b.init_resize_handler );
|
| 4782 |
row.appendChild( resizer );
|
| 4783 |
}
|
| 4784 |
}
|
| 4785 |
section.appendChild( row );
|
| 4786 |
b.layout.set_equal_bases( row, b.col_gap_percent );
|
| 4787 |
b.add_overlay_toolbar( section );
|
| 4788 |
section.setAttribute( 'tabindex', '0' );
|
| 4789 |
this.init_all_nested_sortables( section );
|
| 4790 |
|
| 4791 |
// Insertion policy: top | bottom.
|
| 4792 |
if ( insert_pos === 'top' && container.firstElementChild ) {
|
| 4793 |
container.insertBefore( section, container.firstElementChild );
|
| 4794 |
} else {
|
| 4795 |
container.appendChild( section );
|
| 4796 |
}
|
| 4797 |
}
|
| 4798 |
|
| 4799 |
/**
|
| 4800 |
* @param {Object} section_data
|
| 4801 |
* @param {HTMLElement} container
|
| 4802 |
* @returns {HTMLElement} The rebuilt section element.
|
| 4803 |
*/
|
| 4804 |
rebuild_section(section_data, container) {
|
| 4805 |
const b = this.builder;
|
| 4806 |
const cols_data = Array.isArray( section_data?.columns ) ? section_data.columns : [];
|
| 4807 |
this.add_section( container, cols_data.length || 1 );
|
| 4808 |
const section = container.lastElementChild;
|
| 4809 |
if ( !section.dataset.uid ) {
|
| 4810 |
section.setAttribute( 'data-uid', `s-${++b._uid_counter}-${Date.now()}-${Math.random().toString( 36 ).slice( 2, 7 )}` );
|
| 4811 |
}
|
| 4812 |
section.setAttribute( 'data-id', section_data?.id || `section-${++b.section_counter}-${Date.now()}` );
|
| 4813 |
section.setAttribute( 'data-type', 'section' );
|
| 4814 |
section.setAttribute( 'data-label', section_data?.label || 'Section' );
|
| 4815 |
section.setAttribute( 'data-columns', String( (section_data?.columns || []).length || 1 ) );
|
| 4816 |
// Persisted attributes
|
| 4817 |
if ( section_data?.html_id ) {
|
| 4818 |
section.setAttribute( 'data-html_id', String( section_data.html_id ) );
|
| 4819 |
// give the container a real id so anchors/CSS can target it
|
| 4820 |
section.id = String( section_data.html_id );
|
| 4821 |
}
|
| 4822 |
|
| 4823 |
// NEW: restore persisted per-column styles (raw JSON string).
|
| 4824 |
if ( section_data?.col_styles != null ) {
|
| 4825 |
const json = String( section_data.col_styles );
|
| 4826 |
section.setAttribute( 'data-col_styles', json );
|
| 4827 |
try {
|
| 4828 |
section.dataset.col_styles = json;
|
| 4829 |
} catch ( _e ) {
|
| 4830 |
}
|
| 4831 |
}
|
| 4832 |
// (No render_preview() call here on purpose: sections’ builder DOM uses .wpbc_bfb__row/.wpbc_bfb__column.)
|
| 4833 |
|
| 4834 |
|
| 4835 |
if ( section_data?.cssclass ) {
|
| 4836 |
section.setAttribute( 'data-cssclass', String( section_data.cssclass ) );
|
| 4837 |
// keep core classes, then add custom class(es)
|
| 4838 |
String( section_data.cssclass ).split( /\s+/ ).filter( Boolean ).forEach( cls => section.classList.add( cls ) );
|
| 4839 |
}
|
| 4840 |
|
| 4841 |
const row = section.querySelector( '.wpbc_bfb__row' );
|
| 4842 |
// Delegate parsing + activation + application to the Column Styles service.
|
| 4843 |
try {
|
| 4844 |
const json = section.getAttribute( 'data-col_styles' )
|
| 4845 |
|| (section.dataset ? (section.dataset.col_styles || '') : '');
|
| 4846 |
const arr = UI.WPBC_BFB_Column_Styles.parse_col_styles( json );
|
| 4847 |
UI.WPBC_BFB_Column_Styles.apply( section, arr );
|
| 4848 |
} catch ( _e ) {
|
| 4849 |
}
|
| 4850 |
|
| 4851 |
cols_data.forEach( (col_data, index) => {
|
| 4852 |
const columns_only = row.querySelectorAll( ':scope > .wpbc_bfb__column' );
|
| 4853 |
const col = columns_only[index];
|
| 4854 |
col.style.flexBasis = col_data.width || '100%';
|
| 4855 |
(col_data.items || []).forEach( (item) => {
|
| 4856 |
if ( !item || !item.type ) {
|
| 4857 |
return;
|
| 4858 |
}
|
| 4859 |
if ( item.type === 'field' ) {
|
| 4860 |
const el = b.build_field( item.data );
|
| 4861 |
if ( el ) {
|
| 4862 |
col.appendChild( el );
|
| 4863 |
b.trigger_field_drop_callback( el, 'load' );
|
| 4864 |
}
|
| 4865 |
return;
|
| 4866 |
}
|
| 4867 |
if ( item.type === 'section' ) {
|
| 4868 |
this.rebuild_section( item.data, col );
|
| 4869 |
}
|
| 4870 |
} );
|
| 4871 |
} );
|
| 4872 |
const computed = b.layout.compute_effective_bases_from_row( row, b.col_gap_percent );
|
| 4873 |
b.layout.apply_bases_to_row( row, computed.bases );
|
| 4874 |
this.init_all_nested_sortables( section );
|
| 4875 |
|
| 4876 |
// NEW: retag UIDs first (so uniqueness checks don't exclude originals), then dedupe all keys.
|
| 4877 |
this._retag_uids_in_subtree( section );
|
| 4878 |
this._dedupe_subtree_strict( section );
|
| 4879 |
return section;
|
| 4880 |
}
|
| 4881 |
|
| 4882 |
/** @param {HTMLElement} container */
|
| 4883 |
init_all_nested_sortables(container) {
|
| 4884 |
const b = this.builder;
|
| 4885 |
if ( container.classList.contains( 'wpbc_bfb__form_preview_section_container' ) ) {
|
| 4886 |
this.init_section_sortable( container );
|
| 4887 |
}
|
| 4888 |
container.querySelectorAll( '.wpbc_bfb__section' ).forEach( (section) => {
|
| 4889 |
section.querySelectorAll( '.wpbc_bfb__column' ).forEach( (col) => {
|
| 4890 |
this.init_section_sortable( col );
|
| 4891 |
} );
|
| 4892 |
} );
|
| 4893 |
}
|
| 4894 |
|
| 4895 |
/** @param {HTMLElement} container */
|
| 4896 |
init_section_sortable(container) {
|
| 4897 |
const b = this.builder;
|
| 4898 |
if ( !container ) {
|
| 4899 |
return;
|
| 4900 |
}
|
| 4901 |
const is_column = container.classList.contains( 'wpbc_bfb__column' );
|
| 4902 |
const is_top_level = container.classList.contains( 'wpbc_bfb__form_preview_section_container' );
|
| 4903 |
if ( !is_column && !is_top_level ) {
|
| 4904 |
return;
|
| 4905 |
}
|
| 4906 |
b.init_sortable?.( container );
|
| 4907 |
}
|
| 4908 |
};
|
| 4909 |
|
| 4910 |
/**
|
| 4911 |
* Serialization and deserialization of pages/sections/fields.
|
| 4912 |
*/
|
| 4913 |
UI.WPBC_BFB_Structure_IO = class extends UI.WPBC_BFB_Module {
|
| 4914 |
init() {
|
| 4915 |
this.builder.get_structure = () => this.serialize();
|
| 4916 |
this.builder.load_saved_structure = (s, opts) => this.deserialize( s, opts );
|
| 4917 |
}
|
| 4918 |
|
| 4919 |
/**
|
| 4920 |
* Normalize option values when a field explicitly disables separate values.
|
| 4921 |
*
|
| 4922 |
* Older Builder versions persisted an unchecked value_differs toggle as an
|
| 4923 |
* empty string. Treat that explicit legacy value as false, while retaining
|
| 4924 |
* the schema default when the property is genuinely absent.
|
| 4925 |
*
|
| 4926 |
* @param {Object} field_data Serialized field data.
|
| 4927 |
* @returns {Object} Normalized serialized field data.
|
| 4928 |
*/
|
| 4929 |
_normalize_field_option_values(field_data) {
|
| 4930 |
const has_value_differs = Object.prototype.hasOwnProperty.call( field_data, 'value_differs' );
|
| 4931 |
if ( !has_value_differs ) {
|
| 4932 |
return field_data;
|
| 4933 |
}
|
| 4934 |
|
| 4935 |
const value_differs = Core.WPBC_BFB_Sanitize.coerce_boolean( field_data.value_differs, false );
|
| 4936 |
field_data.value_differs = value_differs;
|
| 4937 |
|
| 4938 |
if ( !value_differs && Array.isArray( field_data.options ) ) {
|
| 4939 |
field_data.options = field_data.options.map( ( option_record ) => {
|
| 4940 |
if ( !option_record || typeof option_record !== 'object' ) {
|
| 4941 |
return option_record;
|
| 4942 |
}
|
| 4943 |
|
| 4944 |
return Object.assign(
|
| 4945 |
{},
|
| 4946 |
option_record,
|
| 4947 |
{ value: String( option_record.label == null ? '' : option_record.label ) }
|
| 4948 |
);
|
| 4949 |
} );
|
| 4950 |
}
|
| 4951 |
|
| 4952 |
return field_data;
|
| 4953 |
}
|
| 4954 |
|
| 4955 |
/** @returns {Array} */
|
| 4956 |
serialize() {
|
| 4957 |
const b = this.builder;
|
| 4958 |
this._normalize_ids();
|
| 4959 |
this._normalize_names();
|
| 4960 |
const pages = [];
|
| 4961 |
b.pages_container.querySelectorAll( '.wpbc_bfb__panel--preview' ).forEach( (page_el, page_index) => {
|
| 4962 |
const container = page_el.querySelector( '.wpbc_bfb__form_preview_section_container' );
|
| 4963 |
const content = [];
|
| 4964 |
if ( !container ) {
|
| 4965 |
pages.push( { page: page_index + 1, content } );
|
| 4966 |
return;
|
| 4967 |
}
|
| 4968 |
container.querySelectorAll( ':scope > *' ).forEach( (child) => {
|
| 4969 |
if ( child.classList.contains( 'wpbc_bfb__section' ) ) {
|
| 4970 |
content.push( { type: 'section', data: this.serialize_section( child ) } );
|
| 4971 |
return;
|
| 4972 |
}
|
| 4973 |
if ( child.classList.contains( 'wpbc_bfb__field' ) ) {
|
| 4974 |
if ( child.classList.contains( 'is-invalid' ) ) {
|
| 4975 |
return;
|
| 4976 |
}
|
| 4977 |
const f_data = this._normalize_field_option_values(
|
| 4978 |
Core.WPBC_Form_Builder_Helper.get_all_data_attributes( child )
|
| 4979 |
);
|
| 4980 |
// Drop ephemeral/editor-only flags
|
| 4981 |
[ 'uid', 'fresh', 'autoname', 'was_loaded', 'name_user_touched' ]
|
| 4982 |
.forEach( k => {
|
| 4983 |
if ( k in f_data ) delete f_data[k];
|
| 4984 |
} );
|
| 4985 |
content.push( { type: 'field', data: f_data } );
|
| 4986 |
}
|
| 4987 |
} );
|
| 4988 |
pages.push( { page: page_index + 1, content } );
|
| 4989 |
} );
|
| 4990 |
return pages;
|
| 4991 |
}
|
| 4992 |
|
| 4993 |
/**
|
| 4994 |
* @param {HTMLElement} section_el
|
| 4995 |
* @returns {{id:string,label:string,html_id:string,cssclass:string,col_styles:string,columns:Array}}
|
| 4996 |
*/
|
| 4997 |
serialize_section(section_el) {
|
| 4998 |
const row = section_el.querySelector( ':scope > .wpbc_bfb__row' );
|
| 4999 |
|
| 5000 |
// NEW: read per-column styles from dataset/attributes (underscore & hyphen)
|
| 5001 |
var col_styles_raw =
|
| 5002 |
section_el.getAttribute( 'data-col_styles' ) ||
|
| 5003 |
(section_el.dataset ? (section_el.dataset.col_styles) : '') ||
|
| 5004 |
'';
|
| 5005 |
|
| 5006 |
const base = {
|
| 5007 |
id : section_el.dataset.id,
|
| 5008 |
label : section_el.dataset.label || '',
|
| 5009 |
html_id : section_el.dataset.html_id || '',
|
| 5010 |
cssclass : section_el.dataset.cssclass || '',
|
| 5011 |
col_styles: String( col_styles_raw ) // <-- NEW: keep as raw JSON string
|
| 5012 |
};
|
| 5013 |
|
| 5014 |
if ( !row ) {
|
| 5015 |
return Object.assign( {}, base, { columns: [] } );
|
| 5016 |
}
|
| 5017 |
|
| 5018 |
const columns = [];
|
| 5019 |
row.querySelectorAll( ':scope > .wpbc_bfb__column' ).forEach( function (col) {
|
| 5020 |
const width = col.style.flexBasis || '100%';
|
| 5021 |
const items = [];
|
| 5022 |
Array.prototype.forEach.call( col.children, function (child) {
|
| 5023 |
if ( child.classList.contains( 'wpbc_bfb__section' ) ) {
|
| 5024 |
items.push( { type: 'section', data: this.serialize_section( child ) } );
|
| 5025 |
return;
|
| 5026 |
}
|
| 5027 |
if ( child.classList.contains( 'wpbc_bfb__field' ) ) {
|
| 5028 |
if ( child.classList.contains( 'is-invalid' ) ) {
|
| 5029 |
return;
|
| 5030 |
}
|
| 5031 |
const f_data = this._normalize_field_option_values(
|
| 5032 |
Core.WPBC_Form_Builder_Helper.get_all_data_attributes( child )
|
| 5033 |
);
|
| 5034 |
[ 'uid', 'fresh', 'autoname', 'was_loaded', 'name_user_touched' ].forEach( function (k) {
|
| 5035 |
if ( k in f_data ) {
|
| 5036 |
delete f_data[k];
|
| 5037 |
}
|
| 5038 |
} );
|
| 5039 |
items.push( { type: 'field', data: f_data } );
|
| 5040 |
}
|
| 5041 |
}.bind( this ) );
|
| 5042 |
columns.push( { width: width, items: items } );
|
| 5043 |
}.bind( this ) );
|
| 5044 |
|
| 5045 |
// Clamp persisted col_styles to the actual number of columns on Save.
|
| 5046 |
try {
|
| 5047 |
const colCount = columns.length;
|
| 5048 |
const raw = String( col_styles_raw || '' ).trim();
|
| 5049 |
|
| 5050 |
if ( raw ) {
|
| 5051 |
let arr = [];
|
| 5052 |
try {
|
| 5053 |
const parsed = JSON.parse( raw );
|
| 5054 |
arr = Array.isArray( parsed ) ? parsed : (parsed && Array.isArray( parsed.columns ) ? parsed.columns : []);
|
| 5055 |
} catch ( _e ) {
|
| 5056 |
arr = [];
|
| 5057 |
}
|
| 5058 |
|
| 5059 |
if ( colCount <= 0 ) {
|
| 5060 |
base.col_styles = '[]';
|
| 5061 |
} else {
|
| 5062 |
if ( arr.length > colCount ) arr.length = colCount;
|
| 5063 |
while ( arr.length < colCount ) arr.push( {} );
|
| 5064 |
base.col_styles = JSON.stringify( arr );
|
| 5065 |
}
|
| 5066 |
} else {
|
| 5067 |
base.col_styles = '';
|
| 5068 |
}
|
| 5069 |
} catch ( _e ) {
|
| 5070 |
}
|
| 5071 |
|
| 5072 |
return Object.assign( {}, base, { columns: columns } );
|
| 5073 |
}
|
| 5074 |
|
| 5075 |
/**
|
| 5076 |
* @param {Array} structure
|
| 5077 |
* @param {{deferIfTyping?: boolean}} [opts = {}]
|
| 5078 |
*/
|
| 5079 |
deserialize(structure, { deferIfTyping = true } = {}) {
|
| 5080 |
const b = this.builder;
|
| 5081 |
if ( deferIfTyping && this._is_typing_in_inspector() ) {
|
| 5082 |
clearTimeout( this._defer_timer );
|
| 5083 |
this._defer_timer = setTimeout( () => {
|
| 5084 |
this.deserialize( structure, { deferIfTyping: false } );
|
| 5085 |
}, 150 );
|
| 5086 |
return;
|
| 5087 |
}
|
| 5088 |
b.pages_container.innerHTML = '';
|
| 5089 |
b.page_counter = 0;
|
| 5090 |
(structure || []).forEach( (page_data) => {
|
| 5091 |
const page_el = b.pages_sections.add_page( { scroll: false } );
|
| 5092 |
const section_container = page_el.querySelector( '.wpbc_bfb__form_preview_section_container' );
|
| 5093 |
section_container.innerHTML = '';
|
| 5094 |
b.init_section_sortable?.( section_container );
|
| 5095 |
(page_data.content || []).forEach( (item) => {
|
| 5096 |
if ( item.type === 'section' ) {
|
| 5097 |
// Now returns the element; attributes (incl. col_styles) are applied inside rebuild.
|
| 5098 |
b.pages_sections.rebuild_section( item.data, section_container );
|
| 5099 |
return;
|
| 5100 |
}
|
| 5101 |
if ( item.type === 'field' ) {
|
| 5102 |
const el = b.build_field( item.data );
|
| 5103 |
if ( el ) {
|
| 5104 |
section_container.appendChild( el );
|
| 5105 |
b.trigger_field_drop_callback( el, 'load' );
|
| 5106 |
}
|
| 5107 |
}
|
| 5108 |
} );
|
| 5109 |
} );
|
| 5110 |
b.usage?.update_palette_ui?.();
|
| 5111 |
b.bus.emit( Core.WPBC_BFB_Events.STRUCTURE_LOADED, { structure } );
|
| 5112 |
}
|
| 5113 |
|
| 5114 |
_normalize_ids() {
|
| 5115 |
const b = this.builder;
|
| 5116 |
b.pages_container.querySelectorAll( '.wpbc_bfb__panel--preview .wpbc_bfb__field:not(.is-invalid)' ).forEach( (el) => {
|
| 5117 |
const data = Core.WPBC_Form_Builder_Helper.get_all_data_attributes( el );
|
| 5118 |
const want = Core.WPBC_BFB_Sanitize.sanitize_html_id( data.id || '' ) || 'field';
|
| 5119 |
const uniq = b.id.ensure_unique_field_id( want, el );
|
| 5120 |
if ( data.id !== uniq ) {
|
| 5121 |
el.setAttribute( 'data-id', uniq );
|
| 5122 |
if ( b.preview_mode ) {
|
| 5123 |
b.render_preview( el );
|
| 5124 |
}
|
| 5125 |
}
|
| 5126 |
} );
|
| 5127 |
}
|
| 5128 |
|
| 5129 |
_normalize_names() {
|
| 5130 |
const b = this.builder;
|
| 5131 |
b.pages_container.querySelectorAll( '.wpbc_bfb__panel--preview .wpbc_bfb__field:not(.is-invalid)' ).forEach( (el) => {
|
| 5132 |
const data = Core.WPBC_Form_Builder_Helper.get_all_data_attributes( el );
|
| 5133 |
const base = Core.WPBC_BFB_Sanitize.sanitize_html_name( (data.name != null) ? data.name : data.id ) || 'field';
|
| 5134 |
const uniq = b.id.ensure_unique_field_name( base, el );
|
| 5135 |
if ( data.name !== uniq ) {
|
| 5136 |
el.setAttribute( 'data-name', uniq );
|
| 5137 |
if ( b.preview_mode ) {
|
| 5138 |
b.render_preview( el );
|
| 5139 |
}
|
| 5140 |
}
|
| 5141 |
} );
|
| 5142 |
}
|
| 5143 |
|
| 5144 |
/** @returns {boolean} */
|
| 5145 |
_is_typing_in_inspector() {
|
| 5146 |
const ins = document.getElementById( 'wpbc_bfb__inspector' );
|
| 5147 |
return !!(ins && document.activeElement && ins.contains( document.activeElement ));
|
| 5148 |
}
|
| 5149 |
};
|
| 5150 |
|
| 5151 |
/**
|
| 5152 |
* Minimal, standalone guard that enforces per-column min widths based on fields' data-min_width.
|
| 5153 |
*
|
| 5154 |
* @type {UI.WPBC_BFB_Min_Width_Guard}
|
| 5155 |
*/
|
| 5156 |
UI.WPBC_BFB_Min_Width_Guard = class extends UI.WPBC_BFB_Module {
|
| 5157 |
|
| 5158 |
constructor(builder) {
|
| 5159 |
super( builder );
|
| 5160 |
this._on_field_add = this._on_field_add.bind( this );
|
| 5161 |
this._on_field_remove = this._on_field_remove.bind( this );
|
| 5162 |
this._on_structure_loaded = this._on_structure_loaded.bind( this );
|
| 5163 |
this._on_structure_change = this._on_structure_change.bind( this );
|
| 5164 |
this._on_window_resize = this._on_window_resize.bind( this );
|
| 5165 |
|
| 5166 |
this._pending_rows = new Set();
|
| 5167 |
this._pending_all = false;
|
| 5168 |
this._raf_id = 0;
|
| 5169 |
}
|
| 5170 |
|
| 5171 |
init() {
|
| 5172 |
const EV = Core.WPBC_BFB_Events;
|
| 5173 |
this.builder?.bus?.on?.( EV.FIELD_ADD, this._on_field_add );
|
| 5174 |
this.builder?.bus?.on?.( EV.FIELD_REMOVE, this._on_field_remove );
|
| 5175 |
this.builder?.bus?.on?.( EV.STRUCTURE_LOADED, this._on_structure_loaded );
|
| 5176 |
// Refresh selectively on structure change (NOT on every prop input).
|
| 5177 |
this.builder?.bus?.on?.( EV.STRUCTURE_CHANGE, this._on_structure_change );
|
| 5178 |
|
| 5179 |
window.addEventListener( 'resize', this._on_window_resize, { passive: true } );
|
| 5180 |
this._schedule_refresh_all();
|
| 5181 |
}
|
| 5182 |
|
| 5183 |
destroy() {
|
| 5184 |
const EV = Core.WPBC_BFB_Events;
|
| 5185 |
this.builder?.bus?.off?.( EV.FIELD_ADD, this._on_field_add );
|
| 5186 |
this.builder?.bus?.off?.( EV.FIELD_REMOVE, this._on_field_remove );
|
| 5187 |
this.builder?.bus?.off?.( EV.STRUCTURE_LOADED, this._on_structure_loaded );
|
| 5188 |
this.builder?.bus?.off?.( EV.STRUCTURE_CHANGE, this._on_structure_change );
|
| 5189 |
window.removeEventListener( 'resize', this._on_window_resize );
|
| 5190 |
}
|
| 5191 |
|
| 5192 |
_on_field_add(e) {
|
| 5193 |
this._schedule_refresh_all();
|
| 5194 |
// if you really want to be minimal work here, keep your row-only version.
|
| 5195 |
}
|
| 5196 |
|
| 5197 |
_on_field_remove(e) {
|
| 5198 |
const src_el = e?.detail?.el || null;
|
| 5199 |
const row = (src_el && src_el.closest) ? src_el.closest( '.wpbc_bfb__row' ) : null;
|
| 5200 |
if ( row ) {
|
| 5201 |
this._schedule_refresh_row( row );
|
| 5202 |
} else {
|
| 5203 |
this._schedule_refresh_all();
|
| 5204 |
}
|
| 5205 |
}
|
| 5206 |
|
| 5207 |
_on_structure_loaded() {
|
| 5208 |
this._schedule_refresh_all();
|
| 5209 |
}
|
| 5210 |
|
| 5211 |
_on_structure_change(e) {
|
| 5212 |
const reason = e?.detail?.reason || '';
|
| 5213 |
const key = e?.detail?.key || '';
|
| 5214 |
|
| 5215 |
// Ignore noisy prop changes that don't affect min widths.
|
| 5216 |
if ( reason === 'prop-change' && key !== 'min_width' ) {
|
| 5217 |
return;
|
| 5218 |
}
|
| 5219 |
|
| 5220 |
const el = e?.detail?.el || null;
|
| 5221 |
const row = el?.closest?.( '.wpbc_bfb__row' ) || null;
|
| 5222 |
if ( row ) {
|
| 5223 |
this._schedule_refresh_row( row );
|
| 5224 |
} else {
|
| 5225 |
this._schedule_refresh_all();
|
| 5226 |
}
|
| 5227 |
}
|
| 5228 |
|
| 5229 |
_on_window_resize() {
|
| 5230 |
this._schedule_refresh_all();
|
| 5231 |
}
|
| 5232 |
|
| 5233 |
_schedule_refresh_row(row_el) {
|
| 5234 |
if ( !row_el ) return;
|
| 5235 |
this._pending_rows.add( row_el );
|
| 5236 |
this._kick_raf();
|
| 5237 |
}
|
| 5238 |
|
| 5239 |
_schedule_refresh_all() {
|
| 5240 |
this._pending_all = true;
|
| 5241 |
this._pending_rows.clear();
|
| 5242 |
this._kick_raf();
|
| 5243 |
}
|
| 5244 |
|
| 5245 |
_kick_raf() {
|
| 5246 |
if ( this._raf_id ) return;
|
| 5247 |
this._raf_id = (window.requestAnimationFrame || setTimeout)( () => {
|
| 5248 |
this._raf_id = 0;
|
| 5249 |
if ( this._pending_all ) {
|
| 5250 |
this._pending_all = false;
|
| 5251 |
this.refresh_all();
|
| 5252 |
return;
|
| 5253 |
}
|
| 5254 |
const rows = Array.from( this._pending_rows );
|
| 5255 |
this._pending_rows.clear();
|
| 5256 |
rows.forEach( (r) => this.refresh_row( r ) );
|
| 5257 |
}, 0 );
|
| 5258 |
}
|
| 5259 |
|
| 5260 |
|
| 5261 |
refresh_all() {
|
| 5262 |
this.builder?.pages_container
|
| 5263 |
?.querySelectorAll?.( '.wpbc_bfb__row' )
|
| 5264 |
?.forEach?.( (row) => this.refresh_row( row ) );
|
| 5265 |
}
|
| 5266 |
|
| 5267 |
refresh_row(row_el) {
|
| 5268 |
if ( !row_el ) return;
|
| 5269 |
|
| 5270 |
const cols = row_el.querySelectorAll( ':scope > .wpbc_bfb__column' );
|
| 5271 |
|
| 5272 |
// 1) Recalculate each column’s required min px and write it to the CSS var.
|
| 5273 |
cols.forEach( (col) => this.apply_col_min( col ) );
|
| 5274 |
|
| 5275 |
// 2) Enforce it at the CSS level right away so layout can’t render narrower.
|
| 5276 |
cols.forEach( (col) => {
|
| 5277 |
const px = parseFloat( getComputedStyle( col ).getPropertyValue( '--wpbc-col-min' ) || '0' ) || 0;
|
| 5278 |
col.style.minWidth = px > 0 ? Math.round( px ) + 'px' : '';
|
| 5279 |
} );
|
| 5280 |
|
| 5281 |
// 3) Normalize current bases so the row respects all mins without overflow.
|
| 5282 |
try {
|
| 5283 |
const b = this.builder;
|
| 5284 |
const gp = b.col_gap_percent;
|
| 5285 |
const eff = b.layout.compute_effective_bases_from_row( row_el, gp ); // { bases, available }
|
| 5286 |
// Re-fit *current* bases against mins (same algorithm layout chips use).
|
| 5287 |
const fitted = UI.WPBC_BFB_Layout_Chips._fit_weights_respecting_min( b, row_el, eff.bases );
|
| 5288 |
if ( Array.isArray( fitted ) ) {
|
| 5289 |
const changed = fitted.some( (v, i) => Math.abs( v - eff.bases[i] ) > 0.01 );
|
| 5290 |
if ( changed ) {
|
| 5291 |
b.layout.apply_bases_to_row( row_el, fitted );
|
| 5292 |
}
|
| 5293 |
}
|
| 5294 |
} catch ( e ) {
|
| 5295 |
w._wpbc?.dev?.error?.( 'WPBC_BFB_Min_Width_Guard - refresh_row', e );
|
| 5296 |
}
|
| 5297 |
}
|
| 5298 |
|
| 5299 |
apply_col_min(col_el) {
|
| 5300 |
if ( !col_el ) return;
|
| 5301 |
let max_px = 0;
|
| 5302 |
const colRect = col_el.getBoundingClientRect();
|
| 5303 |
col_el.querySelectorAll( ':scope > .wpbc_bfb__field' ).forEach( (field) => {
|
| 5304 |
const raw = field.getAttribute( 'data-min_width' );
|
| 5305 |
let px = 0;
|
| 5306 |
if ( raw ) {
|
| 5307 |
const s = String( raw ).trim().toLowerCase();
|
| 5308 |
if ( s.endsWith( '%' ) ) {
|
| 5309 |
const n = parseFloat( s );
|
| 5310 |
if ( Number.isFinite( n ) && colRect.width > 0 ) {
|
| 5311 |
px = (n / 100) * colRect.width;
|
| 5312 |
} else {
|
| 5313 |
px = 0;
|
| 5314 |
}
|
| 5315 |
} else {
|
| 5316 |
px = this.parse_len_px( s );
|
| 5317 |
}
|
| 5318 |
} else {
|
| 5319 |
const cs = getComputedStyle( field );
|
| 5320 |
px = parseFloat( cs.minWidth || '0' ) || 0;
|
| 5321 |
}
|
| 5322 |
if ( px > max_px ) max_px = px;
|
| 5323 |
} );
|
| 5324 |
col_el.style.setProperty( '--wpbc-col-min', max_px > 0 ? Math.round( max_px ) + 'px' : '0px' );
|
| 5325 |
}
|
| 5326 |
|
| 5327 |
parse_len_px(value) {
|
| 5328 |
if ( value == null ) return 0;
|
| 5329 |
const s = String( value ).trim().toLowerCase();
|
| 5330 |
if ( s === '' ) return 0;
|
| 5331 |
if ( s.endsWith( 'px' ) ) {
|
| 5332 |
const n = parseFloat( s );
|
| 5333 |
return Number.isFinite( n ) ? n : 0;
|
| 5334 |
}
|
| 5335 |
if ( s.endsWith( 'rem' ) || s.endsWith( 'em' ) ) {
|
| 5336 |
const n = parseFloat( s );
|
| 5337 |
const base = parseFloat( getComputedStyle( document.documentElement ).fontSize ) || 16;
|
| 5338 |
return Number.isFinite( n ) ? n * base : 0;
|
| 5339 |
}
|
| 5340 |
const n = parseFloat( s );
|
| 5341 |
return Number.isFinite( n ) ? n : 0;
|
| 5342 |
}
|
| 5343 |
};
|
| 5344 |
|
| 5345 |
/**
|
| 5346 |
* WPBC_BFB_Toggle_Normalizer
|
| 5347 |
*
|
| 5348 |
* Converts plain checkboxes into toggle UI:
|
| 5349 |
* <div class="inspector__control wpbc_ui__toggle">
|
| 5350 |
* <input type="checkbox" id="{unique}" data-inspector-key="..." class="inspector__input" role="switch"
|
| 5351 |
* aria-checked="true|false">
|
| 5352 |
* <label class="wpbc_ui__toggle_icon" for="{unique}"></label>
|
| 5353 |
* <label class="wpbc_ui__toggle_label" for="{unique}">Label</label>
|
| 5354 |
* </div>
|
| 5355 |
*
|
| 5356 |
* - Skips inputs already inside `.wpbc_ui__toggle`.
|
| 5357 |
* - Reuses an existing <label for="..."> text if present; otherwise falls back to nearby labels or attributes.
|
| 5358 |
* - Auto-generates a unique id when absent.
|
| 5359 |
*/
|
| 5360 |
UI.WPBC_BFB_Toggle_Normalizer = class {
|
| 5361 |
|
| 5362 |
/**
|
| 5363 |
* Upgrade all raw checkboxes in a container to toggles.
|
| 5364 |
* @param {HTMLElement} root_el
|
| 5365 |
*/
|
| 5366 |
static upgrade_checkboxes_in(root_el) {
|
| 5367 |
|
| 5368 |
if ( !root_el || !root_el.querySelectorAll ) {
|
| 5369 |
return;
|
| 5370 |
}
|
| 5371 |
|
| 5372 |
var inputs = root_el.querySelectorAll( 'input[type="checkbox"]' );
|
| 5373 |
if ( !inputs.length ) {
|
| 5374 |
return;
|
| 5375 |
}
|
| 5376 |
|
| 5377 |
Array.prototype.forEach.call( inputs, function (input) {
|
| 5378 |
|
| 5379 |
// 1) Skip if already inside toggle wrapper.
|
| 5380 |
if ( input.closest( '.wpbc_ui__toggle' ) ) {
|
| 5381 |
return;
|
| 5382 |
}
|
| 5383 |
// Skip rows / where input checkbox explicitly marked with attribute 'data-wpbc-ui-no-toggle'.
|
| 5384 |
if ( input.hasAttribute( 'data-wpbc-ui-no-toggle' ) ) {
|
| 5385 |
return;
|
| 5386 |
}
|
| 5387 |
|
| 5388 |
// 2) Ensure unique id; prefer existing.
|
| 5389 |
var input_id = input.getAttribute( 'id' );
|
| 5390 |
if ( !input_id ) {
|
| 5391 |
var key = (input.dataset && input.dataset.inspectorKey) ? String( input.dataset.inspectorKey ) : 'opt';
|
| 5392 |
input_id = UI.WPBC_BFB_Toggle_Normalizer.generate_unique_id( 'wpbc_ins_auto_' + key + '_' );
|
| 5393 |
input.setAttribute( 'id', input_id );
|
| 5394 |
}
|
| 5395 |
|
| 5396 |
// 3) Find best label text.
|
| 5397 |
var label_text = UI.WPBC_BFB_Toggle_Normalizer.resolve_label_text( root_el, input, input_id );
|
| 5398 |
|
| 5399 |
// 4) Build the toggle wrapper.
|
| 5400 |
var wrapper = document.createElement( 'div' );
|
| 5401 |
wrapper.className = 'inspector__control wpbc_ui__toggle';
|
| 5402 |
|
| 5403 |
// Keep original input; just move it into wrapper.
|
| 5404 |
input.classList.add( 'inspector__input' );
|
| 5405 |
input.setAttribute( 'role', 'switch' );
|
| 5406 |
input.setAttribute( 'aria-checked', input.checked ? 'true' : 'false' );
|
| 5407 |
|
| 5408 |
var icon_label = document.createElement( 'label' );
|
| 5409 |
icon_label.className = 'wpbc_ui__toggle_icon';
|
| 5410 |
icon_label.setAttribute( 'for', input_id );
|
| 5411 |
|
| 5412 |
var text_label = document.createElement( 'label' );
|
| 5413 |
text_label.className = 'wpbc_ui__toggle_label';
|
| 5414 |
text_label.setAttribute( 'for', input_id );
|
| 5415 |
text_label.appendChild( document.createTextNode( label_text ) );
|
| 5416 |
|
| 5417 |
// 5) Insert wrapper into DOM near the input.
|
| 5418 |
// Preferred: replace the original labeled row if it matches typical inspector layout.
|
| 5419 |
var replaced = UI.WPBC_BFB_Toggle_Normalizer.try_replace_known_row( input, wrapper, label_text );
|
| 5420 |
|
| 5421 |
if ( !replaced ) {
|
| 5422 |
if ( !input.parentNode ) return; // NEW guard
|
| 5423 |
// Fallback: just wrap the input in place and append labels.
|
| 5424 |
input.parentNode.insertBefore( wrapper, input );
|
| 5425 |
wrapper.appendChild( input );
|
| 5426 |
wrapper.appendChild( icon_label );
|
| 5427 |
wrapper.appendChild( text_label );
|
| 5428 |
}
|
| 5429 |
|
| 5430 |
// 6) ARIA sync on change.
|
| 5431 |
input.addEventListener( 'change', function () {
|
| 5432 |
input.setAttribute( 'aria-checked', input.checked ? 'true' : 'false' );
|
| 5433 |
} );
|
| 5434 |
} );
|
| 5435 |
}
|
| 5436 |
|
| 5437 |
/**
|
| 5438 |
* Generate a unique id with a given prefix.
|
| 5439 |
* @param {string} prefix
|
| 5440 |
* @returns {string}
|
| 5441 |
*/
|
| 5442 |
static generate_unique_id(prefix) {
|
| 5443 |
var base = String( prefix || 'wpbc_ins_auto_' );
|
| 5444 |
var uid = Math.random().toString( 36 ).slice( 2, 8 );
|
| 5445 |
var id = base + uid;
|
| 5446 |
// Minimal collision guard in the current document scope.
|
| 5447 |
while ( document.getElementById( id ) ) {
|
| 5448 |
uid = Math.random().toString( 36 ).slice( 2, 8 );
|
| 5449 |
id = base + uid;
|
| 5450 |
}
|
| 5451 |
return id;
|
| 5452 |
}
|
| 5453 |
|
| 5454 |
/**
|
| 5455 |
* Resolve the best human label for an input.
|
| 5456 |
* Priority:
|
| 5457 |
* 1) <label for="{id}">text</label>
|
| 5458 |
* 2) nearest sibling/parent .inspector__label text
|
| 5459 |
* 3) input.getAttribute('aria-label') || data-label || data-inspector-key || name || 'Option'
|
| 5460 |
* @param {HTMLElement} root_el
|
| 5461 |
* @param {HTMLInputElement} input
|
| 5462 |
* @param {string} input_id
|
| 5463 |
* @returns {string}
|
| 5464 |
*/
|
| 5465 |
static resolve_label_text(root_el, input, input_id) {
|
| 5466 |
// for= association
|
| 5467 |
if ( input_id ) {
|
| 5468 |
var assoc = root_el.querySelector( 'label[for="' + UI.WPBC_BFB_Toggle_Normalizer.css_escape( input_id ) + '"]' );
|
| 5469 |
if ( assoc && assoc.textContent ) {
|
| 5470 |
var txt = assoc.textContent.trim();
|
| 5471 |
// Remove the old label from DOM; its text will be used by toggle.
|
| 5472 |
assoc.parentNode && assoc.parentNode.removeChild( assoc );
|
| 5473 |
if ( txt ) {
|
| 5474 |
return txt;
|
| 5475 |
}
|
| 5476 |
}
|
| 5477 |
}
|
| 5478 |
|
| 5479 |
// nearby inspector label
|
| 5480 |
var near_label = input.closest( '.inspector__row' );
|
| 5481 |
if ( near_label ) {
|
| 5482 |
var il = near_label.querySelector( '.inspector__label' );
|
| 5483 |
if ( il && il.textContent ) {
|
| 5484 |
var t2 = il.textContent.trim();
|
| 5485 |
// If this row had the standard label+control, drop the old text label to avoid duplicates.
|
| 5486 |
il.parentNode && il.parentNode.removeChild( il );
|
| 5487 |
if ( t2 ) {
|
| 5488 |
return t2;
|
| 5489 |
}
|
| 5490 |
}
|
| 5491 |
}
|
| 5492 |
|
| 5493 |
// fallbacks
|
| 5494 |
var aria = input.getAttribute( 'aria-label' );
|
| 5495 |
if ( aria ) {
|
| 5496 |
return aria;
|
| 5497 |
}
|
| 5498 |
if ( input.dataset && input.dataset.label ) {
|
| 5499 |
return String( input.dataset.label );
|
| 5500 |
}
|
| 5501 |
if ( input.dataset && input.dataset.inspectorKey ) {
|
| 5502 |
return String( input.dataset.inspectorKey );
|
| 5503 |
}
|
| 5504 |
if ( input.name ) {
|
| 5505 |
return String( input.name );
|
| 5506 |
}
|
| 5507 |
return 'Option';
|
| 5508 |
}
|
| 5509 |
|
| 5510 |
/**
|
| 5511 |
* Try to replace a known inspector row pattern with a toggle wrapper.
|
| 5512 |
* Patterns:
|
| 5513 |
* <div.inspector__row>
|
| 5514 |
* <label.inspector__label>Text</label>
|
| 5515 |
* <div.inspector__control> [input[type=checkbox]] </div>
|
| 5516 |
* </div>
|
| 5517 |
*
|
| 5518 |
* @param {HTMLInputElement} input
|
| 5519 |
* @param {HTMLElement} wrapper
|
| 5520 |
* @returns {boolean} replaced
|
| 5521 |
*/
|
| 5522 |
static try_replace_known_row(input, wrapper, label_text) {
|
| 5523 |
var row = input.closest( '.inspector__row' );
|
| 5524 |
var ctrl_wrap = input.parentElement;
|
| 5525 |
|
| 5526 |
if ( row && ctrl_wrap && ctrl_wrap.classList.contains( 'inspector__control' ) ) {
|
| 5527 |
// Clear control wrap and reinsert toggle structure.
|
| 5528 |
while ( ctrl_wrap.firstChild ) {
|
| 5529 |
ctrl_wrap.removeChild( ctrl_wrap.firstChild );
|
| 5530 |
}
|
| 5531 |
row.classList.add( 'inspector__row--toggle' );
|
| 5532 |
|
| 5533 |
ctrl_wrap.classList.add( 'wpbc_ui__toggle' );
|
| 5534 |
ctrl_wrap.appendChild( input );
|
| 5535 |
|
| 5536 |
var input_id = input.getAttribute( 'id' );
|
| 5537 |
var icon_lbl = document.createElement( 'label' );
|
| 5538 |
icon_lbl.className = 'wpbc_ui__toggle_icon';
|
| 5539 |
icon_lbl.setAttribute( 'for', input_id );
|
| 5540 |
|
| 5541 |
var text_lbl = document.createElement( 'label' );
|
| 5542 |
text_lbl.className = 'wpbc_ui__toggle_label';
|
| 5543 |
text_lbl.setAttribute( 'for', input_id );
|
| 5544 |
if ( label_text ) {
|
| 5545 |
text_lbl.appendChild( document.createTextNode( label_text ) );
|
| 5546 |
}
|
| 5547 |
// If the row previously had a .inspector__label (we removed it in resolve_label_text),
|
| 5548 |
// we intentionally do NOT recreate it; the toggle text label becomes the visible one.
|
| 5549 |
// The text content is already resolved in resolve_label_text() and set below by caller.
|
| 5550 |
|
| 5551 |
ctrl_wrap.appendChild( icon_lbl );
|
| 5552 |
ctrl_wrap.appendChild( text_lbl );
|
| 5553 |
return true;
|
| 5554 |
}
|
| 5555 |
|
| 5556 |
// Not a known pattern; caller will wrap in place.
|
| 5557 |
return false;
|
| 5558 |
}
|
| 5559 |
|
| 5560 |
/**
|
| 5561 |
* CSS.escape polyfill for selectors.
|
| 5562 |
* @param {string} s
|
| 5563 |
* @returns {string}
|
| 5564 |
*/
|
| 5565 |
static css_escape(s) {
|
| 5566 |
s = String( s );
|
| 5567 |
if ( window.CSS && typeof window.CSS.escape === 'function' ) {
|
| 5568 |
return window.CSS.escape( s );
|
| 5569 |
}
|
| 5570 |
return s.replace( /([^\w-])/g, '\\$1' );
|
| 5571 |
}
|
| 5572 |
};
|
| 5573 |
|
| 5574 |
/**
|
| 5575 |
* Apply all UI normalizers/enhancers to a container (post-render).
|
| 5576 |
* Keep this file small and add more normalizers later in one place.
|
| 5577 |
*
|
| 5578 |
* @param {HTMLElement} root
|
| 5579 |
*/
|
| 5580 |
UI.apply_post_render = function (root) {
|
| 5581 |
if ( !root ) {
|
| 5582 |
return;
|
| 5583 |
}
|
| 5584 |
try {
|
| 5585 |
UI.WPBC_BFB_ValueSlider?.init_on?.( root );
|
| 5586 |
} catch ( e ) { /* noop */
|
| 5587 |
}
|
| 5588 |
try {
|
| 5589 |
var T = UI.WPBC_BFB_Toggle_Normalizer;
|
| 5590 |
if ( T && typeof T.upgrade_checkboxes_in === 'function' ) {
|
| 5591 |
T.upgrade_checkboxes_in( root );
|
| 5592 |
}
|
| 5593 |
} catch ( e ) {
|
| 5594 |
w._wpbc?.dev?.error?.( 'apply_post_render.toggle', e );
|
| 5595 |
}
|
| 5596 |
|
| 5597 |
// Accessibility: keep aria-checked in sync for all toggles inside root.
|
| 5598 |
try {
|
| 5599 |
root.querySelectorAll( '.wpbc_ui__toggle input[type="checkbox"]' ).forEach( function (cb) {
|
| 5600 |
if ( cb.__wpbc_aria_hooked ) {
|
| 5601 |
return;
|
| 5602 |
}
|
| 5603 |
cb.__wpbc_aria_hooked = true;
|
| 5604 |
cb.setAttribute( 'aria-checked', cb.checked ? 'true' : 'false' );
|
| 5605 |
// Delegate ‘change’ just once per render – native delegation still works fine for your logic.
|
| 5606 |
cb.addEventListener( 'change', () => {
|
| 5607 |
cb.setAttribute( 'aria-checked', cb.checked ? 'true' : 'false' );
|
| 5608 |
}, { passive: true } );
|
| 5609 |
} );
|
| 5610 |
} catch ( e ) {
|
| 5611 |
w._wpbc?.dev?.error?.( 'apply_post_render.aria', e );
|
| 5612 |
}
|
| 5613 |
};
|
| 5614 |
|
| 5615 |
UI.InspectorEnhancers = UI.InspectorEnhancers || (function () {
|
| 5616 |
var regs = [];
|
| 5617 |
|
| 5618 |
function register(name, selector, init, destroy) {
|
| 5619 |
regs.push( { name, selector, init, destroy } );
|
| 5620 |
}
|
| 5621 |
|
| 5622 |
function scan(root) {
|
| 5623 |
if ( !root ) return;
|
| 5624 |
regs.forEach( function (r) {
|
| 5625 |
root.querySelectorAll( r.selector ).forEach( function (node) {
|
| 5626 |
node.__wpbc_eh = node.__wpbc_eh || {};
|
| 5627 |
if ( node.__wpbc_eh[r.name] ) return;
|
| 5628 |
try {
|
| 5629 |
r.init && r.init( node, root );
|
| 5630 |
node.__wpbc_eh[r.name] = true;
|
| 5631 |
} catch ( _e ) {
|
| 5632 |
}
|
| 5633 |
} );
|
| 5634 |
} );
|
| 5635 |
}
|
| 5636 |
|
| 5637 |
function destroy(root) {
|
| 5638 |
if ( !root ) return;
|
| 5639 |
regs.forEach( function (r) {
|
| 5640 |
root.querySelectorAll( r.selector ).forEach( function (node) {
|
| 5641 |
try {
|
| 5642 |
r.destroy && r.destroy( node, root );
|
| 5643 |
} catch ( _e ) {
|
| 5644 |
}
|
| 5645 |
if ( node.__wpbc_eh ) delete node.__wpbc_eh[r.name];
|
| 5646 |
} );
|
| 5647 |
} );
|
| 5648 |
}
|
| 5649 |
|
| 5650 |
return { register, scan, destroy };
|
| 5651 |
})();
|
| 5652 |
|
| 5653 |
UI.WPBC_BFB_ValueSlider = {
|
| 5654 |
init_on(root) {
|
| 5655 |
var groups = (root.nodeType === 1 ? [ root ] : []).concat( [].slice.call( root.querySelectorAll?.( '[data-len-group]' ) || [] ) );
|
| 5656 |
groups.forEach( function (g) {
|
| 5657 |
if ( !g.matches || !g.matches( '[data-len-group]' ) ) return;
|
| 5658 |
if ( g.__wpbc_len_wired ) return;
|
| 5659 |
|
| 5660 |
var number = g.querySelector( '[data-len-value]' );
|
| 5661 |
var range = g.querySelector( '[data-len-range]' );
|
| 5662 |
var unit = g.querySelector( '[data-len-unit]' );
|
| 5663 |
|
| 5664 |
if ( !number || !range ) return;
|
| 5665 |
|
| 5666 |
// Mirror constraints if missing on the range.
|
| 5667 |
[ 'min', 'max', 'step' ].forEach( function (a) {
|
| 5668 |
if ( !range.hasAttribute( a ) && number.hasAttribute( a ) ) {
|
| 5669 |
range.setAttribute( a, number.getAttribute( a ) );
|
| 5670 |
}
|
| 5671 |
} );
|
| 5672 |
|
| 5673 |
|
| 5674 |
function sync_range_from_number() { |
| 5675 |
if ( g.hasAttribute( 'data-len-allow-empty' ) && '' === number.value ) { |
| 5676 |
var empty_range_value = range.min || '0'; |
| 5677 |
if ( range.value !== empty_range_value ) { |
| 5678 |
range.value = empty_range_value; |
| 5679 |
} |
| 5680 |
return; |
| 5681 |
} |
| 5682 |
if ( range.value !== number.value ) { |
| 5683 |
range.value = number.value;
|
| 5684 |
}
|
| 5685 |
}
|
| 5686 |
|
| 5687 |
function dispatch_input(el) {
|
| 5688 |
try { el.dispatchEvent( new Event( 'input', { bubbles: true } ) ); } catch ( _e ) {}
|
| 5689 |
}
|
| 5690 |
function dispatch_change(el) {
|
| 5691 |
try { el.dispatchEvent( new Event( 'change', { bubbles: true } ) ); } catch ( _e ) {}
|
| 5692 |
}
|
| 5693 |
|
| 5694 |
// Throttle range->number syncing (time-based).
|
| 5695 |
var timer_id = 0;
|
| 5696 |
var pending_val = null;
|
| 5697 |
var pending_change = false;
|
| 5698 |
var last_flush_ts = 0;
|
| 5699 |
|
| 5700 |
// Change this to tune speed: 50..120 ms is a good range.
|
| 5701 |
var min_interval_ms = parseInt( g.dataset.lenThrottle || UI.VALUE_SLIDER_THROTTLE_MS, 10 );
|
| 5702 |
min_interval_ms = Number.isFinite( min_interval_ms ) ? Math.max( 0, min_interval_ms ) : 120;
|
| 5703 |
|
| 5704 |
function flush_range_to_number() {
|
| 5705 |
timer_id = 0;
|
| 5706 |
|
| 5707 |
if ( pending_val == null ) {
|
| 5708 |
return;
|
| 5709 |
}
|
| 5710 |
|
| 5711 |
var next = String( pending_val );
|
| 5712 |
pending_val = null;
|
| 5713 |
|
| 5714 |
if ( number.value !== next ) {
|
| 5715 |
number.value = next;
|
| 5716 |
// IMPORTANT: only 'input' while dragging.
|
| 5717 |
dispatch_input( number );
|
| 5718 |
}
|
| 5719 |
|
| 5720 |
if ( pending_change ) {
|
| 5721 |
pending_change = false;
|
| 5722 |
dispatch_change( number );
|
| 5723 |
}
|
| 5724 |
|
| 5725 |
last_flush_ts = Date.now();
|
| 5726 |
}
|
| 5727 |
|
| 5728 |
function schedule_range_to_number(val, emit_change) {
|
| 5729 |
pending_val = val;
|
| 5730 |
if ( emit_change ) {
|
| 5731 |
pending_change = true;
|
| 5732 |
}
|
| 5733 |
|
| 5734 |
// If commit requested, flush immediately.
|
| 5735 |
if ( pending_change ) {
|
| 5736 |
if ( timer_id ) {
|
| 5737 |
clearTimeout( timer_id );
|
| 5738 |
timer_id = 0;
|
| 5739 |
}
|
| 5740 |
flush_range_to_number();
|
| 5741 |
return;
|
| 5742 |
}
|
| 5743 |
|
| 5744 |
var now = Date.now();
|
| 5745 |
var delta = now - last_flush_ts;
|
| 5746 |
|
| 5747 |
// If enough time passed, flush immediately; else schedule.
|
| 5748 |
if ( delta >= min_interval_ms ) {
|
| 5749 |
flush_range_to_number();
|
| 5750 |
return;
|
| 5751 |
}
|
| 5752 |
|
| 5753 |
if ( timer_id ) {
|
| 5754 |
return;
|
| 5755 |
}
|
| 5756 |
|
| 5757 |
timer_id = setTimeout( flush_range_to_number, Math.max( 0, min_interval_ms - delta ) );
|
| 5758 |
}
|
| 5759 |
|
| 5760 |
function on_number_input() {
|
| 5761 |
sync_range_from_number();
|
| 5762 |
}
|
| 5763 |
|
| 5764 |
function on_number_change() {
|
| 5765 |
sync_range_from_number();
|
| 5766 |
}
|
| 5767 |
|
| 5768 |
function on_range_input() {
|
| 5769 |
schedule_range_to_number( range.value, false );
|
| 5770 |
}
|
| 5771 |
|
| 5772 |
function on_range_change() {
|
| 5773 |
schedule_range_to_number( range.value, true );
|
| 5774 |
}
|
| 5775 |
|
| 5776 |
number.addEventListener( 'input', on_number_input );
|
| 5777 |
number.addEventListener( 'change', on_number_change );
|
| 5778 |
range.addEventListener( 'input', on_range_input );
|
| 5779 |
range.addEventListener( 'change', on_range_change );
|
| 5780 |
|
| 5781 |
if ( unit ) {
|
| 5782 |
unit.addEventListener( 'change', function () {
|
| 5783 |
// We just nudge the number so upstream handlers re-run.
|
| 5784 |
try {
|
| 5785 |
number.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 5786 |
} catch ( _e ) {
|
| 5787 |
}
|
| 5788 |
} );
|
| 5789 |
}
|
| 5790 |
|
| 5791 |
// Initial sync
|
| 5792 |
sync_range_from_number();
|
| 5793 |
|
| 5794 |
g.__wpbc_len_wired = {
|
| 5795 |
destroy() {
|
| 5796 |
number.removeEventListener( 'input', on_number_input );
|
| 5797 |
number.removeEventListener( 'change', on_number_change );
|
| 5798 |
range.removeEventListener( 'input', on_range_input );
|
| 5799 |
range.removeEventListener( 'change', on_range_change );
|
| 5800 |
}
|
| 5801 |
};
|
| 5802 |
} );
|
| 5803 |
},
|
| 5804 |
destroy_on(root) {
|
| 5805 |
var groups = (root && root.nodeType === 1 ? [ root ] : []).concat(
|
| 5806 |
[].slice.call( root.querySelectorAll?.( '[data-len-group]' ) || [] )
|
| 5807 |
);
|
| 5808 |
groups.forEach( function (g) {
|
| 5809 |
if ( !g.matches || !g.matches( '[data-len-group]' ) ) return;
|
| 5810 |
try {
|
| 5811 |
g.__wpbc_len_wired && g.__wpbc_len_wired.destroy && g.__wpbc_len_wired.destroy();
|
| 5812 |
} catch ( _e ) {
|
| 5813 |
}
|
| 5814 |
delete g.__wpbc_len_wired;
|
| 5815 |
} );
|
| 5816 |
}
|
| 5817 |
};
|
| 5818 |
|
| 5819 |
// Register with the global enhancers hub.
|
| 5820 |
UI.InspectorEnhancers && UI.InspectorEnhancers.register(
|
| 5821 |
'value-slider',
|
| 5822 |
'[data-len-group]',
|
| 5823 |
function (el, _root) {
|
| 5824 |
UI.WPBC_BFB_ValueSlider.init_on( el );
|
| 5825 |
},
|
| 5826 |
function (el, _root) {
|
| 5827 |
UI.WPBC_BFB_ValueSlider.destroy_on( el );
|
| 5828 |
}
|
| 5829 |
);
|
| 5830 |
|
| 5831 |
// Single, load-order-safe patch so enhancers auto-run on every bind.
|
| 5832 |
(function patchInspectorEnhancers() {
|
| 5833 |
function applyPatch() {
|
| 5834 |
var Inspector = w.WPBC_BFB_Inspector;
|
| 5835 |
if ( !Inspector || Inspector.__wpbc_enhancers_patched ) return false;
|
| 5836 |
Inspector.__wpbc_enhancers_patched = true;
|
| 5837 |
var orig = Inspector.prototype.bind_to_field;
|
| 5838 |
Inspector.prototype.bind_to_field = function (el) {
|
| 5839 |
orig.call( this, el );
|
| 5840 |
try {
|
| 5841 |
var ins = this.panel
|
| 5842 |
|| document.getElementById( 'wpbc_bfb__inspector' )
|
| 5843 |
|| document.querySelector( '.wpbc_bfb__inspector' );
|
| 5844 |
UI.InspectorEnhancers && UI.InspectorEnhancers.scan( ins );
|
| 5845 |
} catch ( _e ) {
|
| 5846 |
}
|
| 5847 |
};
|
| 5848 |
// Initial scan if the DOM is already present.
|
| 5849 |
try {
|
| 5850 |
var insEl = document.getElementById( 'wpbc_bfb__inspector' )
|
| 5851 |
|| document.querySelector( '.wpbc_bfb__inspector' );
|
| 5852 |
UI.InspectorEnhancers && UI.InspectorEnhancers.scan( insEl );
|
| 5853 |
} catch ( _e ) {
|
| 5854 |
}
|
| 5855 |
return true;
|
| 5856 |
}
|
| 5857 |
|
| 5858 |
// Try now; if Inspector isn’t defined yet, patch when it becomes ready.
|
| 5859 |
if ( !applyPatch() ) {
|
| 5860 |
document.addEventListener(
|
| 5861 |
'wpbc_bfb_inspector_ready',
|
| 5862 |
function () {
|
| 5863 |
applyPatch();
|
| 5864 |
},
|
| 5865 |
{ once: true }
|
| 5866 |
);
|
| 5867 |
}
|
| 5868 |
})();
|
| 5869 |
|
| 5870 |
}( window, document ));
|
| 5871 |
|
| 5872 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 5873 |
// == File /includes/page-form-builder/__js/core/bfb-sync-code-tools-tab.js | 2026-04-06 | 16:38
|
| 5874 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 5875 |
(function ( w, d ) {
|
| 5876 |
'use strict';
|
| 5877 |
|
| 5878 |
/**
|
| 5879 |
* Dispatch request to show a right sidebar panel.
|
| 5880 |
*
|
| 5881 |
* @param {string} panel_id
|
| 5882 |
* @param {string} tab_id
|
| 5883 |
*
|
| 5884 |
* @return {void}
|
| 5885 |
*/
|
| 5886 |
function wpbc_bfb__dispatch_show_panel( panel_id, tab_id ) {
|
| 5887 |
|
| 5888 |
var event_detail;
|
| 5889 |
|
| 5890 |
if ( ! panel_id || ! tab_id ) {
|
| 5891 |
return;
|
| 5892 |
}
|
| 5893 |
|
| 5894 |
event_detail = {
|
| 5895 |
panel_id: panel_id,
|
| 5896 |
tab_id : tab_id
|
| 5897 |
};
|
| 5898 |
|
| 5899 |
if ( typeof w.wpbc_bfb__dispatch_event_safe === 'function' ) {
|
| 5900 |
w.wpbc_bfb__dispatch_event_safe( 'wpbc_bfb:show_panel', event_detail );
|
| 5901 |
return;
|
| 5902 |
}
|
| 5903 |
|
| 5904 |
d.dispatchEvent(
|
| 5905 |
new CustomEvent(
|
| 5906 |
'wpbc_bfb:show_panel',
|
| 5907 |
{
|
| 5908 |
detail: event_detail
|
| 5909 |
}
|
| 5910 |
)
|
| 5911 |
);
|
| 5912 |
}
|
| 5913 |
|
| 5914 |
/**
|
| 5915 |
* Sync right sidebar with top mode tabs.
|
| 5916 |
*
|
| 5917 |
* Uses top tabs nav attribute `data-active-tab` as the source of truth.
|
| 5918 |
* This avoids false detection on initial page load, because top panels are
|
| 5919 |
* hidden by inline style `display:none`, not by the `hidden` attribute.
|
| 5920 |
*/
|
| 5921 |
class WPBC_BFB_Mode_Rightbar_Sync {
|
| 5922 |
|
| 5923 |
constructor() {
|
| 5924 |
this.top_tabs_nav = null;
|
| 5925 |
this.advanced_tab_wrap = null;
|
| 5926 |
this.advanced_panel = null;
|
| 5927 |
this.mutation_observer = null;
|
| 5928 |
this.last_mode = '';
|
| 5929 |
this.sync_rightbar_mode = this.sync_rightbar_mode.bind( this );
|
| 5930 |
this.handle_click = this.handle_click.bind( this );
|
| 5931 |
}
|
| 5932 |
|
| 5933 |
/**
|
| 5934 |
* Init controller.
|
| 5935 |
*
|
| 5936 |
* @return {void}
|
| 5937 |
*/
|
| 5938 |
init() {
|
| 5939 |
this.top_tabs_nav = d.getElementById( 'wpbc_bfb__top_horisontal_nav' );
|
| 5940 |
this.advanced_tab_wrap = d.querySelector( '.wpbc_bfb__rightbar_tab_wrap--advanced_tools' );
|
| 5941 |
this.advanced_panel = d.getElementById( 'wpbc_bfb__inspector_advanced_tools' );
|
| 5942 |
|
| 5943 |
if ( ! this.advanced_tab_wrap || ! this.advanced_panel ) {
|
| 5944 |
return;
|
| 5945 |
}
|
| 5946 |
|
| 5947 |
// Observe active tab changes in the top tabs nav.
|
| 5948 |
if ( this.top_tabs_nav ) {
|
| 5949 |
this.mutation_observer = new MutationObserver( this.sync_rightbar_mode );
|
| 5950 |
this.mutation_observer.observe(
|
| 5951 |
this.top_tabs_nav,
|
| 5952 |
{
|
| 5953 |
attributes : true,
|
| 5954 |
attributeFilter: [ 'data-active-tab' ]
|
| 5955 |
}
|
| 5956 |
);
|
| 5957 |
}
|
| 5958 |
|
| 5959 |
// Fallback for click-driven switching.
|
| 5960 |
d.addEventListener( 'click', this.handle_click, true );
|
| 5961 |
|
| 5962 |
// Initial sync.
|
| 5963 |
this.sync_rightbar_mode();
|
| 5964 |
}
|
| 5965 |
|
| 5966 |
/**
|
| 5967 |
* Get active top tab id.
|
| 5968 |
*
|
| 5969 |
* Priority:
|
| 5970 |
* 1. data-active-tab from top tabs nav
|
| 5971 |
* 2. active CSS class in nav
|
| 5972 |
* 3. visible top panel fallback
|
| 5973 |
*
|
| 5974 |
* @return {string}
|
| 5975 |
*/
|
| 5976 |
get_active_top_tab_id() {
|
| 5977 |
var active_tab_id = '';
|
| 5978 |
var active_link = null;
|
| 5979 |
var advanced_panel = null;
|
| 5980 |
var builder_panel = null;
|
| 5981 |
|
| 5982 |
if ( this.top_tabs_nav ) {
|
| 5983 |
active_tab_id = String( this.top_tabs_nav.getAttribute( 'data-active-tab' ) || '' ).trim();
|
| 5984 |
if ( '' !== active_tab_id ) {
|
| 5985 |
return active_tab_id;
|
| 5986 |
}
|
| 5987 |
|
| 5988 |
active_link = this.top_tabs_nav.querySelector( '.wpbc_ui_el__horis_nav_item.active [data-wpbc-bfb-tab]' );
|
| 5989 |
if ( active_link ) {
|
| 5990 |
active_tab_id = String( active_link.getAttribute( 'data-wpbc-bfb-tab' ) || '' ).trim();
|
| 5991 |
if ( '' !== active_tab_id ) {
|
| 5992 |
return active_tab_id;
|
| 5993 |
}
|
| 5994 |
}
|
| 5995 |
}
|
| 5996 |
|
| 5997 |
// Final fallback: detect visible panel.
|
| 5998 |
advanced_panel = d.querySelector( '.wpbc_bfb__top_tab_section__advanced_tab' );
|
| 5999 |
builder_panel = d.querySelector( '.wpbc_bfb__top_tab_section__builder_tab' );
|
| 6000 |
|
| 6001 |
if ( this.is_element_visible( advanced_panel ) ) {
|
| 6002 |
return 'advanced_tab';
|
| 6003 |
}
|
| 6004 |
if ( this.is_element_visible( builder_panel ) ) {
|
| 6005 |
return 'builder_tab';
|
| 6006 |
}
|
| 6007 |
|
| 6008 |
return '';
|
| 6009 |
}
|
| 6010 |
|
| 6011 |
/**
|
| 6012 |
* Check element visibility.
|
| 6013 |
*
|
| 6014 |
* @param {HTMLElement|null} el
|
| 6015 |
*
|
| 6016 |
* @return {boolean}
|
| 6017 |
*/
|
| 6018 |
is_element_visible( el ) {
|
| 6019 |
var style;
|
| 6020 |
|
| 6021 |
if ( ! el ) {
|
| 6022 |
return false;
|
| 6023 |
}
|
| 6024 |
|
| 6025 |
style = w.getComputedStyle( el );
|
| 6026 |
|
| 6027 |
if ( ! style ) {
|
| 6028 |
return false;
|
| 6029 |
}
|
| 6030 |
|
| 6031 |
if ( 'none' === style.display ) {
|
| 6032 |
return false;
|
| 6033 |
}
|
| 6034 |
|
| 6035 |
if ( 'hidden' === style.visibility ) {
|
| 6036 |
return false;
|
| 6037 |
}
|
| 6038 |
|
| 6039 |
return true;
|
| 6040 |
}
|
| 6041 |
|
| 6042 |
/**
|
| 6043 |
* Check if Advanced Mode is active.
|
| 6044 |
*
|
| 6045 |
* @return {boolean}
|
| 6046 |
*/
|
| 6047 |
is_advanced_mode_active() {
|
| 6048 |
return ( 'advanced_tab' === this.get_active_top_tab_id() );
|
| 6049 |
}
|
| 6050 |
|
| 6051 |
/**
|
| 6052 |
* Show Code Tools tab button.
|
| 6053 |
*
|
| 6054 |
* @return {void}
|
| 6055 |
*/
|
| 6056 |
show_advanced_tools_tab() {
|
| 6057 |
this.advanced_tab_wrap.removeAttribute( 'hidden' );
|
| 6058 |
this.advanced_tab_wrap.setAttribute( 'aria-hidden', 'false' );
|
| 6059 |
}
|
| 6060 |
|
| 6061 |
/**
|
| 6062 |
* Hide Code Tools tab button.
|
| 6063 |
*
|
| 6064 |
* @return {void}
|
| 6065 |
*/
|
| 6066 |
hide_advanced_tools_tab() {
|
| 6067 |
this.advanced_tab_wrap.setAttribute( 'hidden', 'true' );
|
| 6068 |
this.advanced_tab_wrap.setAttribute( 'aria-hidden', 'true' );
|
| 6069 |
}
|
| 6070 |
|
| 6071 |
/**
|
| 6072 |
* Check if Code Tools panel is currently active.
|
| 6073 |
*
|
| 6074 |
* @return {boolean}
|
| 6075 |
*/
|
| 6076 |
is_advanced_tools_panel_active() {
|
| 6077 |
return !! ( this.advanced_panel && ! this.advanced_panel.hasAttribute( 'hidden' ) );
|
| 6078 |
}
|
| 6079 |
|
| 6080 |
/**
|
| 6081 |
* Open Code Tools panel.
|
| 6082 |
*
|
| 6083 |
* @return {void}
|
| 6084 |
*/
|
| 6085 |
open_advanced_tools_panel() {
|
| 6086 |
wpbc_bfb__dispatch_show_panel( 'wpbc_bfb__inspector_advanced_tools', 'wpbc_tab_advanced_tools' );
|
| 6087 |
}
|
| 6088 |
|
| 6089 |
/**
|
| 6090 |
* Open default builder rightbar panel.
|
| 6091 |
*
|
| 6092 |
* @return {void}
|
| 6093 |
*/
|
| 6094 |
open_default_visual_panel() {
|
| 6095 |
wpbc_bfb__dispatch_show_panel( 'wpbc_bfb__palette_add_new', 'wpbc_tab_library' );
|
| 6096 |
}
|
| 6097 |
|
| 6098 |
/**
|
| 6099 |
* Sync rightbar mode with top tabs mode.
|
| 6100 |
*
|
| 6101 |
* @return {void}
|
| 6102 |
*/
|
| 6103 |
sync_rightbar_mode() {
|
| 6104 |
var is_advanced_mode = this.is_advanced_mode_active();
|
| 6105 |
|
| 6106 |
if ( is_advanced_mode ) {
|
| 6107 |
this.show_advanced_tools_tab();
|
| 6108 |
|
| 6109 |
if ( 'advanced' !== this.last_mode ) {
|
| 6110 |
this.open_advanced_tools_panel();
|
| 6111 |
}
|
| 6112 |
|
| 6113 |
this.last_mode = 'advanced';
|
| 6114 |
return;
|
| 6115 |
}
|
| 6116 |
|
| 6117 |
if ( this.is_advanced_tools_panel_active() ) {
|
| 6118 |
this.open_default_visual_panel();
|
| 6119 |
}
|
| 6120 |
|
| 6121 |
this.hide_advanced_tools_tab();
|
| 6122 |
this.last_mode = 'builder';
|
| 6123 |
}
|
| 6124 |
|
| 6125 |
/**
|
| 6126 |
* Fallback click handler for top tabs.
|
| 6127 |
*
|
| 6128 |
* @param {Event} event
|
| 6129 |
*
|
| 6130 |
* @return {void}
|
| 6131 |
*/
|
| 6132 |
handle_click( event ) {
|
| 6133 |
var target = event.target.closest( '[data-wpbc-bfb-tab]' );
|
| 6134 |
var this_obj = this;
|
| 6135 |
|
| 6136 |
if ( ! target ) {
|
| 6137 |
return;
|
| 6138 |
}
|
| 6139 |
|
| 6140 |
setTimeout(
|
| 6141 |
function () {
|
| 6142 |
this_obj.sync_rightbar_mode();
|
| 6143 |
},
|
| 6144 |
0
|
| 6145 |
);
|
| 6146 |
}
|
| 6147 |
}
|
| 6148 |
|
| 6149 |
if ( d.readyState === 'loading' ) {
|
| 6150 |
d.addEventListener(
|
| 6151 |
'DOMContentLoaded',
|
| 6152 |
function () {
|
| 6153 |
( new WPBC_BFB_Mode_Rightbar_Sync() ).init();
|
| 6154 |
}
|
| 6155 |
);
|
| 6156 |
} else {
|
| 6157 |
( new WPBC_BFB_Mode_Rightbar_Sync() ).init();
|
| 6158 |
}
|
| 6159 |
|
| 6160 |
})( window, document ); |
| 6161 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 6162 |
// == File /includes/page-form-builder/_out/core/bfb-inspector.js == Time point: 2025-09-06 14:08
|
| 6163 |
// ---------------------------------------------------------------------------------------------------------------------
|
| 6164 |
(function (w) {
|
| 6165 |
'use strict';
|
| 6166 |
|
| 6167 |
// 1) Actions registry.
|
| 6168 |
|
| 6169 |
/** @type {Record<string, (ctx: InspectorActionContext) => void>} */
|
| 6170 |
const __INSPECTOR_ACTIONS_MAP__ = Object.create( null );
|
| 6171 |
|
| 6172 |
// Built-ins.
|
| 6173 |
__INSPECTOR_ACTIONS_MAP__['deselect'] = ({ builder }) => {
|
| 6174 |
builder?.select_field?.( null );
|
| 6175 |
};
|
| 6176 |
|
| 6177 |
__INSPECTOR_ACTIONS_MAP__['scrollto'] = ({ builder, el }) => {
|
| 6178 |
if ( !el || !document.body.contains( el ) ) return;
|
| 6179 |
builder?.select_field?.( el, { scrollIntoView: true } );
|
| 6180 |
el.classList.add( 'wpbc_bfb__scroll-pulse' );
|
| 6181 |
setTimeout( () => el.classList.remove( 'wpbc_bfb__scroll-pulse' ), 700 );
|
| 6182 |
};
|
| 6183 |
|
| 6184 |
__INSPECTOR_ACTIONS_MAP__['move-up'] = ({ builder, el }) => {
|
| 6185 |
if ( !el ) return;
|
| 6186 |
builder?.move_item?.( el, 'up' );
|
| 6187 |
// Scroll after the DOM has settled.
|
| 6188 |
requestAnimationFrame(() => __INSPECTOR_ACTIONS_MAP__['scrollto']({ builder, el }));
|
| 6189 |
};
|
| 6190 |
|
| 6191 |
__INSPECTOR_ACTIONS_MAP__['move-down'] = ({ builder, el }) => {
|
| 6192 |
if ( !el ) return;
|
| 6193 |
builder?.move_item?.( el, 'down' );
|
| 6194 |
// Scroll after the DOM has settled.
|
| 6195 |
requestAnimationFrame(() => __INSPECTOR_ACTIONS_MAP__['scrollto']({ builder, el }));
|
| 6196 |
};
|
| 6197 |
|
| 6198 |
__INSPECTOR_ACTIONS_MAP__['delete'] = ({ builder, el, confirm = w.confirm }) => {
|
| 6199 |
if ( !el ) return;
|
| 6200 |
const is_field = el.classList.contains( 'wpbc_bfb__field' );
|
| 6201 |
const label = is_field
|
| 6202 |
? (el.querySelector( '.wpbc_bfb__field-label' )?.textContent || el.dataset?.id || 'field')
|
| 6203 |
: (el.dataset?.id || 'section');
|
| 6204 |
|
| 6205 |
UI.Modal_Confirm_Delete.open( label, () => {
|
| 6206 |
// Central command will remove, emit events, and reselect neighbor (which re-binds Inspector).
|
| 6207 |
builder?.delete_item?.( el );
|
| 6208 |
} );
|
| 6209 |
|
| 6210 |
};
|
| 6211 |
|
| 6212 |
__INSPECTOR_ACTIONS_MAP__['duplicate'] = ({ builder, el }) => {
|
| 6213 |
if ( !el ) return;
|
| 6214 |
const clone = builder?.duplicate_item?.( el );
|
| 6215 |
if ( clone ) builder?.select_field?.( clone, { scrollIntoView: true } );
|
| 6216 |
};
|
| 6217 |
|
| 6218 |
// Public API.
|
| 6219 |
w.WPBC_BFB_Inspector_Actions = {
|
| 6220 |
run(name, ctx) {
|
| 6221 |
const fn = __INSPECTOR_ACTIONS_MAP__[name];
|
| 6222 |
if ( typeof fn === 'function' ) fn( ctx );
|
| 6223 |
else console.warn( 'WPBC. Inspector action not found:', name );
|
| 6224 |
},
|
| 6225 |
register(name, handler) {
|
| 6226 |
if ( !name || typeof handler !== 'function' ) {
|
| 6227 |
throw new Error( 'register(name, handler): invalid arguments' );
|
| 6228 |
}
|
| 6229 |
__INSPECTOR_ACTIONS_MAP__[name] = handler;
|
| 6230 |
},
|
| 6231 |
has(name) {
|
| 6232 |
return typeof __INSPECTOR_ACTIONS_MAP__[name] === 'function';
|
| 6233 |
}
|
| 6234 |
};
|
| 6235 |
|
| 6236 |
// 2) Inspector Factory.
|
| 6237 |
|
| 6238 |
var UI = (w.WPBC_BFB_Core.UI = w.WPBC_BFB_Core.UI || {});
|
| 6239 |
|
| 6240 |
// Global Hybrid++ registries (keep public).
|
| 6241 |
w.wpbc_bfb_inspector_factory_slots = w.wpbc_bfb_inspector_factory_slots || {};
|
| 6242 |
w.wpbc_bfb_inspector_factory_value_from = w.wpbc_bfb_inspector_factory_value_from || {};
|
| 6243 |
|
| 6244 |
// Define Factory only if missing (no early return for the whole bundle).
|
| 6245 |
// always define/replace Factory
|
| 6246 |
{
|
| 6247 |
|
| 6248 |
/**
|
| 6249 |
* Utility: create element with attributes and children.
|
| 6250 |
*
|
| 6251 |
* @param {string} tag
|
| 6252 |
* @param {Object=} attrs
|
| 6253 |
* @param {(Node|string|Array<Node|string>)=} children
|
| 6254 |
* @returns {HTMLElement}
|
| 6255 |
*/
|
| 6256 |
function el(tag, attrs, children) {
|
| 6257 |
var node = document.createElement( tag );
|
| 6258 |
if ( attrs ) {
|
| 6259 |
Object.keys( attrs ).forEach( function (k) {
|
| 6260 |
var v = attrs[k];
|
| 6261 |
if ( v == null ) return;
|
| 6262 |
if ( k === 'class' ) {
|
| 6263 |
node.className = v;
|
| 6264 |
return;
|
| 6265 |
}
|
| 6266 |
if ( k === 'dataset' ) {
|
| 6267 |
Object.keys( v ).forEach( function (dk) {
|
| 6268 |
node.dataset[dk] = String( v[dk] );
|
| 6269 |
} );
|
| 6270 |
return;
|
| 6271 |
}
|
| 6272 |
if ( k === 'checked' && typeof v === 'boolean' ) {
|
| 6273 |
if ( v ) node.setAttribute( 'checked', 'checked' );
|
| 6274 |
return;
|
| 6275 |
}
|
| 6276 |
if ( k === 'disabled' && typeof v === 'boolean' ) {
|
| 6277 |
if ( v ) node.setAttribute( 'disabled', 'disabled' );
|
| 6278 |
return;
|
| 6279 |
}
|
| 6280 |
// normalize boolean attributes to strings.
|
| 6281 |
if ( typeof v === 'boolean' ) {
|
| 6282 |
node.setAttribute( k, v ? 'true' : 'false' );
|
| 6283 |
return;
|
| 6284 |
}
|
| 6285 |
node.setAttribute( k, String( v ) );
|
| 6286 |
} );
|
| 6287 |
}
|
| 6288 |
if ( children ) {
|
| 6289 |
(Array.isArray( children ) ? children : [ children ]).forEach( function (c) {
|
| 6290 |
if ( c == null ) return;
|
| 6291 |
node.appendChild( (typeof c === 'string') ? document.createTextNode( c ) : c );
|
| 6292 |
} );
|
| 6293 |
}
|
| 6294 |
return node;
|
| 6295 |
}
|
| 6296 |
|
| 6297 |
/**
|
| 6298 |
* Build a toggle control row (checkbox rendered as toggle).
|
| 6299 |
*
|
| 6300 |
* Structure:
|
| 6301 |
* <div class="inspector__row inspector__row--toggle">
|
| 6302 |
* <div class="inspector__control wpbc_ui__toggle">
|
| 6303 |
* <input type="checkbox" id="ID" data-inspector-key="KEY" class="inspector__input" checked>
|
| 6304 |
* <label class="wpbc_ui__toggle_icon" for="ID"></label>
|
| 6305 |
* <label class="wpbc_ui__toggle_label" for="ID">Label text</label>
|
| 6306 |
* </div>
|
| 6307 |
* </div>
|
| 6308 |
*
|
| 6309 |
* @param {string} input_id
|
| 6310 |
* @param {string} key
|
| 6311 |
* @param {boolean} checked
|
| 6312 |
* @param {string} label_text
|
| 6313 |
* @returns {HTMLElement}
|
| 6314 |
*/
|
| 6315 |
function build_toggle_row( input_id, key, checked, label_text ) {
|
| 6316 |
|
| 6317 |
var row_el = el( 'div', { 'class': 'inspector__row inspector__row--toggle' } );
|
| 6318 |
var ctrl_wrap = el( 'div', { 'class': 'inspector__control wpbc_ui__toggle' } );
|
| 6319 |
|
| 6320 |
var input_el = el( 'input', {
|
| 6321 |
id : input_id,
|
| 6322 |
type : 'checkbox',
|
| 6323 |
'data-inspector-key': key,
|
| 6324 |
'class' : 'inspector__input',
|
| 6325 |
checked : !!checked,
|
| 6326 |
role : 'switch',
|
| 6327 |
'aria-checked' : !!checked
|
| 6328 |
} );
|
| 6329 |
var icon_lbl = el( 'label', { 'class': 'wpbc_ui__toggle_icon', 'for': input_id } );
|
| 6330 |
var text_lbl = el( 'label', { 'class': 'wpbc_ui__toggle_label', 'for': input_id }, label_text || '' );
|
| 6331 |
|
| 6332 |
ctrl_wrap.appendChild( input_el );
|
| 6333 |
ctrl_wrap.appendChild( icon_lbl );
|
| 6334 |
ctrl_wrap.appendChild( text_lbl );
|
| 6335 |
|
| 6336 |
row_el.appendChild( ctrl_wrap );
|
| 6337 |
return row_el;
|
| 6338 |
}
|
| 6339 |
|
| 6340 |
/**
|
| 6341 |
* Utility: choose initial value from data or schema default.
|
| 6342 |
*/
|
| 6343 |
function get_initial_value(key, data, props_schema) {
|
| 6344 |
if ( data && Object.prototype.hasOwnProperty.call( data, key ) ) return data[key];
|
| 6345 |
var meta = props_schema && props_schema[key];
|
| 6346 |
return (meta && Object.prototype.hasOwnProperty.call( meta, 'default' )) ? meta.default : '';
|
| 6347 |
}
|
| 6348 |
|
| 6349 |
/**
|
| 6350 |
* Utility: coerce value by schema type.
|
| 6351 |
*/
|
| 6352 |
|
| 6353 |
|
| 6354 |
function coerce_by_type(value, type) {
|
| 6355 |
switch ( type ) {
|
| 6356 |
case 'number':
|
| 6357 |
case 'int':
|
| 6358 |
case 'float':
|
| 6359 |
if ( value === '' || value == null ) {
|
| 6360 |
return '';
|
| 6361 |
}
|
| 6362 |
var n = Number( value );
|
| 6363 |
return isNaN( n ) ? '' : n;
|
| 6364 |
case 'boolean':
|
| 6365 |
return !!value;
|
| 6366 |
case 'array':
|
| 6367 |
return Array.isArray( value ) ? value : [];
|
| 6368 |
default:
|
| 6369 |
return (value == null) ? '' : String( value );
|
| 6370 |
}
|
| 6371 |
}
|
| 6372 |
|
| 6373 |
/**
|
| 6374 |
* Normalize <select> options (array of {value,label} or map {value:label}).
|
| 6375 |
*/
|
| 6376 |
function normalize_select_options(options) {
|
| 6377 |
if ( Array.isArray( options ) ) {
|
| 6378 |
return options.map( function (o) {
|
| 6379 |
if ( typeof o === 'object' && o && 'value' in o ) {
|
| 6380 |
return { value: String( o.value ), label: String( o.label || o.value ) };
|
| 6381 |
}
|
| 6382 |
return { value: String( o ), label: String( o ) };
|
| 6383 |
} );
|
| 6384 |
}
|
| 6385 |
if ( options && typeof options === 'object' ) {
|
| 6386 |
return Object.keys( options ).map( function (k) {
|
| 6387 |
return { value: String( k ), label: String( options[k] ) };
|
| 6388 |
} );
|
| 6389 |
}
|
| 6390 |
return [];
|
| 6391 |
}
|
| 6392 |
|
| 6393 |
/** Parse a CSS length like "120px" or "80%" into { value:number, unit:string }. */
|
| 6394 |
function parse_len(value, fallback_unit) {
|
| 6395 |
value = (value == null) ? '' : String( value ).trim();
|
| 6396 |
var m = value.match( /^(-?\d+(?:\.\d+)?)(px|%|rem|em)$/i );
|
| 6397 |
if ( m ) {
|
| 6398 |
return { value: parseFloat( m[1] ), unit: m[2].toLowerCase() };
|
| 6399 |
}
|
| 6400 |
// plain number -> assume fallback unit
|
| 6401 |
if ( value !== '' && !isNaN( Number( value ) ) ) {
|
| 6402 |
return { value: Number( value ), unit: (fallback_unit || 'px') };
|
| 6403 |
}
|
| 6404 |
return { value: 0, unit: (fallback_unit || 'px') };
|
| 6405 |
}
|
| 6406 |
|
| 6407 |
/** Clamp helper. */
|
| 6408 |
function clamp_num(v, min, max) {
|
| 6409 |
if ( typeof v !== 'number' || isNaN( v ) ) return (min != null ? min : 0);
|
| 6410 |
if ( min != null && v < min ) v = min;
|
| 6411 |
if ( max != null && v > max ) v = max;
|
| 6412 |
return v;
|
| 6413 |
}
|
| 6414 |
|
| 6415 |
// Initialize Coloris pickers in a given root.
|
| 6416 |
// Relies on Coloris being enqueued (see bfb-bootstrap.php).
|
| 6417 |
function init_coloris_pickers(root) {
|
| 6418 |
if ( !root || !w.Coloris ) return;
|
| 6419 |
// Mark inputs we want Coloris to handle.
|
| 6420 |
var inputs = root.querySelectorAll( 'input[data-inspector-type="color"]' );
|
| 6421 |
if ( !inputs.length ) return;
|
| 6422 |
|
| 6423 |
// Add a stable class for Coloris targeting; avoid double-initializing.
|
| 6424 |
inputs.forEach( function (input) {
|
| 6425 |
if ( input.classList.contains( 'wpbc_bfb_coloris' ) ) return;
|
| 6426 |
input.classList.add( 'wpbc_bfb_coloris' );
|
| 6427 |
} );
|
| 6428 |
|
| 6429 |
// Create/refresh a Coloris instance bound to these inputs.
|
| 6430 |
// Keep HEX output to match schema defaults (e.g., "#e0e0e0").
|
| 6431 |
try {
|
| 6432 |
w.Coloris( {
|
| 6433 |
el : '.wpbc_bfb_coloris',
|
| 6434 |
alpha : false,
|
| 6435 |
format : 'hex',
|
| 6436 |
themeMode: 'auto'
|
| 6437 |
} );
|
| 6438 |
// Coloris already dispatches 'input' events on value changes.
|
| 6439 |
} catch ( e ) {
|
| 6440 |
// Non-fatal: if Coloris throws (rare), the text input still works.
|
| 6441 |
console.warn( 'WPBC Inspector: Coloris init failed:', e );
|
| 6442 |
}
|
| 6443 |
}
|
| 6444 |
|
| 6445 |
/**
|
| 6446 |
* Build: slider + number in one row (writes to a single data key).
|
| 6447 |
* Control meta: { type:'range_number', key, label, min, max, step }
|
| 6448 |
*/
|
| 6449 |
function build_range_number_row(input_id, key, label_text, value, meta) {
|
| 6450 |
var row_el = el('div', { 'class': 'inspector__row' });
|
| 6451 |
var label_el = el('label', { 'for': input_id, 'class': 'inspector__label' }, label_text || key || '');
|
| 6452 |
var ctrl = el('div', { 'class': 'inspector__control' });
|
| 6453 |
|
| 6454 |
var min = (meta && meta.min != null) ? meta.min : 0;
|
| 6455 |
var max = (meta && meta.max != null) ? meta.max : 100;
|
| 6456 |
var step = (meta && meta.step != null) ? meta.step : 1;
|
| 6457 |
|
| 6458 |
var group = el('div', { 'class': 'wpbc_len_group wpbc_inline_inputs', 'data-len-group': key });
|
| 6459 |
|
| 6460 |
var range = el('input', {
|
| 6461 |
type : 'range',
|
| 6462 |
'class': 'inspector__input',
|
| 6463 |
'data-len-range': '',
|
| 6464 |
min : String(min),
|
| 6465 |
max : String(max),
|
| 6466 |
step : String(step),
|
| 6467 |
value: String(value == null || value === '' ? min : value)
|
| 6468 |
});
|
| 6469 |
|
| 6470 |
var num = el('input', {
|
| 6471 |
id : input_id,
|
| 6472 |
type : 'number',
|
| 6473 |
'class': 'inspector__input inspector__w_30',
|
| 6474 |
'data-len-value': '',
|
| 6475 |
'data-inspector-key': key,
|
| 6476 |
min : String(min),
|
| 6477 |
max : String(max),
|
| 6478 |
step : String(step),
|
| 6479 |
value: (value == null || value === '') ? String(min) : String(value)
|
| 6480 |
});
|
| 6481 |
|
| 6482 |
group.appendChild(range);
|
| 6483 |
group.appendChild(num);
|
| 6484 |
ctrl.appendChild(group);
|
| 6485 |
row_el.appendChild(label_el);
|
| 6486 |
row_el.appendChild(ctrl);
|
| 6487 |
return row_el;
|
| 6488 |
}
|
| 6489 |
|
| 6490 |
/**
|
| 6491 |
* Build: (number + unit) + slider, writing a *single* combined string to `key`.
|
| 6492 |
* Control meta:
|
| 6493 |
* {
|
| 6494 |
* type:'len', key, label, units:['px','%','rem','em'],
|
| 6495 |
* slider: { px:{min:0,max:512,step:1}, '%':{min:0,max:100,step:1}, rem:{min:0,max:10,step:0.1}, em:{...} },
|
| 6496 |
* fallback_unit:'px'
|
| 6497 |
* }
|
| 6498 |
*/
|
| 6499 |
function build_len_compound_row(control, props_schema, data, uid) {
|
| 6500 |
var key = control.key;
|
| 6501 |
var label_text = control.label || key || '';
|
| 6502 |
var def_str = get_initial_value( key, data, props_schema );
|
| 6503 |
var fallback_u = control.fallback_unit || 'px';
|
| 6504 |
var parsed = parse_len( def_str, fallback_u );
|
| 6505 |
|
| 6506 |
var row = el( 'div', { 'class': 'inspector__row' } );
|
| 6507 |
var label = el( 'label', { 'class': 'inspector__label' }, label_text );
|
| 6508 |
var ctrl = el( 'div', { 'class': 'inspector__control' } );
|
| 6509 |
|
| 6510 |
var units = Array.isArray( control.units ) && control.units.length ? control.units : [ 'px', '%', 'rem', 'em' ];
|
| 6511 |
var slider_map = control.slider || {
|
| 6512 |
'px' : { min: 0, max: 512, step: 1 },
|
| 6513 |
'%' : { min: 0, max: 100, step: 1 },
|
| 6514 |
'rem': { min: 0, max: 10, step: 0.1 },
|
| 6515 |
'em' : { min: 0, max: 10, step: 0.1 }
|
| 6516 |
};
|
| 6517 |
|
| 6518 |
// Host with a hidden input that carries data-inspector-key to reuse the standard handler.
|
| 6519 |
var group = el( 'div', { 'class': 'wpbc_len_group', 'data-len-group': key } );
|
| 6520 |
|
| 6521 |
var inline = el( 'div', { 'class': 'wpbc_inline_inputs' } );
|
| 6522 |
|
| 6523 |
var num = el( 'input', {
|
| 6524 |
type : 'number',
|
| 6525 |
'class' : 'inspector__input',
|
| 6526 |
'data-len-value': '',
|
| 6527 |
min : '0',
|
| 6528 |
step : 'any',
|
| 6529 |
value : String( parsed.value )
|
| 6530 |
} );
|
| 6531 |
|
| 6532 |
var sel = el( 'select', { 'class': 'inspector__input', 'data-len-unit': '' } );
|
| 6533 |
units.forEach( function (u) {
|
| 6534 |
var opt = el( 'option', { value: u }, u );
|
| 6535 |
if ( u === parsed.unit ) opt.setAttribute( 'selected', 'selected' );
|
| 6536 |
sel.appendChild( opt );
|
| 6537 |
} );
|
| 6538 |
|
| 6539 |
inline.appendChild( num );
|
| 6540 |
inline.appendChild( sel );
|
| 6541 |
|
| 6542 |
// Slider (unit-aware)
|
| 6543 |
var current = slider_map[parsed.unit] || slider_map[units[0]];
|
| 6544 |
var range = el( 'input', {
|
| 6545 |
type : 'range',
|
| 6546 |
'class' : 'inspector__input',
|
| 6547 |
'data-len-range': '',
|
| 6548 |
min : String( current.min ),
|
| 6549 |
max : String( current.max ),
|
| 6550 |
step : String( current.step ),
|
| 6551 |
value : String( clamp_num( parsed.value, current.min, current.max ) )
|
| 6552 |
} );
|
| 6553 |
|
| 6554 |
// Hidden writer input that the default Inspector handler will catch.
|
| 6555 |
var hidden = el( 'input', {
|
| 6556 |
type : 'text',
|
| 6557 |
'class' : 'inspector__input',
|
| 6558 |
style : 'display:none',
|
| 6559 |
'aria-hidden' : 'true',
|
| 6560 |
tabindex : '-1',
|
| 6561 |
id : 'wpbc_ins_' + key + '_' + uid + '_len_hidden',
|
| 6562 |
'data-inspector-key': key,
|
| 6563 |
value : (String( parsed.value ) + parsed.unit)
|
| 6564 |
} );
|
| 6565 |
|
| 6566 |
group.appendChild( inline );
|
| 6567 |
group.appendChild( range );
|
| 6568 |
group.appendChild( hidden );
|
| 6569 |
|
| 6570 |
ctrl.appendChild( group );
|
| 6571 |
row.appendChild( label );
|
| 6572 |
row.appendChild( ctrl );
|
| 6573 |
return row;
|
| 6574 |
}
|
| 6575 |
|
| 6576 |
/**
|
| 6577 |
* Wire syncing for any .wpbc_len_group inside a given root (panel).
|
| 6578 |
* - range ⇄ number sync
|
| 6579 |
* - unit switches update slider bounds
|
| 6580 |
* - hidden writer (if present) gets updated and emits 'input'
|
| 6581 |
*/
|
| 6582 |
function wire_len_group(root) {
|
| 6583 |
if ( !root ) return;
|
| 6584 |
|
| 6585 |
function find_group(el) {
|
| 6586 |
return el && el.closest && el.closest( '.wpbc_len_group' );
|
| 6587 |
}
|
| 6588 |
|
| 6589 |
root.addEventListener( 'input', function (e) {
|
| 6590 |
var t = e.target;
|
| 6591 |
// Slider moved -> update number (and writer/hidden)
|
| 6592 |
if ( t && t.hasAttribute( 'data-len-range' ) ) {
|
| 6593 |
var g = find_group( t );
|
| 6594 |
if ( !g ) return;
|
| 6595 |
var num = g.querySelector( '[data-len-value]' );
|
| 6596 |
if ( num ) {
|
| 6597 |
num.value = t.value;
|
| 6598 |
}
|
| 6599 |
var writer = g.querySelector( '[data-inspector-key]' );
|
| 6600 |
if ( writer && writer.type === 'text' ) {
|
| 6601 |
var unit = g.querySelector( '[data-len-unit]' );
|
| 6602 |
unit = unit ? unit.value : 'px';
|
| 6603 |
writer.value = String( t.value ) + String( unit );
|
| 6604 |
// trigger standard inspector handler:
|
| 6605 |
writer.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 6606 |
} else {
|
| 6607 |
// Plain range_number case (number has data-inspector-key) -> fire input on number
|
| 6608 |
if ( num && num.hasAttribute( 'data-inspector-key' ) ) {
|
| 6609 |
num.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 6610 |
}
|
| 6611 |
}
|
| 6612 |
}
|
| 6613 |
|
| 6614 |
// Number typed -> update slider and writer/hidden
|
| 6615 |
if ( t && t.hasAttribute( 'data-len-value' ) ) {
|
| 6616 |
var g = find_group( t );
|
| 6617 |
if ( !g ) return;
|
| 6618 |
var r = g.querySelector( '[data-len-range]' );
|
| 6619 |
if ( r ) {
|
| 6620 |
// clamp within slider bounds if present
|
| 6621 |
var min = Number( r.min );
|
| 6622 |
var max = Number( r.max );
|
| 6623 |
var v = Number( t.value );
|
| 6624 |
if ( !isNaN( v ) ) {
|
| 6625 |
v = clamp_num( v, isNaN( min ) ? undefined : min, isNaN( max ) ? undefined : max );
|
| 6626 |
r.value = String( v );
|
| 6627 |
if ( String( v ) !== t.value ) t.value = String( v );
|
| 6628 |
}
|
| 6629 |
}
|
| 6630 |
var writer = g.querySelector( '[data-inspector-key]' );
|
| 6631 |
if ( writer && writer.type === 'text' ) {
|
| 6632 |
var unit = g.querySelector( '[data-len-unit]' );
|
| 6633 |
unit = unit ? unit.value : 'px';
|
| 6634 |
writer.value = String( t.value || 0 ) + String( unit );
|
| 6635 |
writer.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 6636 |
}
|
| 6637 |
// else: number itself likely carries data-inspector-key (range_number); default handler will run.
|
| 6638 |
}
|
| 6639 |
}, true );
|
| 6640 |
|
| 6641 |
root.addEventListener( 'change', function (e) {
|
| 6642 |
var t = e.target;
|
| 6643 |
// Unit changed -> update slider limits and writer/hidden
|
| 6644 |
if ( t && t.hasAttribute( 'data-len-unit' ) ) {
|
| 6645 |
var g = find_group( t );
|
| 6646 |
if ( !g ) return;
|
| 6647 |
|
| 6648 |
// Find the control meta via a data attribute on group if provided
|
| 6649 |
// (Factory path sets nothing here; we re-derive from current slider bounds.)
|
| 6650 |
var r = g.querySelector( '[data-len-range]' );
|
| 6651 |
var num = g.querySelector( '[data-len-value]' );
|
| 6652 |
var writer = g.querySelector( '[data-inspector-key]' );
|
| 6653 |
var unit = t.value || 'px';
|
| 6654 |
|
| 6655 |
// Adjust slider bounds heuristically (match Factory defaults)
|
| 6656 |
var bounds_by_unit = {
|
| 6657 |
'px' : { min: 0, max: 512, step: 1 },
|
| 6658 |
'%' : { min: 0, max: 100, step: 1 },
|
| 6659 |
'rem': { min: 0, max: 10, step: 0.1 },
|
| 6660 |
'em' : { min: 0, max: 10, step: 0.1 }
|
| 6661 |
};
|
| 6662 |
if ( r ) {
|
| 6663 |
var b = bounds_by_unit[unit] || bounds_by_unit['px'];
|
| 6664 |
r.min = String( b.min );
|
| 6665 |
r.max = String( b.max );
|
| 6666 |
r.step = String( b.step );
|
| 6667 |
// clamp to new bounds
|
| 6668 |
var v = Number( num && num.value ? num.value : r.value );
|
| 6669 |
if ( !isNaN( v ) ) {
|
| 6670 |
v = clamp_num( v, b.min, b.max );
|
| 6671 |
r.value = String( v );
|
| 6672 |
if ( num ) num.value = String( v );
|
| 6673 |
}
|
| 6674 |
}
|
| 6675 |
if ( writer && writer.type === 'text' ) {
|
| 6676 |
var v = num && num.value ? num.value : (r ? r.value : '0');
|
| 6677 |
writer.value = String( v ) + String( unit );
|
| 6678 |
writer.dispatchEvent( new Event( 'input', { bubbles: true } ) );
|
| 6679 |
}
|
| 6680 |
}
|
| 6681 |
}, true );
|
| 6682 |
}
|
| 6683 |
|
| 6684 |
// =============================================================================================================
|
| 6685 |
// == C O N T R O L ==
|
| 6686 |
// =============================================================================================================
|
| 6687 |
|
| 6688 |
/**
|
| 6689 |
* Schema > Inspector > Control Element, e.g. Input! Build a single control row:
|
| 6690 |
* <div class="inspector__row">
|
| 6691 |
* <label class="inspector__label" for="...">Label</label>
|
| 6692 |
* <div class="inspector__control"><input|textarea|select class="inspector__input" ...></div>
|
| 6693 |
* </div>
|
| 6694 |
*
|
| 6695 |
* @param {Object} control - schema control meta ({type,key,label,...})
|
| 6696 |
* @param {Object} props_schema - schema.props
|
| 6697 |
* @param {Object} data - current element data-* map
|
| 6698 |
* @param {string} uid - unique suffix for input ids
|
| 6699 |
* @param {Object} ctx - { el, builder, type, data }
|
| 6700 |
* @returns {HTMLElement}
|
| 6701 |
*/
|
| 6702 |
function build_control(control, props_schema, data, uid, ctx) {
|
| 6703 |
var type = control.type;
|
| 6704 |
var key = control.key;
|
| 6705 |
|
| 6706 |
var label_text = control.label || key || '';
|
| 6707 |
var prop_meta = (key ? (props_schema[key] || { type: 'string' }) : { type: 'string' });
|
| 6708 |
var value = coerce_by_type( get_initial_value( key, data, props_schema ), prop_meta.type );
|
| 6709 |
// Allow value_from override (computed at render-time).
|
| 6710 |
if ( control && control.value_from && w.wpbc_bfb_inspector_factory_value_from[control.value_from] ) {
|
| 6711 |
try {
|
| 6712 |
var computed = w.wpbc_bfb_inspector_factory_value_from[control.value_from]( ctx || {} );
|
| 6713 |
value = coerce_by_type( computed, prop_meta.type );
|
| 6714 |
} catch ( e ) {
|
| 6715 |
console.warn( 'value_from failed for', control.value_from, e );
|
| 6716 |
}
|
| 6717 |
}
|
| 6718 |
|
| 6719 |
var input_id = 'wpbc_ins_' + key + '_' + uid;
|
| 6720 |
|
| 6721 |
var row_el = el( 'div', { 'class': 'inspector__row' } );
|
| 6722 |
var label_el = el( 'label', { 'for': input_id, 'class': 'inspector__label' }, label_text );
|
| 6723 |
var ctrl_wrap = el( 'div', { 'class': 'inspector__control' } );
|
| 6724 |
|
| 6725 |
var field_el;
|
| 6726 |
|
| 6727 |
// --- slot host (named UI injection) -----------------------------------
|
| 6728 |
if ( type === 'slot' && control.slot ) {
|
| 6729 |
// add a marker class for the layout chips row
|
| 6730 |
var classes = 'inspector__row inspector__row--slot';
|
| 6731 |
if ( control.slot === 'layout_chips' ) classes += ' inspector__row--layout-chips';
|
| 6732 |
|
| 6733 |
var slot_row = el( 'div', { 'class': classes } );
|
| 6734 |
|
| 6735 |
if ( label_text ) slot_row.appendChild( el( 'label', { 'class': 'inspector__label' }, label_text ) );
|
| 6736 |
|
| 6737 |
// add a data attribute on the host so both CSS and the safety-net can target it
|
| 6738 |
var host_attrs = { 'class': 'inspector__control' };
|
| 6739 |
if ( control.slot === 'layout_chips' ) host_attrs['data-bfb-slot'] = 'layout_chips';
|
| 6740 |
|
| 6741 |
var slot_host = el( 'div', host_attrs );
|
| 6742 |
slot_row.appendChild( slot_host );
|
| 6743 |
|
| 6744 |
var slot_fn = w.wpbc_bfb_inspector_factory_slots[control.slot];
|
| 6745 |
if ( typeof slot_fn === 'function' ) {
|
| 6746 |
setTimeout( function () {
|
| 6747 |
try {
|
| 6748 |
slot_fn( slot_host, ctx || {} );
|
| 6749 |
} catch ( e ) {
|
| 6750 |
console.warn( 'slot "' + control.slot + '" failed:', e );
|
| 6751 |
}
|
| 6752 |
}, 0 );
|
| 6753 |
} else {
|
| 6754 |
slot_host.appendChild( el( 'div', { 'class': 'wpbc_bfb__slot__missing' }, '[slot: ' + control.slot + ']' ) );
|
| 6755 |
}
|
| 6756 |
return slot_row;
|
| 6757 |
}
|
| 6758 |
|
| 6759 |
|
| 6760 |
if ( type === 'textarea' ) {
|
| 6761 |
field_el = el( 'textarea', {
|
| 6762 |
id : input_id,
|
| 6763 |
'data-inspector-key': key,
|
| 6764 |
rows : control.rows || 3,
|
| 6765 |
'class' : 'inspector__input'
|
| 6766 |
}, (value == null ? '' : String( value )) );
|
| 6767 |
} else if ( type === 'select' ) {
|
| 6768 |
field_el = el( 'select', {
|
| 6769 |
id : input_id,
|
| 6770 |
'data-inspector-key': key,
|
| 6771 |
'class' : 'inspector__input'
|
| 6772 |
} );
|
| 6773 |
normalize_select_options( control.options || [] ).forEach( function (opt) {
|
| 6774 |
var opt_el = el( 'option', { value: opt.value }, opt.label );
|
| 6775 |
if ( String( value ) === opt.value ) opt_el.setAttribute( 'selected', 'selected' );
|
| 6776 |
field_el.appendChild( opt_el );
|
| 6777 |
} );
|
| 6778 |
} else if ( type === 'checkbox' ) {
|
| 6779 |
// field_el = el( 'input', { id: input_id, type: 'checkbox', 'data-inspector-key': key, checked: !!value, 'class': 'inspector__input' } ); //.
|
| 6780 |
|
| 6781 |
// Render as toggle UI instead of label-left + checkbox. Note: we return the full toggle row here and skip the default row/label flow below.
|
| 6782 |
return build_toggle_row( input_id, key, !!value, label_text );
|
| 6783 |
|
| 6784 |
} else if ( type === 'range_number' ) {
|
| 6785 |
// --- new: slider + number (single key).
|
| 6786 |
var rn_id = 'wpbc_ins_' + key + '_' + uid;
|
| 6787 |
var rn_val = value; // from get_initial_value/prop_meta already.
|
| 6788 |
return build_range_number_row( rn_id, key, label_text, rn_val, control );
|
| 6789 |
|
| 6790 |
} else if ( type === 'len' ) {
|
| 6791 |
// --- new: length compound (value+unit+slider -> writes a single string key).
|
| 6792 |
return build_len_compound_row( control, props_schema, data, uid );
|
| 6793 |
|
| 6794 |
} else if ( type === 'color' ) {
|
| 6795 |
// Color picker (Coloris). Store as string (e.g., "#e0e0e0").
|
| 6796 |
field_el = el( 'input', {
|
| 6797 |
id : input_id,
|
| 6798 |
type : 'text',
|
| 6799 |
'data-inspector-key' : key,
|
| 6800 |
'data-inspector-type': 'color',
|
| 6801 |
'data-coloris' : '',
|
| 6802 |
'class' : 'inspector__input',
|
| 6803 |
'data-default-color' : ( value != null && value !== '' ? String(value) : (control.placeholder || '') )
|
| 6804 |
} );
|
| 6805 |
if ( value !== '' ) {
|
| 6806 |
field_el.value = String( value );
|
| 6807 |
}
|
| 6808 |
} else {
|
| 6809 |
// text/number default.
|
| 6810 |
var attrs = {
|
| 6811 |
id : input_id,
|
| 6812 |
type : (type === 'number') ? 'number' : 'text',
|
| 6813 |
'data-inspector-key': key,
|
| 6814 |
'class' : 'inspector__input'
|
| 6815 |
};
|
| 6816 |
// number constraints (schema or control)
|
| 6817 |
if ( type === 'number' ) {
|
| 6818 |
if ( Object.prototype.hasOwnProperty.call( prop_meta, 'min' ) ) attrs.min = prop_meta.min;
|
| 6819 |
if ( Object.prototype.hasOwnProperty.call( prop_meta, 'max' ) ) attrs.max = prop_meta.max;
|
| 6820 |
if ( Object.prototype.hasOwnProperty.call( prop_meta, 'step' ) ) attrs.step = prop_meta.step;
|
| 6821 |
if ( Object.prototype.hasOwnProperty.call( control, 'min' ) ) attrs.min = control.min;
|
| 6822 |
if ( Object.prototype.hasOwnProperty.call( control, 'max' ) ) attrs.max = control.max;
|
| 6823 |
if ( Object.prototype.hasOwnProperty.call( control, 'step' ) ) attrs.step = control.step;
|
| 6824 |
}
|
| 6825 |
field_el = el( 'input', attrs );
|
| 6826 |
if ( value !== '' ) field_el.value = String( value );
|
| 6827 |
}
|
| 6828 |
|
| 6829 |
ctrl_wrap.appendChild( field_el );
|
| 6830 |
row_el.appendChild( label_el );
|
| 6831 |
row_el.appendChild( ctrl_wrap );
|
| 6832 |
return row_el;
|
| 6833 |
}
|
| 6834 |
|
| 6835 |
/**
|
| 6836 |
* Schema > Inspector > Groups! Build an inspector group (collapsible).
|
| 6837 |
* Structure:
|
| 6838 |
* <section class="wpbc_bfb__inspector__group wpbc_ui__collapsible_group is-open" data-group="...">
|
| 6839 |
* <button type="button" class="group__header" role="button" aria-expanded="true" aria-controls="wpbc_collapsible_panel_X">
|
| 6840 |
* <h3>Group Title</h3>
|
| 6841 |
* <i class="wpbc_ui_el__vert_menu_root_section_icon menu_icon icon-1x wpbc-bi-chevron-right"></i>
|
| 6842 |
* </button>
|
| 6843 |
* <div class="group__fields" id="wpbc_collapsible_panel_X" aria-hidden="false"> …rows… </div>
|
| 6844 |
* </section>
|
| 6845 |
*
|
| 6846 |
* @param {Object} group
|
| 6847 |
* @param {Object} props_schema
|
| 6848 |
* @param {Object} data
|
| 6849 |
* @param {string} uid
|
| 6850 |
* @param {Object} ctx
|
| 6851 |
* @returns {HTMLElement}
|
| 6852 |
*/
|
| 6853 |
function build_group(group, props_schema, data, uid, ctx) {
|
| 6854 |
var is_open = !!group.open;
|
| 6855 |
var panel_id = 'wpbc_collapsible_panel_' + uid + '_' + (group.key || 'g');
|
| 6856 |
|
| 6857 |
var section = el( 'section', {
|
| 6858 |
'class' : 'wpbc_bfb__inspector__group wpbc_ui__collapsible_group' + (is_open ? ' is-open' : ''),
|
| 6859 |
'data-group': group.key || ''
|
| 6860 |
} );
|
| 6861 |
|
| 6862 |
var header_btn = el( 'button', {
|
| 6863 |
type : 'button',
|
| 6864 |
'class' : 'group__header',
|
| 6865 |
role : 'button',
|
| 6866 |
'aria-expanded': is_open ? 'true' : 'false',
|
| 6867 |
'aria-controls': panel_id
|
| 6868 |
}, [
|
| 6869 |
el( 'h3', null, group.title || group.label || group.key || '' ),
|
| 6870 |
el( 'i', { 'class': 'wpbc_ui_el__vert_menu_root_section_icon menu_icon icon-1x wpbc-bi-chevron-right' } )
|
| 6871 |
] );
|
| 6872 |
|
| 6873 |
var fields = el( 'div', {
|
| 6874 |
'class' : 'group__fields',
|
| 6875 |
id : panel_id,
|
| 6876 |
'aria-hidden': is_open ? 'false' : 'true'
|
| 6877 |
} );
|
| 6878 |
|
| 6879 |
function asArray(x) {
|
| 6880 |
if ( Array.isArray( x ) ) return x;
|
| 6881 |
if ( x && typeof x === 'object' ) return Object.values( x );
|
| 6882 |
return x != null ? [ x ] : [];
|
| 6883 |
}
|
| 6884 |
|
| 6885 |
asArray( group.controls ).forEach( function (control) {
|
| 6886 |
fields.appendChild( build_control( control, props_schema, data, uid, ctx ) );
|
| 6887 |
} );
|
| 6888 |
|
| 6889 |
section.appendChild( header_btn );
|
| 6890 |
section.appendChild( fields );
|
| 6891 |
return section;
|
| 6892 |
}
|
| 6893 |
|
| 6894 |
/**
|
| 6895 |
* Schema > Inspector > Header! Build inspector header with action buttons wired to existing data-action handlers.
|
| 6896 |
*
|
| 6897 |
* @param {Array<string>} header_actions
|
| 6898 |
* @param {string} title_text
|
| 6899 |
* @returns {HTMLElement}
|
| 6900 |
*/
|
| 6901 |
function build_header(inspector_ui, title_fallback, schema_for_type) {
|
| 6902 |
|
| 6903 |
inspector_ui = inspector_ui || {};
|
| 6904 |
schema_for_type = schema_for_type || {};
|
| 6905 |
var variant = inspector_ui.header_variant || 'minimal';
|
| 6906 |
var headerActions = inspector_ui.header_actions
|
| 6907 |
|| schema_for_type.header_actions
|
| 6908 |
|| [ 'deselect', 'scrollto', 'move-up', 'move-down', 'duplicate', 'delete' ];
|
| 6909 |
|
| 6910 |
var title = inspector_ui.title || title_fallback || '';
|
| 6911 |
var description = inspector_ui.description || '';
|
| 6912 |
|
| 6913 |
// helper to create a button for either header style
|
| 6914 |
function actionBtn(act, minimal) {
|
| 6915 |
if ( minimal ) {
|
| 6916 |
return el( 'button', { type: 'button', 'class': 'button-link', 'data-action': act }, '' );
|
| 6917 |
}
|
| 6918 |
// toolbar variant (rich)
|
| 6919 |
var iconMap = {
|
| 6920 |
'deselect' : 'wpbc_icn_near_me_disabled',
|
| 6921 |
'scrollto' : 'wpbc_icn_ads_click filter_center_focus',
|
| 6922 |
'move-up' : 'wpbc_icn_arrow_upward',
|
| 6923 |
'move-down': 'wpbc_icn_arrow_downward',
|
| 6924 |
'duplicate': 'wpbc_icn_content_copy',
|
| 6925 |
'delete' : 'wpbc_icn_delete_outline'
|
| 6926 |
};
|
| 6927 |
var classes = 'button button-secondary wpbc_ui_control wpbc_ui_button';
|
| 6928 |
if ( act === 'delete' ) classes += ' wpbc_ui_button_danger button-link-delete';
|
| 6929 |
|
| 6930 |
var btn = el( 'button', {
|
| 6931 |
type : 'button',
|
| 6932 |
'class' : classes,
|
| 6933 |
'data-action': act,
|
| 6934 |
'aria-label' : act.replace( /-/g, ' ' )
|
| 6935 |
} );
|
| 6936 |
|
| 6937 |
if ( act === 'delete' ) {
|
| 6938 |
btn.appendChild( el( 'span', { 'class': 'in-button-text' }, 'Delete' ) );
|
| 6939 |
btn.appendChild( document.createTextNode( ' ' ) ); // minor spacing before icon
|
| 6940 |
}
|
| 6941 |
btn.appendChild( el( 'i', { 'class': 'menu_icon icon-1x ' + (iconMap[act] || '') } ) );
|
| 6942 |
return btn;
|
| 6943 |
}
|
| 6944 |
|
| 6945 |
// === minimal header (existing look; default) ===
|
| 6946 |
if ( variant !== 'toolbar' ) {
|
| 6947 |
var header = el( 'header', { 'class': 'wpbc_bfb__inspector__header' } );
|
| 6948 |
header.appendChild( el( 'h3', null, title || '' ) );
|
| 6949 |
|
| 6950 |
var actions = el( 'div', { 'class': 'wpbc_bfb__inspector__header_actions' } );
|
| 6951 |
headerActions.forEach( function (act) {
|
| 6952 |
actions.appendChild( actionBtn( act, /*minimal*/true ) );
|
| 6953 |
} );
|
| 6954 |
header.appendChild( actions );
|
| 6955 |
return header;
|
| 6956 |
}
|
| 6957 |
|
| 6958 |
// === toolbar header (rich title/desc + grouped buttons) ===
|
| 6959 |
var root = el( 'div', { 'class': 'wpbc_bfb__inspector__head' } );
|
| 6960 |
var wrap = el( 'div', { 'class': 'header_container' } );
|
| 6961 |
var left = el( 'div', { 'class': 'header_title_content' } );
|
| 6962 |
var h3 = el( 'h3', { 'class': 'title' }, title || '' );
|
| 6963 |
left.appendChild( h3 );
|
| 6964 |
if ( description ) {
|
| 6965 |
left.appendChild( el( 'div', { 'class': 'desc' }, description ) );
|
| 6966 |
}
|
| 6967 |
|
| 6968 |
var right = el( 'div', { 'class': 'actions wpbc_ajx_toolbar wpbc_no_borders' } );
|
| 6969 |
var uiC = el( 'div', { 'class': 'ui_container ui_container_small' } );
|
| 6970 |
var uiG = el( 'div', { 'class': 'ui_group' } );
|
| 6971 |
|
| 6972 |
// Split into visual groups: first 2, next 2, then the rest.
|
| 6973 |
var g1 = el( 'div', { 'class': 'ui_element' } );
|
| 6974 |
var g2 = el( 'div', { 'class': 'ui_element' } );
|
| 6975 |
var g3 = el( 'div', { 'class': 'ui_element' } );
|
| 6976 |
|
| 6977 |
headerActions.slice( 0, 2 ).forEach( function (act) {
|
| 6978 |
g1.appendChild( actionBtn( act, false ) );
|
| 6979 |
} );
|
| 6980 |
headerActions.slice( 2, 4 ).forEach( function (act) {
|
| 6981 |
g2.appendChild( actionBtn( act, false ) );
|
| 6982 |
} );
|
| 6983 |
headerActions.slice( 4 ).forEach( function (act) {
|
| 6984 |
g3.appendChild( actionBtn( act, false ) );
|
| 6985 |
} );
|
| 6986 |
|
| 6987 |
uiG.appendChild( g1 );
|
| 6988 |
uiG.appendChild( g2 );
|
| 6989 |
uiG.appendChild( g3 );
|
| 6990 |
uiC.appendChild( uiG );
|
| 6991 |
right.appendChild( uiC );
|
| 6992 |
|
| 6993 |
wrap.appendChild( left );
|
| 6994 |
wrap.appendChild( right );
|
| 6995 |
root.appendChild( wrap );
|
| 6996 |
|
| 6997 |
return root;
|
| 6998 |
}
|
| 6999 |
|
| 7000 |
|
| 7001 |
function factory_render(panel_el, schema_for_type, data, opts) {
|
| 7002 |
if ( !panel_el ) return panel_el;
|
| 7003 |
|
| 7004 |
schema_for_type = schema_for_type || {};
|
| 7005 |
var props_schema = (schema_for_type.schema && schema_for_type.schema.props) ? schema_for_type.schema.props : {};
|
| 7006 |
var inspector_ui = (schema_for_type.inspector_ui || {});
|
| 7007 |
var groups = inspector_ui.groups || [];
|
| 7008 |
|
| 7009 |
var header_actions = inspector_ui.header_actions || schema_for_type.header_actions || [];
|
| 7010 |
var title_text = (opts && opts.title) || inspector_ui.title || schema_for_type.label || (data && data.label) || '';
|
| 7011 |
|
| 7012 |
// Prepare rendering context for slots/value_from, etc.
|
| 7013 |
var ctx = {
|
| 7014 |
el : opts && opts.el || null,
|
| 7015 |
builder: opts && opts.builder || null,
|
| 7016 |
type : opts && opts.type || null,
|
| 7017 |
data : data || {}
|
| 7018 |
};
|
| 7019 |
|
| 7020 |
// clear panel.
|
| 7021 |
while ( panel_el.firstChild ) panel_el.removeChild( panel_el.firstChild );
|
| 7022 |
|
| 7023 |
var uid = Math.random().toString( 36 ).slice( 2, 8 );
|
| 7024 |
|
| 7025 |
// header.
|
| 7026 |
panel_el.appendChild( build_header( inspector_ui, title_text, schema_for_type ) );
|
| 7027 |
|
| 7028 |
|
| 7029 |
// groups.
|
| 7030 |
groups.forEach( function (g) {
|
| 7031 |
panel_el.appendChild( build_group( g, props_schema, data || {}, uid, ctx ) );
|
| 7032 |
} );
|
| 7033 |
|
| 7034 |
// ARIA sync for toggles created here (ensure aria-checked matches state).
|
| 7035 |
try {
|
| 7036 |
// Centralized UI normalizers (toggles + A11y): handled in Core.
|
| 7037 |
UI.apply_post_render( panel_el );
|
| 7038 |
try {
|
| 7039 |
wire_len_group( panel_el );
|
| 7040 |
// Initialize Coloris on color inputs rendered in this panel.
|
| 7041 |
init_coloris_pickers( panel_el );
|
| 7042 |
} catch ( _ ) { }
|
| 7043 |
} catch ( _ ) { }
|
| 7044 |
|
| 7045 |
return panel_el;
|
| 7046 |
}
|
| 7047 |
|
| 7048 |
UI.WPBC_BFB_Inspector_Factory = { render: factory_render }; // overwrite/refresh
|
| 7049 |
|
| 7050 |
// ---- Built-in slot + value_from for Sections ----
|
| 7051 |
|
| 7052 |
function slot_layout_chips(host, ctx) {
|
| 7053 |
try {
|
| 7054 |
var L = w.WPBC_BFB_Core && w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Layout_Chips;
|
| 7055 |
if ( L && typeof L.render_for_section === 'function' ) {
|
| 7056 |
L.render_for_section( ctx.builder, ctx.el, host );
|
| 7057 |
} else {
|
| 7058 |
host.appendChild( document.createTextNode( '[layout_chips not available]' ) );
|
| 7059 |
}
|
| 7060 |
} catch ( e ) {
|
| 7061 |
console.warn( 'wpbc_bfb_slot_layout_chips failed:', e );
|
| 7062 |
}
|
| 7063 |
}
|
| 7064 |
|
| 7065 |
w.wpbc_bfb_inspector_factory_slots.layout_chips = slot_layout_chips;
|
| 7066 |
|
| 7067 |
function value_from_compute_section_columns(ctx) {
|
| 7068 |
try {
|
| 7069 |
var row = ctx && ctx.el && ctx.el.querySelector && ctx.el.querySelector( ':scope > .wpbc_bfb__row' );
|
| 7070 |
if ( !row ) return 1;
|
| 7071 |
var n = row.querySelectorAll( ':scope > .wpbc_bfb__column' ).length || 1;
|
| 7072 |
if ( n < 1 ) n = 1;
|
| 7073 |
if ( n > 4 ) n = 4;
|
| 7074 |
return n;
|
| 7075 |
} catch ( _ ) {
|
| 7076 |
return 1;
|
| 7077 |
}
|
| 7078 |
}
|
| 7079 |
|
| 7080 |
w.wpbc_bfb_inspector_factory_value_from.compute_section_columns = value_from_compute_section_columns;
|
| 7081 |
}
|
| 7082 |
|
| 7083 |
// 3) Inspector class.
|
| 7084 |
|
| 7085 |
class WPBC_BFB_Inspector {
|
| 7086 |
|
| 7087 |
constructor(panel_el, builder) {
|
| 7088 |
this.panel = panel_el || this._create_fallback_panel();
|
| 7089 |
this.builder = builder;
|
| 7090 |
this.selected_el = null;
|
| 7091 |
this._render_timer = null;
|
| 7092 |
|
| 7093 |
this._on_delegated_input = (e) => this._apply_control_from_event( e );
|
| 7094 |
this._on_delegated_change = (e) => this._apply_control_from_event( e );
|
| 7095 |
this.panel.addEventListener( 'input', this._on_delegated_input, true );
|
| 7096 |
this.panel.addEventListener( 'change', this._on_delegated_change, true );
|
| 7097 |
|
| 7098 |
this._on_delegated_click = (e) => {
|
| 7099 |
const btn = e.target.closest( '[data-action]' );
|
| 7100 |
if ( !btn || !this.panel.contains( btn ) ) return;
|
| 7101 |
e.preventDefault();
|
| 7102 |
e.stopPropagation();
|
| 7103 |
|
| 7104 |
const action = btn.getAttribute( 'data-action' );
|
| 7105 |
const el = this.selected_el;
|
| 7106 |
if ( !el ) return;
|
| 7107 |
|
| 7108 |
w.WPBC_BFB_Inspector_Actions?.run( action, {
|
| 7109 |
builder: this.builder,
|
| 7110 |
el,
|
| 7111 |
panel : this.panel,
|
| 7112 |
event : e
|
| 7113 |
} );
|
| 7114 |
|
| 7115 |
if ( action === 'delete' ) this.clear();
|
| 7116 |
};
|
| 7117 |
this.panel.addEventListener( 'click', this._on_delegated_click );
|
| 7118 |
}
|
| 7119 |
|
| 7120 |
_post_render_ui() {
|
| 7121 |
try {
|
| 7122 |
var UI = w.WPBC_BFB_Core && w.WPBC_BFB_Core.UI;
|
| 7123 |
if ( UI && typeof UI.apply_post_render === 'function' ) {
|
| 7124 |
UI.apply_post_render( this.panel );
|
| 7125 |
}
|
| 7126 |
// NEW: wire slider/number/unit syncing for length & range_number groups.
|
| 7127 |
try {
|
| 7128 |
wire_len_group( this.panel );
|
| 7129 |
init_coloris_pickers( this.panel );
|
| 7130 |
} catch ( _ ) {
|
| 7131 |
}
|
| 7132 |
} catch ( e ) {
|
| 7133 |
_wpbc?.dev?.error?.( 'inspector._post_render_ui', e );
|
| 7134 |
}
|
| 7135 |
}
|
| 7136 |
|
| 7137 |
|
| 7138 |
_apply_control_from_event(e) {
|
| 7139 |
if ( !this.panel.contains( e.target ) ) return;
|
| 7140 |
|
| 7141 |
const t = /** @type {HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement} */ (e.target);
|
| 7142 |
const key = t?.dataset?.inspectorKey;
|
| 7143 |
if ( !key ) return;
|
| 7144 |
|
| 7145 |
const el = this.selected_el;
|
| 7146 |
if ( !el || !document.body.contains( el ) ) return;
|
| 7147 |
|
| 7148 |
let v;
|
| 7149 |
if ( t instanceof HTMLInputElement && t.type === 'checkbox' ) {
|
| 7150 |
v = !!t.checked;
|
| 7151 |
t.setAttribute( 'aria-checked', v ? 'true' : 'false' ); // Keep ARIA state in sync for toggles (schema and template paths).
|
| 7152 |
} else if ( t instanceof HTMLInputElement && t.type === 'number' ) {
|
| 7153 |
v = (t.value === '' ? '' : Number( t.value ));
|
| 7154 |
} else {
|
| 7155 |
v = t.value;
|
| 7156 |
}
|
| 7157 |
|
| 7158 |
if ( key === 'id' ) {
|
| 7159 |
const unique = this.builder?.id?.set_field_id?.( el, v );
|
| 7160 |
if ( unique != null && t.value !== unique ) t.value = unique;
|
| 7161 |
|
| 7162 |
} else if ( key === 'name' ) {
|
| 7163 |
const unique = this.builder?.id?.set_field_name?.( el, v );
|
| 7164 |
if ( unique != null && t.value !== unique ) t.value = unique;
|
| 7165 |
|
| 7166 |
} else if ( key === 'html_id' ) {
|
| 7167 |
const applied = this.builder?.id?.set_field_html_id?.( el, v );
|
| 7168 |
if ( applied != null && t.value !== applied ) t.value = applied;
|
| 7169 |
|
| 7170 |
} else if ( key === 'columns' && el.classList.contains( 'wpbc_bfb__section' ) ) {
|
| 7171 |
const v_int = parseInt( String( v ), 10 );
|
| 7172 |
if ( Number.isFinite( v_int ) ) {
|
| 7173 |
const clamped = w.WPBC_BFB_Core.WPBC_BFB_Sanitize.clamp( v_int, 1, 4 );
|
| 7174 |
this.builder?.set_section_columns?.( el, clamped );
|
| 7175 |
if ( String( clamped ) !== t.value ) t.value = String( clamped );
|
| 7176 |
}
|
| 7177 |
|
| 7178 |
} else {
|
| 7179 |
if ( t instanceof HTMLInputElement && t.type === 'checkbox' ) {
|
| 7180 |
el.setAttribute( 'data-' + key, String( !!v ) );
|
| 7181 |
} else if ( t instanceof HTMLInputElement && t.type === 'number' ) {
|
| 7182 |
if ( t.value === '' || !Number.isFinite( v ) ) {
|
| 7183 |
el.removeAttribute( 'data-' + key );
|
| 7184 |
} else {
|
| 7185 |
el.setAttribute( 'data-' + key, String( v ) );
|
| 7186 |
}
|
| 7187 |
} else if ( v == null ) {
|
| 7188 |
el.removeAttribute( 'data-' + key );
|
| 7189 |
} else {
|
| 7190 |
el.setAttribute( 'data-' + key, (typeof v === 'object') ? JSON.stringify( v ) : String( v ) );
|
| 7191 |
}
|
| 7192 |
}
|
| 7193 |
|
| 7194 |
// Update preview/overlay
|
| 7195 |
if ( el.classList.contains( 'wpbc_bfb__field' ) ) {
|
| 7196 |
if ( this.builder?.preview_mode ) this.builder.render_preview( el );
|
| 7197 |
else this.builder.add_overlay_toolbar( el );
|
| 7198 |
} else {
|
| 7199 |
this.builder.add_overlay_toolbar( el );
|
| 7200 |
}
|
| 7201 |
|
| 7202 |
if ( this._needs_rerender( el, key, e ) ) {
|
| 7203 |
this._schedule_render_preserving_focus( 0 );
|
| 7204 |
}
|
| 7205 |
}
|
| 7206 |
|
| 7207 |
_needs_rerender(el, key, _e) {
|
| 7208 |
if ( el.classList.contains( 'wpbc_bfb__section' ) && key === 'columns' ) return true;
|
| 7209 |
return false;
|
| 7210 |
}
|
| 7211 |
|
| 7212 |
bind_to_field(field_el) {
|
| 7213 |
this.selected_el = field_el;
|
| 7214 |
this.render();
|
| 7215 |
}
|
| 7216 |
|
| 7217 |
clear() {
|
| 7218 |
this.selected_el = null;
|
| 7219 |
if ( this._render_timer ) {
|
| 7220 |
clearTimeout( this._render_timer );
|
| 7221 |
this._render_timer = null;
|
| 7222 |
}
|
| 7223 |
// Also clear the section-cols hint on empty state.
|
| 7224 |
this.panel.removeAttribute('data-bfb-section-cols');
|
| 7225 |
this.panel.innerHTML = '<div class="wpbc_bfb__inspector__empty">Select a field to edit its options.</div>';
|
| 7226 |
}
|
| 7227 |
|
| 7228 |
_schedule_render_preserving_focus(delay = 200) {
|
| 7229 |
const active = /** @type {HTMLInputElement|HTMLTextAreaElement|HTMLElement|null} */ (document.activeElement);
|
| 7230 |
const activeKey = active?.dataset?.inspectorKey || null;
|
| 7231 |
let selStart = null, selEnd = null;
|
| 7232 |
|
| 7233 |
if ( active && 'selectionStart' in active && 'selectionEnd' in active ) {
|
| 7234 |
// @ts-ignore
|
| 7235 |
selStart = active.selectionStart;
|
| 7236 |
// @ts-ignore
|
| 7237 |
selEnd = active.selectionEnd;
|
| 7238 |
}
|
| 7239 |
|
| 7240 |
if ( this._render_timer ) clearTimeout( this._render_timer );
|
| 7241 |
this._render_timer = /** @type {unknown} */ (setTimeout( () => {
|
| 7242 |
this.render();
|
| 7243 |
if ( activeKey ) {
|
| 7244 |
const next = /** @type {HTMLInputElement|HTMLTextAreaElement|HTMLElement|null} */ (
|
| 7245 |
this.panel.querySelector( `[data-inspector-key="${activeKey}"]` )
|
| 7246 |
);
|
| 7247 |
if ( next ) {
|
| 7248 |
next.focus();
|
| 7249 |
try {
|
| 7250 |
if ( selStart != null && selEnd != null && typeof next.setSelectionRange === 'function' ) {
|
| 7251 |
// @ts-ignore
|
| 7252 |
next.setSelectionRange( selStart, selEnd );
|
| 7253 |
}
|
| 7254 |
} catch( e ){ _wpbc?.dev?.error( '_render_timer', e ); }
|
| 7255 |
}
|
| 7256 |
}
|
| 7257 |
}, delay ));
|
| 7258 |
}
|
| 7259 |
|
| 7260 |
render() {
|
| 7261 |
|
| 7262 |
const el = this.selected_el;
|
| 7263 |
if ( !el || !document.body.contains( el ) ) return this.clear();
|
| 7264 |
|
| 7265 |
// Reset section-cols hint unless we set it later for a section.
|
| 7266 |
this.panel.removeAttribute( 'data-bfb-section-cols' );
|
| 7267 |
|
| 7268 |
const prev_scroll = this.panel.scrollTop;
|
| 7269 |
|
| 7270 |
// Section
|
| 7271 |
if ( el.classList.contains( 'wpbc_bfb__section' ) ) {
|
| 7272 |
let tpl = null;
|
| 7273 |
try {
|
| 7274 |
tpl = (w.wp && wp.template && document.getElementById( 'tmpl-wpbc-bfb-inspector-section' )) ? wp.template( 'wpbc-bfb-inspector-section' ) : null;
|
| 7275 |
} catch ( _ ) {
|
| 7276 |
tpl = null;
|
| 7277 |
}
|
| 7278 |
|
| 7279 |
if ( tpl ) {
|
| 7280 |
this.panel.innerHTML = tpl( {} );
|
| 7281 |
this._enforce_default_group_open();
|
| 7282 |
this._set_panel_section_cols( el );
|
| 7283 |
this._post_render_ui();
|
| 7284 |
this.panel.scrollTop = prev_scroll;
|
| 7285 |
return;
|
| 7286 |
}
|
| 7287 |
|
| 7288 |
const Factory = w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Inspector_Factory;
|
| 7289 |
const schemas = w.WPBC_BFB_Schemas || {};
|
| 7290 |
const entry = schemas['section'] || null;
|
| 7291 |
if ( entry && Factory ) {
|
| 7292 |
this.panel.innerHTML = '';
|
| 7293 |
Factory.render(
|
| 7294 |
this.panel,
|
| 7295 |
entry,
|
| 7296 |
{},
|
| 7297 |
{ el, builder: this.builder, type: 'section', title: entry.label || 'Section' }
|
| 7298 |
);
|
| 7299 |
this._enforce_default_group_open();
|
| 7300 |
|
| 7301 |
// --- Safety net: if for any reason the slot didn’t render chips, inject them now.
|
| 7302 |
try {
|
| 7303 |
const hasSlotHost =
|
| 7304 |
this.panel.querySelector( '[data-bfb-slot="layout_chips"]' ) ||
|
| 7305 |
this.panel.querySelector( '.inspector__row--layout-chips .wpbc_bfb__layout_chips' ) ||
|
| 7306 |
this.panel.querySelector( '#wpbc_bfb__layout_chips_host' );
|
| 7307 |
|
| 7308 |
const hasChips =
|
| 7309 |
!!this.panel.querySelector( '.wpbc_bfb__layout_chip' );
|
| 7310 |
|
| 7311 |
if ( !hasChips ) {
|
| 7312 |
// Create a host if missing and render chips into it.
|
| 7313 |
const host = (function ensureHost(root) {
|
| 7314 |
let h =
|
| 7315 |
root.querySelector( '[data-bfb-slot="layout_chips"]' ) ||
|
| 7316 |
root.querySelector( '.inspector__row--layout-chips .wpbc_bfb__layout_chips' ) ||
|
| 7317 |
root.querySelector( '#wpbc_bfb__layout_chips_host' );
|
| 7318 |
if ( h ) return h;
|
| 7319 |
// Fallback host inside (or after) the “layout” group
|
| 7320 |
const fields =
|
| 7321 |
root.querySelector( '.wpbc_bfb__inspector__group[data-group="layout"] .group__fields' ) ||
|
| 7322 |
root.querySelector( '.group__fields' ) || root;
|
| 7323 |
const row = document.createElement( 'div' );
|
| 7324 |
row.className = 'inspector__row inspector__row--layout-chips';
|
| 7325 |
const lab = document.createElement( 'label' );
|
| 7326 |
lab.className = 'inspector__label';
|
| 7327 |
lab.textContent = 'Layout';
|
| 7328 |
const ctl = document.createElement( 'div' );
|
| 7329 |
ctl.className = 'inspector__control';
|
| 7330 |
h = document.createElement( 'div' );
|
| 7331 |
h.className = 'wpbc_bfb__layout_chips';
|
| 7332 |
h.setAttribute( 'data-bfb-slot', 'layout_chips' );
|
| 7333 |
ctl.appendChild( h );
|
| 7334 |
row.appendChild( lab );
|
| 7335 |
row.appendChild( ctl );
|
| 7336 |
fields.appendChild( row );
|
| 7337 |
return h;
|
| 7338 |
})( this.panel );
|
| 7339 |
|
| 7340 |
const L = (w.WPBC_BFB_Core && w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Layout_Chips) ;
|
| 7341 |
if ( L && typeof L.render_for_section === 'function' ) {
|
| 7342 |
host.innerHTML = '';
|
| 7343 |
L.render_for_section( this.builder, el, host );
|
| 7344 |
}
|
| 7345 |
}
|
| 7346 |
} catch( e ){ _wpbc?.dev?.error( 'WPBC_BFB_Inspector - render', e ); }
|
| 7347 |
|
| 7348 |
this._set_panel_section_cols( el );
|
| 7349 |
this.panel.scrollTop = prev_scroll;
|
| 7350 |
return;
|
| 7351 |
}
|
| 7352 |
|
| 7353 |
this.panel.innerHTML = '<div class="wpbc_bfb__inspector__empty">Select a field to edit its options.</div>';
|
| 7354 |
return;
|
| 7355 |
}
|
| 7356 |
|
| 7357 |
// Field
|
| 7358 |
if ( !el.classList.contains( 'wpbc_bfb__field' ) ) return this.clear();
|
| 7359 |
|
| 7360 |
const data = w.WPBC_BFB_Core.WPBC_Form_Builder_Helper.get_all_data_attributes( el );
|
| 7361 |
const type = data.type || 'text';
|
| 7362 |
|
| 7363 |
function _get_tpl(id) {
|
| 7364 |
if ( !w.wp || !wp.template ) return null;
|
| 7365 |
if ( !document.getElementById( 'tmpl-' + id ) ) return null;
|
| 7366 |
try {
|
| 7367 |
return wp.template( id );
|
| 7368 |
} catch ( e ) {
|
| 7369 |
return null;
|
| 7370 |
}
|
| 7371 |
}
|
| 7372 |
|
| 7373 |
const tpl_id = `wpbc-bfb-inspector-${type}`;
|
| 7374 |
const tpl = _get_tpl( tpl_id );
|
| 7375 |
const generic_tpl = _get_tpl( 'wpbc-bfb-inspector-generic' );
|
| 7376 |
|
| 7377 |
const schemas = w.WPBC_BFB_Schemas || {};
|
| 7378 |
const schema_for_type = schemas[type] || null;
|
| 7379 |
const Factory = w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Inspector_Factory;
|
| 7380 |
|
| 7381 |
if ( tpl ) {
|
| 7382 |
// NEW: merge schema defaults so missing keys (esp. booleans) honor defaults on first paint
|
| 7383 |
const hasOwn = Function.call.bind( Object.prototype.hasOwnProperty );
|
| 7384 |
const props = (schema_for_type && schema_for_type.schema && schema_for_type.schema.props) ? schema_for_type.schema.props : {};
|
| 7385 |
const merged = { ...data };
|
| 7386 |
if ( props ) {
|
| 7387 |
Object.keys( props ).forEach( (k) => {
|
| 7388 |
const meta = props[k] || {};
|
| 7389 |
if ( !hasOwn( data, k ) ) {
|
| 7390 |
if ( hasOwn( meta, 'default' ) ) {
|
| 7391 |
// Coerce booleans to a real boolean; leave others as-is
|
| 7392 |
merged[k] = (meta.type === 'boolean') ? !!meta.default : meta.default;
|
| 7393 |
}
|
| 7394 |
} else if ( meta.type === 'boolean' ) {
|
| 7395 |
// Explicit empty values are legacy unchecked booleans, not missing defaults.
|
| 7396 |
merged[k] = w.WPBC_BFB_Core.WPBC_BFB_Sanitize.coerce_boolean( data[k], false );
|
| 7397 |
} else if ( data[k] === '' && hasOwn( meta, 'default' ) ) {
|
| 7398 |
merged[k] = meta.default;
|
| 7399 |
}
|
| 7400 |
} );
|
| 7401 |
}
|
| 7402 |
this.panel.innerHTML = tpl( merged );
|
| 7403 |
|
| 7404 |
this._post_render_ui();
|
| 7405 |
} else if ( schema_for_type && Factory ) {
|
| 7406 |
this.panel.innerHTML = '';
|
| 7407 |
Factory.render(
|
| 7408 |
this.panel,
|
| 7409 |
schema_for_type,
|
| 7410 |
{ ...data },
|
| 7411 |
{ el, builder: this.builder, type, title: data.label || '' }
|
| 7412 |
);
|
| 7413 |
// Ensure toggle normalizers and slider/number/unit wiring are attached.
|
| 7414 |
this._post_render_ui();
|
| 7415 |
} else if ( generic_tpl ) {
|
| 7416 |
this.panel.innerHTML = generic_tpl( { ...data } );
|
| 7417 |
this._post_render_ui();
|
| 7418 |
} else {
|
| 7419 |
|
| 7420 |
const msg = `There are no Inspector wp.template "${tpl_id}" or Schema for this "${String( type || '' )}" element.`;
|
| 7421 |
this.panel.innerHTML = '';
|
| 7422 |
const div = document.createElement( 'div' );
|
| 7423 |
div.className = 'wpbc_bfb__inspector__empty';
|
| 7424 |
div.textContent = msg; // safe.
|
| 7425 |
this.panel.appendChild( div );
|
| 7426 |
}
|
| 7427 |
|
| 7428 |
this._enforce_default_group_open();
|
| 7429 |
this.panel.scrollTop = prev_scroll;
|
| 7430 |
}
|
| 7431 |
|
| 7432 |
_enforce_default_group_open() {
|
| 7433 |
const groups = Array.from( this.panel.querySelectorAll( '.wpbc_bfb__inspector__group' ) );
|
| 7434 |
if ( !groups.length ) return;
|
| 7435 |
|
| 7436 |
let found = false;
|
| 7437 |
groups.forEach( (g) => {
|
| 7438 |
if ( !found && g.classList.contains( 'is-open' ) ) {
|
| 7439 |
found = true;
|
| 7440 |
} else {
|
| 7441 |
if ( g.classList.contains( 'is-open' ) ) {
|
| 7442 |
g.classList.remove( 'is-open' );
|
| 7443 |
g.dispatchEvent( new Event( 'wpbc:collapsible:close', { bubbles: true } ) );
|
| 7444 |
} else {
|
| 7445 |
g.classList.remove( 'is-open' );
|
| 7446 |
}
|
| 7447 |
}
|
| 7448 |
} );
|
| 7449 |
|
| 7450 |
if ( !found ) {
|
| 7451 |
groups[0].classList.add( 'is-open' );
|
| 7452 |
groups[0].dispatchEvent( new Event( 'wpbc:collapsible:open', { bubbles: true } ) );
|
| 7453 |
}
|
| 7454 |
}
|
| 7455 |
|
| 7456 |
/**
|
| 7457 |
* Set data-bfb-section-cols on the inspector panel based on the current section.
|
| 7458 |
* Uses the registered compute fn if available; falls back to direct DOM.
|
| 7459 |
* @param {HTMLElement} sectionEl
|
| 7460 |
*/
|
| 7461 |
_set_panel_section_cols(sectionEl) {
|
| 7462 |
try {
|
| 7463 |
// Prefer the already-registered value_from helper if present.
|
| 7464 |
var compute = w.wpbc_bfb_inspector_factory_value_from && w.wpbc_bfb_inspector_factory_value_from.compute_section_columns;
|
| 7465 |
|
| 7466 |
var cols = 1;
|
| 7467 |
if ( typeof compute === 'function' ) {
|
| 7468 |
cols = compute( { el: sectionEl } ) || 1;
|
| 7469 |
} else {
|
| 7470 |
// Fallback: compute directly from the DOM.
|
| 7471 |
var row = sectionEl && sectionEl.querySelector( ':scope > .wpbc_bfb__row' );
|
| 7472 |
cols = row ? (row.querySelectorAll( ':scope > .wpbc_bfb__column' ).length || 1) : 1;
|
| 7473 |
if ( cols < 1 ) cols = 1;
|
| 7474 |
if ( cols > 4 ) cols = 4;
|
| 7475 |
}
|
| 7476 |
this.panel.setAttribute( 'data-bfb-section-cols', String( cols ) );
|
| 7477 |
} catch ( _ ) {
|
| 7478 |
}
|
| 7479 |
}
|
| 7480 |
|
| 7481 |
|
| 7482 |
_create_fallback_panel() {
|
| 7483 |
const p = document.createElement( 'div' );
|
| 7484 |
p.id = 'wpbc_bfb__inspector';
|
| 7485 |
p.className = 'wpbc_bfb__inspector';
|
| 7486 |
document.body.appendChild( p );
|
| 7487 |
return /** @type {HTMLDivElement} */ (p);
|
| 7488 |
}
|
| 7489 |
}
|
| 7490 |
|
| 7491 |
// Export class + ready signal.
|
| 7492 |
w.WPBC_BFB_Inspector = WPBC_BFB_Inspector;
|
| 7493 |
document.dispatchEvent( new Event( 'wpbc_bfb_inspector_ready' ) );
|
| 7494 |
|
| 7495 |
})( window );
|
| 7496 |
|
| 7497 |
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["bfb-core.js","bfb-fields.js","bfb-ui.js","bfb-sync-code-tools-tab.js","bfb-inspector.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;ACruDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzoCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC93FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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":"wpbc_bfb.js","sourcesContent":["// ---------------------------------------------------------------------------------------------------------------------\r\n// == File  /includes/page-form-builder/_out/core/bfb-core.js == | 2025-09-10 15:47\r\n// ---------------------------------------------------------------------------------------------------------------------\r\n(function ( w ) {\r\n\t'use strict';\r\n\r\n\t// Single global namespace (idempotent & load-order safe).\r\n\tconst Core = ( w.WPBC_BFB_Core = w.WPBC_BFB_Core || {} );\r\n\tconst UI   = ( Core.UI = Core.UI || {} );\r\n\r\n\t/**\r\n\t * Core sanitize/escape/normalize helpers.\r\n\t * All methods use snake_case; camelCase aliases are provided for backwards compatibility.\r\n\t */\r\n\tCore.WPBC_BFB_Sanitize = class {\r\n\r\n\t\t/**\r\n\t\t * Escape text for safe use in CSS selectors.\r\n\t\t * @param {string} s - raw selector fragment\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic esc_css(s) {\r\n\t\t\treturn (w.CSS && w.CSS.escape) ? w.CSS.escape( String( s ) ) : String( s ).replace( /([^\\w-])/g, '\\\\$1' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Escape a value for attribute selectors, e.g. [data-id=\"<value>\"].\r\n\t\t * @param {string} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic esc_attr_value_for_selector(v) {\r\n\t\t\treturn String( v )\r\n\t\t\t\t.replace( /\\\\/g, '\\\\\\\\' )\r\n\t\t\t\t.replace( /\"/g, '\\\\\"' )\r\n\t\t\t\t.replace( /\\n/g, '\\\\A ' )\r\n\t\t\t\t.replace( /\\]/g, '\\\\]' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Sanitize into a broadly compatible HTML id: letters, digits, - _ : . ; must start with a letter.\r\n\t\t * @param {string} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic sanitize_html_id(v) {\r\n\t\t\tlet s = (v == null ? '' : String( v )).trim();\r\n\t\t\ts     = s\r\n\t\t\t\t.replace( /\\s+/g, '-' )\r\n\t\t\t\t.replace( /[^A-Za-z0-9\\-_\\:.]/g, '-' )\r\n\t\t\t\t.replace( /-+/g, '-' )\r\n\t\t\t\t.replace( /^[-_.:]+|[-_.:]+$/g, '' );\r\n\t\t\tif ( !s ) return 'field';\r\n\t\t\tif ( !/^[A-Za-z]/.test( s ) ) s = 'f-' + s;\r\n\t\t\treturn s;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Sanitize into a safe HTML name token: letters, digits, _ -\r\n\t\t * Must start with a letter; no dots/brackets/spaces.\r\n\t\t * @param {string} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic sanitize_html_name(v) {\r\n\r\n\t\t\tlet s = (v == null ? '' : String( v )).trim();\r\n\r\n\t\t\ts = s.replace( /\\s+/g, '_' ).replace( /[^A-Za-z0-9_-]/g, '_' ).replace( /_+/g, '_' );\r\n\r\n\t\t\tif ( ! s ) {\r\n\t\t\t\ts = 'field';\r\n\t\t\t}\r\n\t\t\tif ( ! /^[A-Za-z]/.test( s ) ) {\r\n\t\t\t\ts = 'f_' + s;\r\n\t\t\t}\r\n\t\t\treturn s;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Escape for HTML text/attributes (not URLs).\r\n\t\t * @param {any} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic escape_html(v) {\r\n\t\t\tif ( v == null ) {\r\n\t\t\t\treturn '';\r\n\t\t\t}\r\n\t\t\treturn String( v )\r\n\t\t\t\t.replace( /&/g, '&amp;' )\r\n\t\t\t\t.replace( /\"/g, '&quot;' )\r\n\t\t\t\t.replace( /'/g, '&#039;' )\r\n\t\t\t\t.replace( /</g, '&lt;' )\r\n\t\t\t\t.replace( />/g, '&gt;' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Escape minimal set for attribute-safety without slugging.\r\n\t\t * Keeps original human text; escapes &, <, >, \" and ' only.\r\n\t\t * @param {string} s\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic escape_value_for_attr(s) {\r\n\t\t\treturn String( s == null ? '' : s )\r\n\t\t\t\t.replace( /&/g, '&amp;' )\r\n\t\t\t\t.replace( /</g, '&lt;' )\r\n\t\t\t\t.replace( />/g, '&gt;' )\r\n\t\t\t\t.replace( /\"/g, '&quot;' )\r\n\t\t\t\t.replace( /'/g, '&#39;' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Sanitize a space-separated CSS class list.\r\n\t\t * @param {any} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic sanitize_css_classlist(v) {\r\n\t\t\tif ( v == null ) return '';\r\n\t\t\treturn String( v ).replace( /[^\\w\\- ]+/g, ' ' ).replace( /\\s+/g, ' ' ).trim();\r\n\t\t}\r\n// == NEW ==\r\n\t\t/**\r\n\t\t * Turn an arbitrary value into a conservative \"token\" (underscores, hyphens allowed).\r\n\t\t * Useful for shortcode tokens, ids in plain text, etc.\r\n\t\t * @param {any} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic to_token(v) {\r\n\t\t\treturn String( v ?? '' )\r\n\t\t\t\t.trim()\r\n\t\t\t\t.replace( /\\s+/g, '_' )\r\n\t\t\t\t.replace( /[^A-Za-z0-9_\\-]/g, '' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Convert to kebab-case (letters, digits, hyphens).\r\n\t\t * @param {any} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic to_kebab(v) {\r\n\t\t\treturn String( v ?? '' )\r\n\t\t\t\t.trim()\r\n\t\t\t\t.replace( /[_\\s]+/g, '-' )\r\n\t\t\t\t.replace( /[^A-Za-z0-9-]/g, '' )\r\n\t\t\t\t.replace( /-+/g, '-' )\r\n\t\t\t\t.toLowerCase();\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Truthy normalization for form-like inputs: true, 'true', 1, '1', 'yes', 'on'.\r\n\t\t * @param {any} v\r\n\t\t * @returns {boolean}\r\n\t\t */\r\n\t\tstatic is_truthy(v) {\r\n\t\t\tif ( typeof v === 'boolean' ) return v;\r\n\t\t\tconst s = String( v ?? '' ).trim().toLowerCase();\r\n\t\t\treturn s === 'true' || s === '1' || s === 'yes' || s === 'on';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Coerce to boolean with an optional default for empty values.\r\n\t\t * @param {any} v\r\n\t\t * @param {boolean} [def=false]\r\n\t\t * @returns {boolean}\r\n\t\t */\r\n\t\tstatic coerce_boolean(v, def = false) {\r\n\t\t\tif ( v == null || v === '' ) return def;\r\n\t\t\treturn this.is_truthy( v );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Parse a \"percent-like\" value ('33'|'33%'|33) with fallback.\r\n\t\t * @param {string|number|null|undefined} v\r\n\t\t * @param {number} fallback_value\r\n\t\t * @returns {number}\r\n\t\t */\r\n\t\tstatic parse_percent(v, fallback_value) {\r\n\t\t\tif ( v == null ) {\r\n\t\t\t\treturn fallback_value;\r\n\t\t\t}\r\n\t\t\tconst s = String( v ).trim();\r\n\t\t\tconst n = parseFloat( s.replace( /%/g, '' ) );\r\n\t\t\treturn Number.isFinite( n ) ? n : fallback_value;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Clamp a number to the [min, max] range.\r\n\t\t * @param {number} n\r\n\t\t * @param {number} min\r\n\t\t * @param {number} max\r\n\t\t * @returns {number}\r\n\t\t */\r\n\t\tstatic clamp(n, min, max) {\r\n\t\t\treturn Math.max( min, Math.min( max, n ) );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Escape a value for inclusion inside a quoted HTML attribute (double quotes).\r\n\t\t * Replaces newlines with spaces and double quotes with single quotes.\r\n\t\t * @param {any} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic escape_for_attr_quoted(v) {\r\n\t\t\tif ( v == null ) return '';\r\n\t\t\treturn String( v ).replace( /\\r?\\n/g, ' ' ).replace( /\"/g, '\\'' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Escape for shortcode-like tokens where double quotes and newlines should be neutralized.\r\n\t\t * @param {any} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic escape_for_shortcode(v) {\r\n\t\t\treturn String( v ?? '' ).replace( /\"/g, '\\\\\"' ).replace( /\\r?\\n/g, ' ' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * JSON.parse with fallback (no throw).\r\n\t\t * @param {string} s\r\n\t\t * @param {any} [fallback=null]\r\n\t\t * @returns {any}\r\n\t\t */\r\n\t\tstatic safe_json_parse(s, fallback = null) {\r\n\t\t\ttry {\r\n\t\t\t\treturn JSON.parse( s );\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t\treturn fallback;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Stringify data-* attribute value safely (objects -> JSON, others -> String).\r\n\t\t * @param {any} v\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic stringify_data_value(v) {\r\n\t\t\tif ( typeof v === 'object' && v !== null ) {\r\n\t\t\t\ttry {\r\n\t\t\t\t\treturn JSON.stringify( v );\r\n\t\t\t\t} catch {\r\n\t\t\t\t\tconsole.error( 'WPBC: stringify_data_value' );\r\n\t\t\t\t\treturn '';\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn String( v );\r\n\t\t}\r\n\r\n\t\t// -------------------------------------------------------------------------------------------------------------\r\n\t\t// Strict value guards for CSS lengths and hex colors (defense-in-depth).\r\n\t\t// -------------------------------------------------------------------------------------------------------------\r\n\t\t/**\r\n\t\t * Sanitize a CSS length. Allows: px, %, rem, em (lower/upper).\r\n\t\t * Returns fallback if invalid.\r\n\t\t * @param {any} v\r\n\t\t * @param {string} [fallback='100%']\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic sanitize_css_len(v, fallback = '100%') {\r\n\t\t\tconst s = String( v ?? '' ).trim();\r\n\t\t\tconst m = s.match( /^(-?\\d+(?:\\.\\d+)?)(px|%|rem|em)$/i );\r\n\t\t\treturn m ? m[0] : String( fallback );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Sanitize a hex color. Allows #rgb or #rrggbb (case-insensitive).\r\n\t\t * Returns fallback if invalid.\r\n\t\t * @param {any} v\r\n\t\t * @param {string} [fallback='#e0e0e0']\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic sanitize_hex_color(v, fallback = '#e0e0e0') {\r\n\t\t\tconst s = String( v ?? '' ).trim();\r\n\t\t\treturn /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i.test( s ) ? s : String( fallback );\r\n\t\t}\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * WPBC ID / Name service. Generates, sanitizes, and ensures uniqueness for field ids/names/html_ids within the\r\n\t * canvas.\r\n\t */\r\n\tCore.WPBC_BFB_IdService = class  {\r\n\r\n\t\t/**\r\n\t\t * Constructor. Set root container of the form pages.\r\n\t\t *\r\n\t\t * @param {HTMLElement} pages_container - Root container of the form pages.\r\n\t\t */\r\n\t\tconstructor( pages_container ) {\r\n\t\t\tthis.pages_container = pages_container;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Ensure a unique **internal** field id (stored in data-id) within the canvas.\r\n\t\t * Starts from a desired id (already sanitized or not) and appends suffixes if needed.\r\n\t\t *\r\n\t\t * @param {string} baseId - Desired id.\r\n\t\t * @returns {string} Unique id.\r\n\t\t */\r\n\t\tensure_unique_field_id(baseId, currentEl = null) {\r\n\t\t\tconst base    = Core.WPBC_BFB_Sanitize.sanitize_html_id( baseId );\r\n\t\t\tlet id        = base || 'field';\r\n\t\t\tconst esc     = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );\r\n\t\t\tconst escUid  = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );\r\n\t\t\tconst notSelf = currentEl?.dataset?.uid ? `:not([data-uid=\"${escUid( currentEl.dataset.uid )}\"])` : '';\r\n\t\t\twhile ( this.pages_container?.querySelector(\r\n\t\t\t\t`.wpbc_bfb__panel--preview .wpbc_bfb__field${notSelf}[data-id=\"${esc(id)}\"], .wpbc_bfb__panel--preview .wpbc_bfb__section${notSelf}[data-id=\"${esc(id)}\"]`\r\n\t\t\t) ) {\r\n\t\t\t\t// Excludes self by data-uid .\r\n\t\t\t\tconst found = this.pages_container.querySelector( `.wpbc_bfb__panel--preview .wpbc_bfb__field[data-id=\"${esc( id )}\"], .wpbc_bfb__panel--preview .wpbc_bfb__section[data-id=\"${esc( id )}\"]` );\r\n\t\t\t\tif ( found && currentEl && found === currentEl ) {\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t\tid = `${base || 'field'}-${Math.random().toString( 36 ).slice( 2, 5 )}`;\r\n\t\t\t}\r\n\t\t\treturn id;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Ensure a unique HTML name across the form.\r\n\t\t *\r\n\t\t * @param {string} base - Desired base name (un/sanitized).\r\n\t\t * @param {HTMLElement|null} currentEl - If provided, ignore conflicts with this element.\r\n\t\t * @returns {string} Unique name.\r\n\t\t */\r\n\t\tensure_unique_field_name(base, currentEl = null) {\r\n\t\t\tlet name      = base || 'field';\r\n\t\t\tconst esc     = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );\r\n\t\t\tconst escUid  = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );\r\n\t\t\t// Exclude the current field *and any DOM mirrors of it* (same data-uid)\r\n\t\t\tconst uid     = currentEl?.dataset?.uid;\r\n\t\t\tconst notSelf = uid ? `:not([data-uid=\"${escUid( uid )}\"])` : '';\r\n\t\t\twhile ( true ) {\r\n\t\t\t\tconst selector = `.wpbc_bfb__panel--preview .wpbc_bfb__field${notSelf}[data-name=\"${esc( name )}\"]`;\r\n\t\t\t\tconst clashes  = this.pages_container?.querySelectorAll( selector ) || [];\r\n\t\t\t\tif ( clashes.length === 0 ) break;           // nobody else uses this name\r\n\t\t\t\tconst m = name.match( /-(\\d+)$/ );\r\n\t\t\t\tname    = m ? name.replace( /-\\d+$/, '-' + (Number( m[1] ) + 1) ) : `${base}-2`;\r\n\t\t\t}\r\n\t\t\treturn name;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Set field's INTERNAL id (data-id) on an element. Ensures uniqueness and optionally asks caller to refresh\r\n\t\t * preview.\r\n\t\t *\r\n\t\t * @param {HTMLElement} field_el - Field element in the canvas.\r\n\t\t * @param {string} newIdRaw - Desired id (un/sanitized).\r\n\t\t * @param {boolean} [renderPreview=false] - Caller can decide to re-render preview.\r\n\t\t * @returns {string} Applied unique id.\r\n\t\t */\r\n\t\tset_field_id( field_el, newIdRaw, renderPreview = false ) {\r\n\t\t\tconst desired = Core.WPBC_BFB_Sanitize.sanitize_html_id( newIdRaw );\r\n\t\t\tconst unique  = this.ensure_unique_field_id( desired, field_el );\r\n\t\t\tfield_el.setAttribute( 'data-id', unique );\r\n\t\t\tif ( renderPreview ) {\r\n\t\t\t\t// Caller decides if / when to render.\r\n\t\t\t}\r\n\t\t\treturn unique;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Set field's REQUIRED HTML name (data-name). Ensures sanitized + unique per form.\r\n\t\t * Falls back to sanitized internal id if user provides empty value.\r\n\t\t *\r\n\t\t * @param {HTMLElement} field_el - Field element in the canvas.\r\n\t\t * @param {string} newNameRaw - Desired name (un/sanitized).\r\n\t\t * @param {boolean} [renderPreview=false] - Caller can decide to re-render preview.\r\n\t\t * @returns {string} Applied unique name.\r\n\t\t */\r\n\t\tset_field_name( field_el, newNameRaw, renderPreview = false ) {\r\n\t\t\tconst raw  = (newNameRaw == null ? '' : String( newNameRaw )).trim();\r\n\t\t\tconst base = raw\r\n\t\t\t\t? Core.WPBC_BFB_Sanitize.sanitize_html_name( raw )\r\n\t\t\t\t: Core.WPBC_BFB_Sanitize.sanitize_html_name( field_el.getAttribute( 'data-id' ) || 'field' );\r\n\r\n\t\t\tconst unique = this.ensure_unique_field_name( base, field_el );\r\n\t\t\tfield_el.setAttribute( 'data-name', unique );\r\n\t\t\tif ( renderPreview ) {\r\n\t\t\t\t// Caller decides if / when to render.\r\n\t\t\t}\r\n\t\t\treturn unique;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Set field's OPTIONAL public HTML id (data-html_id). Empty value removes the attribute.\r\n\t\t * Ensures sanitization + uniqueness among other declared HTML ids.\r\n\t\t *\r\n\t\t * @param {HTMLElement} field_el - Field element in the canvas.\r\n\t\t * @param {string} newHtmlIdRaw - Desired html_id (optional).\r\n\t\t * @param {boolean} [renderPreview=false] - Caller can decide to re-render preview.\r\n\t\t * @returns {string} The applied html_id or empty string if removed.\r\n\t\t */\r\n\t\tset_field_html_id( field_el, newHtmlIdRaw, renderPreview = false ) {\r\n\t\t\tconst raw = (newHtmlIdRaw == null ? '' : String( newHtmlIdRaw )).trim();\r\n\r\n\t\t\tif ( raw === '' ) {\r\n\t\t\t\tfield_el.removeAttribute( 'data-html_id' );\r\n\t\t\t\tif ( renderPreview ) {\r\n\t\t\t\t\t// Caller decides if / when to render.\r\n\t\t\t\t}\r\n\t\t\t\treturn '';\r\n\t\t\t}\r\n\r\n\t\t\tconst desired = Core.WPBC_BFB_Sanitize.sanitize_html_id( raw );\r\n\t\t\tlet htmlId    = desired;\r\n\t\t\tconst esc     = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );\r\n\t\t\tconst escUid  = (v) => Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( v );\r\n\r\n\t\t\twhile ( true ) {\r\n\r\n\t\t\t\tconst uid     = field_el?.dataset?.uid;\r\n\t\t\t\tconst notSelf = uid ? `:not([data-uid=\"${escUid( uid )}\"])` : '';\r\n\r\n\t\t\t\tconst clashInCanvas = this.pages_container?.querySelector(\r\n\t\t\t\t\t`.wpbc_bfb__panel--preview .wpbc_bfb__field${notSelf}[data-html_id=\"${esc( htmlId )}\"],` +\r\n\t\t\t\t\t`.wpbc_bfb__panel--preview .wpbc_bfb__section${notSelf}[data-html_id=\"${esc( htmlId )}\"]`\r\n\t\t\t\t);\r\n\t\t\t\tconst domClash = document.getElementById( htmlId );\r\n\r\n\t\t\t\t// Allow when the only \"clash\" is inside this same field (e.g., the input you just rendered)\r\n\t\t\t\tconst domClashIsSelf = domClash === field_el || (domClash && field_el.contains( domClash ));\r\n\r\n\t\t\t\tif ( !clashInCanvas && (!domClash || domClashIsSelf) ) {\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst m = htmlId.match( /-(\\d+)$/ );\r\n\t\t\t\thtmlId  = m ? htmlId.replace( /-\\d+$/, '-' + (Number( m[1] ) + 1) ) : `${desired}-2`;\r\n\t\t\t}\r\n\r\n\t\t\tfield_el.setAttribute( 'data-html_id', htmlId );\r\n\t\t\tif ( renderPreview ) {\r\n\t\t\t\t// Caller decides if / when to render.\r\n\t\t\t}\r\n\t\t\treturn htmlId;\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * WPBC Layout service. Encapsulates column width math with gap handling, presets, and utilities.\r\n\t */\r\n\tCore.WPBC_BFB_LayoutService = class  {\r\n\r\n\t\t/**\r\n\t\t * Constructor. Set options with gap between columns (%).\r\n\t\t *\r\n\t\t * @param {{ col_gap_percent?: number }} [opts] - Options with gap between columns (%).\r\n\t\t */\r\n\t\tconstructor( opts = {} ) {\r\n\t\t\tthis.col_gap_percent = Number.isFinite( +opts.col_gap_percent ) ? +opts.col_gap_percent : 3;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Compute normalized flex-basis values for a row, respecting column gaps.\r\n\t\t * Returns bases that sum to available = 100 - (n-1)*gap.\r\n\t\t *\r\n\t\t * @param {HTMLElement} row_el - Row element containing .wpbc_bfb__column children.\r\n\t\t * @param {number} [gap_percent=this.col_gap_percent] - Gap percent between columns.\r\n\t\t * @returns {{available:number,bases:number[]}} Available space and basis values.\r\n\t\t */\r\n\t\tcompute_effective_bases_from_row( row_el, gap_percent = this.col_gap_percent ) {\r\n\t\t\tconst cols = Array.from( row_el?.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );\r\n\t\t\tconst n    = cols.length || 1;\r\n\r\n\t\t\tconst raw = cols.map( ( col ) => {\r\n\t\t\t\tconst w = col.style.flexBasis || '';\r\n\t\t\t\tconst p = Core.WPBC_BFB_Sanitize.parse_percent( w, NaN );\r\n\t\t\t\treturn Number.isFinite( p ) ? p : (100 / n);\r\n\t\t\t} );\r\n\r\n\t\t\tconst sum_raw    = raw.reduce( ( a, b ) => a + b, 0 ) || 100;\r\n\t\t\tconst gp         = Number.isFinite( +gap_percent ) ? +gap_percent : 3;\r\n\t\t\tconst total_gaps = Math.max( 0, n - 1 ) * gp;\r\n\t\t\tconst available  = Math.max( 0, 100 - total_gaps );\r\n\t\t\tconst scale      = available / sum_raw;\r\n\r\n\t\t\treturn {\r\n\t\t\t\tavailable,\r\n\t\t\t\tbases: raw.map( ( p ) => Math.max( 0, p * scale ) )\r\n\t\t\t};\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Apply computed bases to the row's columns (sets flex-basis %).\r\n\t\t *\r\n\t\t * @param {HTMLElement} row_el - Row element.\r\n\t\t * @param {number[]} bases - Array of basis values (percent of full 100).\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tapply_bases_to_row( row_el, bases ) {\r\n\t\t\tconst cols = Array.from( row_el?.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );\r\n\t\t\tcols.forEach( ( col, i ) => {\r\n\t\t\t\tconst p             = bases[i] ?? 0;\r\n\t\t\t\tcol.style.flexBasis = `${p}%`;\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Distribute columns evenly, respecting gap.\r\n\t\t *\r\n\t\t * @param {HTMLElement} row_el - Row element.\r\n\t\t * @param {number} [gap_percent=this.col_gap_percent] - Gap percent.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tset_equal_bases( row_el, gap_percent = this.col_gap_percent ) {\r\n\t\t\tconst cols       = Array.from( row_el?.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );\r\n\t\t\tconst n          = cols.length || 1;\r\n\t\t\tconst gp         = Number.isFinite( +gap_percent ) ? +gap_percent : 3;\r\n\t\t\tconst total_gaps = Math.max( 0, n - 1 ) * gp;\r\n\t\t\tconst available  = Math.max( 0, 100 - total_gaps );\r\n\t\t\tconst each       = available / n;\r\n\t\t\tthis.apply_bases_to_row( row_el, Array( n ).fill( each ) );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Apply a preset of relative weights to a row/section.\r\n\t\t *\r\n\t\t * @param {HTMLElement} sectionOrRow - .wpbc_bfb__section or its child .wpbc_bfb__row.\r\n\t\t * @param {number[]} weights - Relative weights (e.g., [1,3,1]).\r\n\t\t * @param {number} [gap_percent=this.col_gap_percent] - Gap percent.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tapply_layout_preset( sectionOrRow, weights, gap_percent = this.col_gap_percent ) {\r\n\t\t\tconst row = sectionOrRow?.classList?.contains( 'wpbc_bfb__row' )\r\n\t\t\t\t? sectionOrRow\r\n\t\t\t\t: sectionOrRow?.querySelector( ':scope > .wpbc_bfb__row' );\r\n\r\n\t\t\tif ( ! row ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst cols = Array.from( row.querySelectorAll( ':scope > .wpbc_bfb__column' ) || [] );\r\n\t\t\tconst n    = cols.length || 1;\r\n\r\n\t\t\tif ( ! Array.isArray( weights ) || weights.length !== n ) {\r\n\t\t\t\tthis.set_equal_bases( row, gap_percent );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst sum       = weights.reduce( ( a, b ) => a + Math.max( 0, Number( b ) || 0 ), 0 ) || 1;\r\n\t\t\tconst gp        = Number.isFinite( +gap_percent ) ? +gap_percent : 3;\r\n\t\t\tconst available = Math.max( 0, 100 - Math.max( 0, n - 1 ) * gp );\r\n\t\t\tconst bases     = weights.map( ( w ) => Math.max( 0, (Number( w ) || 0) / sum * available ) );\r\n\r\n\t\t\tthis.apply_bases_to_row( row, bases );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Build preset weight lists for a given column count.\r\n\t\t *\r\n\t\t * @param {number} n - Column count.\r\n\t\t * @returns {number[][]} List of weight arrays.\r\n\t\t */\r\n\t\tbuild_presets_for_columns( n ) {\r\n\t\t\tswitch ( n ) {\r\n\t\t\t\tcase 1:\r\n\t\t\t\t\treturn [ [ 1 ] ];\r\n\t\t\t\tcase 2:\r\n\t\t\t\t\treturn [ [ 1, 2 ], [ 2, 1 ], [ 1, 3 ], [ 3, 1 ] ];\r\n\t\t\t\tcase 3:\r\n\t\t\t\t\treturn [ [ 1, 3, 1 ], [ 1, 2, 1 ], [ 2, 1, 1 ], [ 1, 1, 2 ] ];\r\n\t\t\t\tcase 4:\r\n\t\t\t\t\treturn [ [ 1, 2, 2, 1 ], [ 2, 1, 1, 1 ], [ 1, 1, 1, 2 ] ];\r\n\t\t\t\tdefault:\r\n\t\t\t\t\treturn [ Array( n ).fill( 1 ) ];\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Format a human-readable label like \"50%/25%/25%\" from weights.\r\n\t\t *\r\n\t\t * @param {number[]} weights - Weight list.\r\n\t\t * @returns {string} Label string.\r\n\t\t */\r\n\t\tformat_preset_label( weights ) {\r\n\t\t\tconst sum = weights.reduce( ( a, b ) => a + (Number( b ) || 0), 0 ) || 1;\r\n\t\t\treturn weights.map( ( w ) => Math.round( ((Number( w ) || 0) / sum) * 100 ) ).join( '%/' ) + '%';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Parse comma/space separated weights into numbers.\r\n\t\t *\r\n\t\t * @param {string} input - User input like \"20,60,20\".\r\n\t\t * @returns {number[]} Parsed weights.\r\n\t\t */\r\n\t\tparse_weights( input ) {\r\n\t\t\tif ( ! input ) {\r\n\t\t\t\treturn [];\r\n\t\t\t}\r\n\t\t\treturn String( input )\r\n\t\t\t\t.replace( /[^\\d,.\\s]/g, '' )\r\n\t\t\t\t.split( /[\\s,]+/ )\r\n\t\t\t\t.map( ( s ) => parseFloat( s ) )\r\n\t\t\t\t.filter( ( n ) => Number.isFinite( n ) && n >= 0 );\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * WPBC Usage Limit service.\r\n\t * Counts field usage by key, compares to palette limits, and updates palette UI.\r\n\t */\r\n\tCore.WPBC_BFB_UsageLimitService = class  {\r\n\r\n\t\t/**\r\n\t\t * Constructor. Set pages_container and palette_ul.\r\n\t\t *\r\n\t\t * @param {HTMLElement} pages_container - Canvas root that holds placed fields.\r\n\t\t * @param {HTMLElement[]|null} palette_uls?:   Palettes UL with .wpbc_bfb__field items (may be null).\r\n\t\t */\r\n\t\tconstructor(pages_container, palette_uls) {\r\n\t\t\tthis.pages_container = pages_container;\r\n\t\t\t// Normalize to an array; we’ll still be robust if none provided.\r\n\t\t\tthis.palette_uls     = Array.isArray( palette_uls ) ? palette_uls : (palette_uls ? [ palette_uls ] : []);\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Parse usage limit from raw dataset value. Missing/invalid -> Infinity.\r\n\t\t *\r\n\t\t * @param {string|number|null|undefined} raw - Raw attribute value.\r\n\t\t * @returns {number} Limit number or Infinity.\r\n\t\t */\r\n\t\tstatic parse_usage_limit( raw ) {\r\n\t\t\tif ( raw == null ) {\r\n\t\t\t\treturn Infinity;\r\n\t\t\t}\r\n\t\t\tconst n = parseInt( raw, 10 );\r\n\t\t\treturn Number.isFinite( n ) ? n : Infinity;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Count how many instances exist per usage_key in the canvas.\r\n\t\t *\r\n\t\t * @returns {Record<string, number>} Map of usage_key -> count.\r\n\t\t */\r\n\t\tcount_usage_by_key() {\r\n\t\t\tconst used = {};\r\n\t\t\tconst all  = this.pages_container?.querySelectorAll( '.wpbc_bfb__panel--preview .wpbc_bfb__field:not(.is-invalid)' ) || [];\r\n\t\t\tall.forEach( ( el ) => {\r\n\t\t\t\tconst key = el.dataset.usage_key || el.dataset.type || el.dataset.id;\r\n\t\t\t\tif ( ! key ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tused[key] = (used[key] || 0) + 1;\r\n\t\t\t} );\r\n\t\t\treturn used;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Return palette limit for a given usage key (id of the palette item).\r\n\t\t *\r\n\t\t * @param {string} key - Usage key.\r\n\t\t * @returns {number} Limit value or Infinity.\r\n\t\t */\r\n\t\tget_limit_for_key(key) {\r\n\t\t\tif ( ! key ) {\r\n\t\t\t\treturn Infinity;\r\n\t\t\t}\r\n\t\t\t// Query across all palettes present now (stored + any newly added in DOM).\r\n\t\t\tconst roots            = this.palette_uls?.length ? this.palette_uls : document.querySelectorAll( '.wpbc_bfb__panel_field_types__ul' );\r\n\t\t\tconst allPaletteFields = Array.from( roots ).flatMap( r => Array.from( r.querySelectorAll( '.wpbc_bfb__field' ) ) );\r\n\t\t\tlet limit              = Infinity;\r\n\r\n\t\t\tallPaletteFields.forEach( (el) => {\r\n\t\t\t\tconst usage_key = el.dataset.usage_key || el.dataset.id;\r\n\t\t\t\tif ( el.dataset.id === key || usage_key === key ) {\r\n\t\t\t\t\tconst n = Core.WPBC_BFB_UsageLimitService.parse_usage_limit( el.dataset.usagenumber );\r\n\t\t\t\t\t// Choose the smallest finite limit (safest if palettes disagree).\r\n\t\t\t\t\tif ( n < limit ) {\r\n\t\t\t\t\t\tlimit = n;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\r\n\t\t\treturn limit;\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Disable/enable palette items based on current usage counts and limits.\r\n\t\t *\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tupdate_palette_ui() {\r\n\t\t\t// Always compute usage from the canvas:\r\n\t\t\tconst usage = this.count_usage_by_key();\r\n\r\n\t\t\t// Update all palettes currently in DOM (not just the initially captured ones)\r\n\t\t\tconst palettes = document.querySelectorAll( '.wpbc_bfb__panel_field_types__ul' );\r\n\r\n\t\t\tpalettes.forEach( (pal) => {\r\n\t\t\t\tpal.querySelectorAll( '.wpbc_bfb__field' ).forEach( (panel_field) => {\r\n\t\t\t\t\tconst paletteId   = panel_field.dataset.id;\r\n\t\t\t\t\tconst usageKey    = panel_field.dataset.usage_key || paletteId;\r\n\t\t\t\t\tconst raw_limit   = panel_field.dataset.usagenumber;\r\n\t\t\t\t\tconst perElLimit  = Core.WPBC_BFB_UsageLimitService.parse_usage_limit( raw_limit );\r\n\t\t\t\t\t// Effective limit across all palettes is the global limit for this key.\r\n\t\t\t\t\tconst globalLimit = this.get_limit_for_key( usageKey );\r\n\t\t\t\t\tconst limit       = Number.isFinite( globalLimit ) ? globalLimit : perElLimit; // prefer global min\r\n\r\n\t\t\t\t\tconst current = usage[usageKey] || 0;\r\n\t\t\t\t\tconst disable = Number.isFinite( limit ) && current >= limit;\r\n\r\n\t\t\t\t\tpanel_field.style.pointerEvents = disable ? 'none' : '';\r\n\t\t\t\t\tpanel_field.style.opacity       = disable ? '0.4' : '';\r\n\t\t\t\t\tpanel_field.setAttribute( 'aria-disabled', disable ? 'true' : 'false' );\r\n\t\t\t\t\tif ( disable ) {\r\n\t\t\t\t\t\tpanel_field.setAttribute( 'tabindex', '-1' );\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tpanel_field.removeAttribute( 'tabindex' );\r\n\t\t\t\t\t}\r\n\t\t\t\t} );\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Return how many valid instances with this usage key exist in the canvas.\r\n\t\t *\r\n\t\t * @param {string} key - Usage key of a palette item.\r\n\t\t * @returns {number} Count of existing non-invalid instances.\r\n\t\t */\r\n\t\tcount_for_key( key ) {\r\n\t\t\tif ( ! key ) {\r\n\t\t\t\treturn 0;\r\n\t\t\t}\r\n\t\t\treturn ( this.pages_container?.querySelectorAll(\r\n                `.wpbc_bfb__panel--preview .wpbc_bfb__field[data-usage_key=\"${Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( key )}\"]:not(.is-invalid), \r\n                 .wpbc_bfb__panel--preview .wpbc_bfb__field[data-type=\"${Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( key )}\"]:not(.is-invalid)`\r\n\t\t\t) || [] ).length;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Alias for limit lookup (readability).\r\n\t\t *\r\n\t\t * @param {string} key - Usage key of a palette item.\r\n\t\t * @returns {number} Limit value or Infinity.\r\n\t\t */\r\n\t\tlimit_for_key( key ) {\r\n\t\t\treturn this.get_limit_for_key( key );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Remaining slots for this key (Infinity if unlimited).\r\n\t\t *\r\n\t\t * @param {string} key - Usage key of a palette item.\r\n\t\t * @returns {number} Remaining count (>= 0) or Infinity.\r\n\t\t */\r\n\t\tremaining_for_key( key ) {\r\n\t\t\tconst limit = this.limit_for_key( key );\r\n\t\t\tif ( limit === Infinity ) {\r\n\t\t\t\treturn Infinity;\r\n\t\t\t}\r\n\t\t\tconst used = this.count_for_key( key );\r\n\t\t\treturn Math.max( 0, limit - used );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * True if you can add `delta` more items for this key.\r\n\t\t *\r\n\t\t * @param {string} key - Usage key of a palette item.\r\n\t\t * @param {number} [delta=1] - How many items you intend to add.\r\n\t\t * @returns {boolean} Whether adding is allowed.\r\n\t\t */\r\n\t\tcan_add( key, delta = 1 ) {\r\n\t\t\tconst rem = this.remaining_for_key( key );\r\n\t\t\treturn ( rem === Infinity ) ? true : ( rem >= delta );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * UI-facing gate: alert when exceeded. Returns boolean allowed/blocked.\r\n\t\t *\r\n\t\t * @param {string} key - Usage key of a palette item.\r\n\t\t * @param {{label?: string, delta?: number}} [opts={}] - Optional UI info.\r\n\t\t * @returns {boolean} True if allowed, false if blocked.\r\n\t\t */\r\n\t\tgate_or_alert( key, { label = key, delta = 1 } = {} ) {\r\n\t\t\tif ( this.can_add( key, delta ) ) {\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\t\t\tconst limit = this.limit_for_key( key );\r\n\t\t\talert( `Only ${limit} instance${limit > 1 ? 's' : ''} of \"${label}\" allowed.` );\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Backward-compatible alias used elsewhere in the codebase.  - Check whether another instance with the given\r\n\t\t * usage key can be added.\r\n\t\t *\r\n\t\t * @param {string} key - Usage key of a palette item.\r\n\t\t * @returns {boolean} Whether adding one more is allowed.\r\n\t\t */\r\n\t\tis_usage_ok( key ) {\r\n\t\t\treturn this.can_add( key, 1 );\r\n\t\t}\r\n\r\n\t};\r\n\r\n\t/**\r\n\t * Constant event names for the builder.\r\n\t */\r\n\tCore.WPBC_BFB_Events = Object.freeze({\r\n\t\tSELECT            : 'wpbc:bfb:select',\r\n\t\tCLEAR_SELECTION   : 'wpbc:bfb:clear-selection',\r\n\t\tFIELD_ADD         : 'wpbc:bfb:field:add',\r\n\t\tFIELD_REMOVE      : 'wpbc:bfb:field:remove',\r\n\t\tSTRUCTURE_CHANGE  : 'wpbc:bfb:structure:change',\r\n\t\tSTRUCTURE_LOADED  : 'wpbc:bfb:structure:loaded'\r\n\t});\r\n\r\n\t/**\r\n\t * Lightweight event bus that emits to both the pages container and document.\r\n\t */\r\n\tCore.WPBC_BFB_EventBus =  class {\r\n\t\t/**\r\n\t\t * @param {HTMLElement} scope_el - Element to dispatch bubbled events from.\r\n\t\t */\r\n\t\tconstructor( scope_el ) {\r\n\t\t\tthis.scope_el = scope_el;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Emit a DOM CustomEvent with payload.\r\n\t\t *\r\n\t\t * @param {string} type - Event type (use Core.WPBC_BFB_Events. when possible).\r\n\t\t * @param {Object} [detail={}] - Arbitrary serializable payload.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\temit( type, detail = {} ) {\r\n\t\t\tif ( ! this.scope_el ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tthis.scope_el.dispatchEvent( new CustomEvent( type, { detail: { ...detail }, bubbles: true } ) );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Subscribe to an event on document.\r\n\t\t *\r\n\t\t * @param {string} type - Event type.\r\n\t\t * @param {(ev:CustomEvent)=>void} handler - Handler function.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\ton( type, handler ) {\r\n\t\t\tdocument.addEventListener( type, handler );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Unsubscribe from an event on document.\r\n\t\t *\r\n\t\t * @param {string} type - Event type.\r\n\t\t * @param {(ev:CustomEvent)=>void} handler - Handler function.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\toff( type, handler ) {\r\n\t\t\tdocument.removeEventListener( type, handler );\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * SortableJS manager: single point for consistent DnD config.\r\n\t */\r\n\tCore.WPBC_BFB_SortableManager = class  {\r\n\r\n\t\t/**\r\n\t\t * @param {WPBC_Form_Builder} builder - The active builder instance.\r\n\t\t * @param {{ groupName?: string, animation?: number, ghostClass?: string, chosenClass?: string, dragClass?:\n\t\t *     string, candidate_dwell_ms?: number, candidate_commit_distance?: number,\n\t\t *     candidate_dwell_distance?: number }} [opts={}] - Visual and drag-stability options.\n\t\t */\r\n\t\tconstructor( builder, opts = {} ) {\r\n\t\t\tthis.builder = builder;\r\n\t\t\tconst gid = this.builder?.instance_id || Math.random().toString( 36 ).slice( 2, 8 );\r\n\t\t\tthis.opts = {\r\n\t\t\t\t// groupName  : 'form',\r\n\t\t\t\tgroupName: `form-${gid}`,\r\n\t\t\t\tanimation  : 150,\r\n\t\t\t\tghostClass : 'wpbc_bfb__drag-ghost',\n\t\t\t\tchosenClass: 'wpbc_bfb__highlight',\n\t\t\t\tdragClass  : 'wpbc_bfb__drag-active',\n\t\t\t\tcandidate_dwell_ms        : 90,\n\t\t\t\tcandidate_commit_distance : 10,\n\t\t\t\tcandidate_dwell_distance  : 2,\n\t\t\t\t...opts\n\t\t\t};\n\t\t\t/** @type {Set<HTMLElement>} */\r\n\t\t\tthis._containers = new Set();\r\n\r\n\t\t\t/**\r\n\t\t\t * Guard against lost mouseup / pointerup events.\r\n\t\t\t *\r\n\t\t\t * @type {boolean}\r\n\t\t\t */\r\n\t\t\tthis._drag_fail_safe_bound = false;\n\n\t\t\t/**\n\t\t\t * State for the current Form Builder canvas drag.\n\t\t\t *\n\t\t\t * @type {?Object}\n\t\t\t */\n\t\t\tthis._drag_state = null;\n\r\n\t\t\tthis._bind_drag_fail_safe();\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Cleanup drag UI state.\r\n\t\t *\r\n\t\t * This is a defensive cleanup for cases when Chrome or a browser extension\r\n\t\t * loses the final mouseup / pointerup event during fallback dragging.\r\n\t\t *\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\t_cleanup_drag_ui() {\n\t\t\tconst drag_state = this._drag_state;\n\n\t\t\tif ( drag_state?.item ) {\n\t\t\t\tdrag_state.item.classList.remove( 'wpbc_bfb__drop-indicator' );\n\t\t\t}\n\t\t\tif ( drag_state?.source_spacer?.parentNode ) {\n\t\t\t\tdrag_state.source_spacer.parentNode.removeChild( drag_state.source_spacer );\n\t\t\t}\n\t\t\tthis._release_canvas_geometry_locks( drag_state );\n\n\t\t\tthis._drag_state = null;\n\t\t\tthis._toggle_dnd_root_flags( false );\n\t\t\tthis.builder?._remove_dragging_class?.();\n\r\n\t\t\t// Remove only fallback mirrors. Do not touch real dragged elements.\r\n\t\t\tdocument.querySelectorAll( '.sortable-fallback[data-drag-role], .wpbc_bfb__simple_list_fallback' )\r\n\t\t\t\t\t.forEach( (el) => {\r\n\t\t\t\t\t\tif ( el.parentNode ) {\r\n\t\t\t\t\t\t\tel.parentNode.removeChild( el );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} );\n\t\t}\n\n\t\t/**\n\t\t * Capture the block size of every canvas layout container before drag reflow starts.\n\t\t *\n\t\t * SortableJS temporarily moves the real node between containers. That changes CSS\n\t\t * `:empty` matching and can otherwise shrink an empty destination row or grow a\n\t\t * populated destination by the insertion-line height. The captured values are\n\t\t * applied only for the active drag session and never become saved form data.\n\t\t *\n\t\t * @returns {Array<Object>} Restorable geometry-lock records for visible canvas containers.\n\t\t */\n\t\t_capture_canvas_geometry_locks() {\n\t\t\tconst pages_container = this.builder?.pages_container;\n\t\t\tif ( ! pages_container?.querySelectorAll ) {\n\t\t\t\treturn [];\n\t\t\t}\n\n\t\t\tconst lock_selector = [\n\t\t\t\t'.wpbc_bfb__form_preview_section_container',\n\t\t\t\t'.wpbc_bfb__row',\n\t\t\t\t'.wpbc_bfb__column'\n\t\t\t].join( ', ' );\n\t\t\tconst block_size_property = '--wpbc-bfb-drag-locked-block-size';\n\n\t\t\treturn Array.from( pages_container.querySelectorAll( lock_selector ) )\n\t\t\t\t.map( ( element ) => {\n\t\t\t\t\tconst block_size = element.getBoundingClientRect?.().height;\n\t\t\t\t\tif ( ! Number.isFinite( block_size ) || block_size <= 0 ) {\n\t\t\t\t\t\treturn null;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\telement                     : element,\n\t\t\t\t\t\tblock_size                  : Math.round( block_size * 1000 ) / 1000,\n\t\t\t\t\t\thad_lock_class              : element.classList?.contains( 'wpbc_bfb__drag-geometry-lock' ),\n\t\t\t\t\t\tprevious_block_size         : element.style?.getPropertyValue?.( block_size_property ) || '',\n\t\t\t\t\t\tprevious_block_size_priority: element.style?.getPropertyPriority?.( block_size_property ) || ''\n\t\t\t\t\t};\n\t\t\t\t} )\n\t\t\t\t.filter( Boolean );\n\t\t}\n\n\t\t/**\n\t\t * Freeze captured canvas container heights for the active SortableJS session.\n\t\t *\n\t\t * The lock is applied before global drag classes or the compact insertion marker\n\t\t * can change flex alignment and empty-container selectors.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_apply_canvas_geometry_locks() {\n\t\t\tconst geometry_locks = this._drag_state?.geometry_locks || [];\n\n\t\t\tgeometry_locks.forEach( ( geometry_lock ) => {\n\t\t\t\tgeometry_lock.element.style?.setProperty(\n\t\t\t\t\t'--wpbc-bfb-drag-locked-block-size',\n\t\t\t\t\t`${geometry_lock.block_size}px`\n\t\t\t\t);\n\t\t\t\tgeometry_lock.element.classList?.add( 'wpbc_bfb__drag-geometry-lock' );\n\t\t\t} );\n\t\t}\n\n\t\t/**\n\t\t * Restore all inline state used by the drag-session geometry lock.\n\t\t *\n\t\t * @param {?Object} drag_state - Drag state whose geometry records must be restored.\n\t\t * @returns {void}\n\t\t */\n\t\t_release_canvas_geometry_locks( drag_state ) {\n\t\t\tconst block_size_property = '--wpbc-bfb-drag-locked-block-size';\n\t\t\tconst geometry_locks      = drag_state?.geometry_locks || [];\n\n\t\t\tgeometry_locks.forEach( ( geometry_lock ) => {\n\t\t\t\tif ( geometry_lock.previous_block_size ) {\n\t\t\t\t\tgeometry_lock.element.style?.setProperty(\n\t\t\t\t\t\tblock_size_property,\n\t\t\t\t\t\tgeometry_lock.previous_block_size,\n\t\t\t\t\t\tgeometry_lock.previous_block_size_priority\n\t\t\t\t\t);\n\t\t\t\t} else {\n\t\t\t\t\tgeometry_lock.element.style?.removeProperty?.( block_size_property );\n\t\t\t\t}\n\n\t\t\t\tif ( ! geometry_lock.had_lock_class ) {\n\t\t\t\t\tgeometry_lock.element.classList?.remove( 'wpbc_bfb__drag-geometry-lock' );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t/**\n\t\t * Capture the original canvas geometry before SortableJS applies its ghost class.\n\t\t *\n\t\t * The saved rectangle is later represented by a non-data spacer. This keeps the\n\t\t * source layout stable while the real dragged node becomes a compact insertion\n\t\t * indicator in another container.\n\t\t *\n\t\t * @param {Sortable.SortableEvent} evt - Sortable choose event.\n\t\t * @returns {void}\n\t\t */\n\t\t_prepare_drag_state( evt ) {\n\t\t\tif ( ! evt?.item || ! evt?.from ) {\n\t\t\t\tthis._drag_state = null;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst source_rect  = evt.item.getBoundingClientRect();\n\t\t\tconst from_palette = !! this.builder?.palette_uls?.includes?.( evt.from );\n\n\t\t\tthis._drag_state = {\n\t\t\t\titem                : evt.item,\n\t\t\t\tfrom_palette        : from_palette,\n\t\t\t\tsource_parent       : evt.from,\n\t\t\t\tsource_next_sibling : evt.item.nextSibling,\n\t\t\t\tsource_rect         : {\n\t\t\t\t\twidth : source_rect.width,\n\t\t\t\t\theight: source_rect.height\n\t\t\t\t},\n\t\t\t\tgeometry_locks      : this._capture_canvas_geometry_locks(),\n\t\t\t\tsource_spacer       : null,\n\t\t\t\taccepted_candidate  : null,\n\t\t\t\tpending_candidate   : null,\n\t\t\t\tpending_since       : 0,\n\t\t\t\tpending_pointer     : null\n\t\t\t};\n\t\t}\n\n\t\t/**\n\t\t * Create a measured, non-data footprint at the dragged item's source position.\n\t\t *\n\t\t * The spacer intentionally does not use field or section classes, so Form Builder\n\t\t * serialization and usage accounting cannot treat it as saved form content.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_create_drag_source_spacer() {\n\t\t\tconst drag_state = this._drag_state;\n\n\t\t\tif (\n\t\t\t\t! drag_state ||\n\t\t\t\tdrag_state.from_palette ||\n\t\t\t\t! drag_state.item ||\n\t\t\t\t! drag_state.source_parent ||\n\t\t\t\tdrag_state.source_spacer\n\t\t\t) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst spacer = document.createElement( 'div' );\n\t\t\tconst width  = Math.max( 1, drag_state.source_rect?.width || 1 );\n\t\t\tconst height = Math.max( 1, drag_state.source_rect?.height || 1 );\n\n\t\t\tspacer.className = 'wpbc_bfb__drag-source-spacer';\n\t\t\tspacer.setAttribute( 'aria-hidden', 'true' );\n\t\t\tspacer.setAttribute( 'data-wpbc-bfb-drag-source-spacer', 'true' );\n\t\t\tspacer.style.setProperty( '--wpbc-bfb-drag-source-inline-size', `${width}px` );\n\t\t\tspacer.style.setProperty( '--wpbc-bfb-drag-source-block-size', `${height}px` );\n\n\t\t\tconst reference_node = drag_state.source_next_sibling?.parentNode === drag_state.source_parent\n\t\t\t\t? drag_state.source_next_sibling\n\t\t\t\t: null;\n\n\t\t\tdrag_state.source_parent.insertBefore( spacer, reference_node );\n\t\t\tdrag_state.source_spacer = spacer;\n\t\t}\n\n\t\t/**\n\t\t * Start the stable drag representation after SortableJS creates its off-flow mirror.\n\t\t *\n\t\t * @param {Sortable.SortableEvent} evt - Sortable start event.\n\t\t * @returns {void}\n\t\t */\n\t\t_start_drag( evt ) {\n\t\t\tif ( ! this._drag_state ) {\n\t\t\t\tthis._prepare_drag_state( evt );\n\t\t\t}\n\n\t\t\tthis._apply_canvas_geometry_locks();\n\t\t\tthis.builder?._add_dragging_class?.();\n\n\t\t\tconst from_palette = !! this._drag_state?.from_palette;\n\t\t\tthis._toggle_dnd_root_flags( true, from_palette );\n\t\t\tthis._tag_drag_mirror( evt );\n\n\t\t\tif ( ! from_palette && evt?.item ) {\n\t\t\t\tthis._create_drag_source_spacer();\n\t\t\t\tevt.item.classList.add( 'wpbc_bfb__drop-indicator' );\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Finish a Form Builder drag and remove transient layout helpers.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_finish_drag() {\n\t\t\tthis._cleanup_drag_ui();\n\t\t}\n\n\t\t/**\n\t\t * Check whether a SortableJS canvas candidate is stable enough to accept.\n\t\t *\n\t\t * The candidate includes the destination container, related sibling, and insertion\n\t\t * side. A new candidate must receive real pointer movement before it can replace\n\t\t * the accepted position, preventing layout movement alone from causing flip-flops.\n\t\t *\n\t\t * @param {Object} evt - Sortable move event.\n\t\t * @param {MouseEvent|PointerEvent|TouchEvent} original_event - Original pointer event.\n\t\t * @returns {boolean} Whether SortableJS may move the in-flow insertion indicator.\n\t\t */\n\t\t_allow_canvas_move( evt, original_event ) {\n\t\t\tconst { to, from } = evt || {};\n\t\t\tif ( ! to || ! from ) {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\tif ( ! to.closest( '.wpbc_bfb__panel--preview' ) ) {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\tconst touch_event  = original_event?.touches?.[0] || original_event?.changedTouches?.[0];\n\t\t\tconst event_x      = touch_event?.clientX ?? original_event?.clientX;\n\t\t\tconst event_y      = touch_event?.clientY ?? original_event?.clientY;\n\t\t\tconst dragged_rect = evt.draggedRect || evt.dragged?.getBoundingClientRect?.();\n\t\t\tconst pointer_x    = Number.isFinite( event_x )\n\t\t\t\t? event_x\n\t\t\t\t: (dragged_rect ? dragged_rect.left + (dragged_rect.width / 2) : 0);\n\t\t\tconst pointer_y    = Number.isFinite( event_y )\n\t\t\t\t? event_y\n\t\t\t\t: (dragged_rect ? dragged_rect.top + (dragged_rect.height / 2) : 0);\n\n\t\t\t// Cross-container column changes require a deliberate move inside the new column.\n\t\t\tif ( to !== from && to.classList?.contains( 'wpbc_bfb__column' ) ) {\n\t\t\t\tconst container_rect = to.getBoundingClientRect();\n\t\t\t\tconst padding_x       = Core.WPBC_BFB_Sanitize.clamp( container_rect.width * 0.20, 12, 36 );\n\t\t\t\tconst padding_y       = Core.WPBC_BFB_Sanitize.clamp( container_rect.height * 0.10, 6, 16 );\n\t\t\t\tconst visually_empty  = ! to.querySelector(\n\t\t\t\t\t':scope > .wpbc_bfb__field:not(.wpbc_bfb__drop-indicator), ' +\n\t\t\t\t\t':scope > .wpbc_bfb__section:not(.wpbc_bfb__drop-indicator)'\n\t\t\t\t) || container_rect.height < 64;\n\t\t\t\tconst inner_top       = container_rect.top + (visually_empty ? 4 : padding_y);\n\t\t\t\tconst inner_bottom    = container_rect.bottom - (visually_empty ? 4 : padding_y);\n\t\t\t\tconst inner_left      = container_rect.left + padding_x;\n\t\t\t\tconst inner_right     = container_rect.right - padding_x;\n\n\t\t\t\tif ( pointer_x <= inner_left || pointer_x >= inner_right || pointer_y <= inner_top || pointer_y >= inner_bottom ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst drag_state = this._drag_state;\n\t\t\tif ( ! drag_state ) {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\tconst candidate = {\n\t\t\t\tto                : to,\n\t\t\t\trelated           : evt.related || null,\n\t\t\t\twill_insert_after : !! evt.willInsertAfter\n\t\t\t};\n\t\t\tconst candidate_matches = ( first, second ) => !! first && !! second &&\n\t\t\t\tfirst.to === second.to &&\n\t\t\t\tfirst.related === second.related &&\n\t\t\t\tfirst.will_insert_after === second.will_insert_after;\n\n\t\t\tif ( candidate_matches( candidate, drag_state.accepted_candidate ) ) {\n\t\t\t\tevt.dragged?.classList.add( 'wpbc_bfb__drop-indicator' );\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\tconst now = window.performance?.now?.() ?? Date.now();\n\t\t\tif ( ! candidate_matches( candidate, drag_state.pending_candidate ) ) {\n\t\t\t\tdrag_state.pending_candidate = candidate;\n\t\t\t\tdrag_state.pending_since     = now;\n\t\t\t\tdrag_state.pending_pointer   = { x: pointer_x, y: pointer_y };\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\tconst pointer_distance = Math.hypot(\n\t\t\t\tpointer_x - drag_state.pending_pointer.x,\n\t\t\t\tpointer_y - drag_state.pending_pointer.y\n\t\t\t);\n\t\t\tconst candidate_age            = now - drag_state.pending_since;\n\t\t\tconst crossed_commit_distance = pointer_distance >= this.opts.candidate_commit_distance;\n\t\t\tconst completed_dwell_move    = candidate_age >= this.opts.candidate_dwell_ms &&\n\t\t\t\tpointer_distance >= this.opts.candidate_dwell_distance;\n\n\t\t\tif ( ! crossed_commit_distance && ! completed_dwell_move ) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\tdrag_state.accepted_candidate = candidate;\n\t\t\tdrag_state.pending_candidate  = null;\n\t\t\tdrag_state.pending_since      = 0;\n\t\t\tdrag_state.pending_pointer    = null;\n\t\t\tevt.dragged?.classList.add( 'wpbc_bfb__drop-indicator' );\n\n\t\t\treturn true;\n\t\t}\n\r\n\t\t/**\r\n\t\t * Bind global fail-safe listeners for drag cleanup.\r\n\t\t *\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\t_bind_drag_fail_safe() {\r\n\t\t\tif ( this._drag_fail_safe_bound ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tthis._drag_fail_safe_bound = true;\r\n\r\n\t\t\tconst finish_drag = () => {\r\n\t\t\t\twindow.requestAnimationFrame( () => {\r\n\t\t\t\t\tthis._cleanup_drag_ui();\r\n\t\t\t\t} );\r\n\t\t\t};\r\n\r\n\t\t\t[ 'mouseup', 'pointerup', 'touchend', 'dragend' ].forEach( (evt_name) => {\r\n\t\t\t\tdocument.addEventListener( evt_name, finish_drag, true );\r\n\t\t\t} );\r\n\r\n\t\t\twindow.addEventListener( 'blur', finish_drag, true );\r\n\r\n\t\t\tdocument.addEventListener(\r\n\t\t\t\t'visibilitychange',\r\n\t\t\t\t() => {\r\n\t\t\t\t\tif ( document.hidden ) {\r\n\t\t\t\t\t\tfinish_drag();\r\n\t\t\t\t\t}\r\n\t\t\t\t},\r\n\t\t\t\ttrue\r\n\t\t\t);\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Tag the drag mirror (element under cursor) with role: 'palette' | 'canvas'.\r\n\t\t * Works with Sortable's fallback mirror (.sortable-fallback / .sortable-drag) and with your dragClass\r\n\t\t * (.wpbc_bfb__drag-active).\r\n\t\t */\r\n\t\t_tag_drag_mirror( evt ) {\r\n\t\t\tconst fromPalette = this.builder?.palette_uls?.includes?.( evt.from );\r\n\t\t\tconst role        = fromPalette ? 'palette' : 'canvas';\r\n\t\t\t// Wait a tick so the mirror exists.  - The window.requestAnimationFrame() method tells the browser you wish to perform an animation.\r\n\t\t\trequestAnimationFrame( () => {\r\n\t\t\t\tconst mirror = document.querySelector( '.sortable-fallback, .sortable-drag, .' + this.opts.dragClass );\n\t\t\t\tif ( mirror ) {\n\t\t\t\t\tmirror.setAttribute( 'data-drag-role', role );\n\t\t\t\t\tmirror.setAttribute( 'aria-hidden', 'true' );\n\t\t\t\t}\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t_toggle_dnd_root_flags( active, from_palette = false ) {\r\n\r\n\t\t\t// set to root element of an HTML document, which is the <html>.\r\n\t\t\tconst root = document.documentElement;\r\n\t\t\tif ( active ) {\r\n\t\t\t\troot.classList.add( 'wpbc_bfb__dnd-active' );\r\n\t\t\t\tif ( from_palette ) {\r\n\t\t\t\t\troot.classList.add( 'wpbc_bfb__drag-from-palette' );\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\troot.classList.remove( 'wpbc_bfb__dnd-active', 'wpbc_bfb__drag-from-palette' );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Ensure a simple vertical sortable list.\r\n\t\t *\r\n\t\t * This configuration is intended for inspector/sidebar lists such as:\r\n\t\t * - dropdown choices\r\n\t\t * - radio options\r\n\t\t * - checkbox options\r\n\t\t *\r\n\t\t * It is intentionally much simpler than the canvas DnD config and does not\r\n\t\t * use the column edge-fence / sticky-target logic.\r\n\t\t *\r\n\t\t * @param {HTMLElement} container - Sortable list container.\r\n\t\t * @param {{ handle_selector?: string, draggable_selector?: string, onUpdate?: Function }} [handlers={}] -\r\n\t\t *     Optional handlers/selectors.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tensure_simple_list( container, handlers = {} ) {\r\n\t\t\tif ( ! container || typeof Sortable === 'undefined' ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tif ( Sortable.get?.( container ) ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst common = {\r\n\t\t\t\tanimation        : this.opts.animation,\r\n\t\t\t\tghostClass       : this.opts.ghostClass,\r\n\t\t\t\tchosenClass      : this.opts.chosenClass,\r\n\t\t\t\tdragClass        : this.opts.dragClass,\r\n\t\t\t\tforceFallback    : true,\r\n\t\t\t\t// For a single scrollable sidebar list this is usually more stable.\r\n\t\t\t\tfallbackOnBody   : false,\r\n\t\t\t\tfallbackTolerance: 8,\r\n\t\t\t\tremoveCloneOnHide: true,\r\n\t\t\t\tonStart          : () => {\r\n\t\t\t\t\tthis.builder?._add_dragging_class?.();\r\n\t\t\t\t\tthis._toggle_dnd_root_flags( true, false );\r\n\t\t\t\t},\r\n\t\t\t\tonEnd            : () => {\r\n\t\t\t\t\tsetTimeout( () => {\r\n\t\t\t\t\t\tthis.builder?._remove_dragging_class?.();\r\n\t\t\t\t\t}, 50 );\r\n\t\t\t\t\tthis._toggle_dnd_root_flags( false );\r\n\t\t\t\t\tthis._cleanup_drag_ui();\n\t\t\t\t}\r\n\t\t\t};\r\n\r\n\t\t\tSortable.create(\r\n\t\t\t\tcontainer,\r\n\t\t\t\t{\r\n\t\t\t\t\t...common,\r\n\t\t\t\t\tgroup                  : { name: this.opts.groupName, pull: false, put: false },\r\n\t\t\t\t\tsort                   : true,\r\n\t\t\t\t\tdirection              : 'vertical',\r\n\t\t\t\t\thandle                 : handlers.handle_selector || '.wpbc_bfb__drag-handle',\r\n\t\t\t\t\tdraggable              : handlers.draggable_selector || '.wpbc_bfb__sortable-row',\r\n\t\t\t\t\tfallbackClass          : 'wpbc_bfb__simple_list_fallback',\r\n\t\t\t\t\tfilter                 : [\r\n\t\t\t\t\t\t'input',\r\n\t\t\t\t\t\t'textarea',\r\n\t\t\t\t\t\t'select',\r\n\t\t\t\t\t\t'button',\r\n\t\t\t\t\t\t'a',\r\n\t\t\t\t\t\t'.wpbc_bfb__no-drag-zone',\r\n\t\t\t\t\t\t'.wpbc_bfb__no-drag-zone *'\r\n\t\t\t\t\t].join( ',' ),\r\n\t\t\t\t\tpreventOnFilter        : false,\r\n\t\t\t\t\tinvertSwap             : false,\r\n\t\t\t\t\tswapThreshold          : 0.30,\r\n\t\t\t\t\tinvertedSwapThreshold  : 0.60,\r\n\t\t\t\t\temptyInsertThreshold   : 8,\r\n\t\t\t\t\tdragoverBubble         : false,\r\n\t\t\t\t\tscroll                 : true,\r\n\t\t\t\t\tscrollSensitivity      : 60,\r\n\t\t\t\t\tscrollSpeed            : 14,\r\n\t\t\t\t\tonUpdate               : handlers.onUpdate || function () {}\r\n\t\t\t\t}\r\n\t\t\t);\r\n\r\n\t\t\tthis._containers.add( container );\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Ensure Sortable is attached to a container with role 'palette' or 'canvas'.\r\n\t\t *\r\n\t\t *  -- Handle selectors: handle:  '.section-drag-handle, .wpbc_bfb__drag-handle, .wpbc_bfb__drag-anywhere,\r\n\t\t * [data-draggable=\"true\"]'\r\n\t\t *  -- Draggable gate: draggable fields, sections, and the transient measured source spacer.\n\t\t *  -- Filter (overlay-safe):     ignore everything in overlay except the handle -\r\n\t\t * '.wpbc_bfb__overlay-controls\r\n\t\t * *:not(.wpbc_bfb__drag-handle):not(.section-drag-handle):not(.wpbc_icn_drag_indicator)'\r\n\t\t *  -- No-drag wrapper:           use .wpbc_bfb__no-drag-zone inside renderers for inputs/widgets.\r\n\t\t *  -- Focus guard (optional):    flip [data-draggable] on focusin/focusout to prevent accidental drags while\r\n\t\t * typing.\r\n\t\t *\r\n\t\t * @param {HTMLElement} container - The element to enhance with Sortable.\r\n\t\t * @param {'palette'|'canvas'} role - Behavior profile to apply.\r\n\t\t * @param {{ onAdd?: Function }} [handlers={}] - Optional handlers.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tensure( container, role, handlers = {} ) {\r\n\t\t\tif ( ! container || typeof Sortable === 'undefined' ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tif ( Sortable.get?.( container ) ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst sortable_kind = handlers.sortable_kind || '';\r\n\r\n\t\t\tif ( sortable_kind === 'simple_list' ) {\r\n\t\t\t\tthis.ensure_simple_list( container, handlers );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst common = {\r\n\t\t\t\tanimation  : this.opts.animation,\r\n\t\t\t\tghostClass : this.opts.ghostClass,\r\n\t\t\t\tchosenClass: this.opts.chosenClass,\r\n\t\t\t\tdragClass  : this.opts.dragClass,\r\n\t\t\t\t// == Element under the cursor  == Ensure we drag a real DOM mirror you can style via CSS (cross-browser).\r\n\t\t\t\tforceFallback    : true,\r\n\t\t\t\tfallbackOnBody   : true,\r\n\t\t\t\tfallbackTolerance: 8,\r\n\t\t\t\tremoveCloneOnHide: true,\n\t\t\t\tonChoose: (evt) => this._prepare_drag_state( evt ),\n\t\t\t\tonStart : (evt) => this._start_drag( evt ),\n\t\t\t\tonEnd   : () => this._finish_drag(),\n\t\t\t\tonMove  : (evt, original_event) => this._allow_canvas_move( evt, original_event )\n\t\t\t};\r\n\r\n\t\t\tif ( role === 'palette' ) {\r\n\t\t\t\tSortable.create( container, {\r\n\t\t\t\t\t...common,\r\n\t\t\t\t\tgroup   : { name: this.opts.groupName, pull: 'clone', put: false },\r\n\t\t\t\t\tsort    : false\r\n\t\t\t\t} );\r\n\t\t\t\tthis._containers.add( container );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\t// role === 'canvas'.\r\n\t\t\tSortable.create( container, {\n\t\t\t\t...common,\n\t\t\t\t// Stable insertion geometry is preferable to animating hit-test targets.\n\t\t\t\tanimation: 0,\n\t\t\t\tgroup    : {\n\t\t\t\t\tname: this.opts.groupName,\r\n\t\t\t\t\tpull: true,\r\n\t\t\t\t\tput : (to, from, draggedEl) => {\r\n\t\t\t\t\t\treturn draggedEl.classList.contains( 'wpbc_bfb__field' ) ||\r\n\t\t\t\t\t\t\t   draggedEl.classList.contains( 'wpbc_bfb__section' );\r\n\t\t\t\t\t}\r\n\t\t\t\t},\r\n\t\t\t\t// ---------- DnD Handlers --------------                // Grab anywhere on fields that opt-in with the class or attribute.  - Sections still require their dedicated handle.\r\n\t\t\t\thandle   : '.section-drag-handle, .wpbc_bfb__drag-handle, .wpbc_bfb__drag-anywhere, [data-draggable=\"true\"]',\r\n\t\t\t\t// The transient spacer participates in hit testing but never serialization.\n\t\t\t\tdraggable: [\n\t\t\t\t\t'.wpbc_bfb__field:not([data-draggable=\"false\"])',\n\t\t\t\t\t'.wpbc_bfb__section',\n\t\t\t\t\t'.wpbc_bfb__drag-source-spacer'\n\t\t\t\t].join( ', ' ),\n\t\t\t\t// ---------- Filters - No DnD ----------                // Declarative “no-drag zones”: anything inside these wrappers won’t start a drag.\r\n\t\t\t\tfilter: [\r\n\t\t\t\t\t'.wpbc_bfb__no-drag-zone',\r\n\t\t\t\t\t'.wpbc_bfb__no-drag-zone *',\r\n\t\t\t\t\t'.wpbc_bfb__column-resizer',  // Ignore the resizer rails during DnD (prevents edge “snap”).\r\n\t\t\t\t\t                              // In the overlay toolbar, block everything EXCEPT the drag handle (and its icon).\r\n\t\t\t\t\t'.wpbc_bfb__overlay-controls *:not(.wpbc_bfb__drag-handle):not(.section-drag-handle):not(.wpbc_icn_drag_indicator)'\r\n\t\t\t\t].join( ',' ),\r\n\t\t\t\tpreventOnFilter  : false,\r\n\t\t\t\t\t// ---------- anti-jitter tuning ----------\r\n\t\t\t\tdirection            : 'vertical',           // columns are vertical lists.\r\n\t\t\t\tinvertSwap           : true,                 // use swap on inverted overlap.\r\n\t\t\t\tswapThreshold        : 0.65,                 // be less eager to swap.\r\n\t\t\t\tinvertedSwapThreshold: 0.85,                 // require deeper overlap when inverted.\r\n\t\t\t\temptyInsertThreshold : 24,                   // don’t jump into empty containers too early.\r\n\t\t\t\tdragoverBubble       : false,                // keep dragover local.\r\n\t\t\t\tscroll               : true,\r\n\t\t\t\tscrollSensitivity    : 40,\r\n\t\t\t\tscrollSpeed          : 10,\n\t\t\t\t// ----------------------------------------\r\n\t\t\t\t// onAdd: handlers.onAdd || this.builder.handle_on_add.bind( this.builder )\r\n\t\t\t\tonAdd: (evt) => {\r\n\t\t\t\t\tif ( this._on_add_section( evt ) ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// Fallback: original handler for normal fields.\r\n\t\t\t\t\t(handlers.onAdd || this.builder.handle_on_add.bind( this.builder ))( evt );\r\n\t\t\t\t},\r\n\t\t\t\tonUpdate: () => {\r\n\t\t\t\t\tthis.builder.bus?.emit?.( Core.WPBC_BFB_Events.STRUCTURE_CHANGE, { reason: 'sort-update' } );\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\r\n\t\t\tthis._containers.add( container );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Handle adding/moving sections via Sortable onAdd.\r\n\t\t * Returns true if handled (i.e., it was a section), false to let the default field handler run.\r\n\t\t *\r\n\t\t * - Palette -> canvas: remove the placeholder clone and build a fresh section via add_section()\r\n\t\t * - Canvas -> canvas: keep the moved DOM (and its children), just re-wire overlays/sortables/metadata\r\n\t\t *\r\n\t\t * @param {Sortable.SortableEvent} evt\r\n\t\t * @returns {boolean}\r\n\t\t */\r\n\t\t_on_add_section(evt) {\r\n\r\n\t\t\tconst item = evt.item;\r\n\t\t\tif ( ! item ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\t// Identify sections both from palette items (li clones) and real canvas nodes.\r\n\t\t\tconst data      = Core.WPBC_Form_Builder_Helper.get_all_data_attributes( item );\r\n\t\t\tconst isSection = item.classList.contains( 'wpbc_bfb__section' ) || (data?.type || item.dataset?.type) === 'section';\r\n\r\n\t\t\tif ( ! isSection ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\tconst fromPalette = this.builder?.palette_uls?.includes?.( evt.from ) === true;\r\n\r\n\t\t\tif ( ! fromPalette ) {\r\n\t\t\t\t// Canvas -> canvas move: DO NOT rebuild/remove; preserve children.\r\n\t\t\t\tthis.builder.add_overlay_toolbar?.( item );                       // ensure overlay exists\r\n\t\t\t\tthis.builder.pages_sections?.init_all_nested_sortables?.( item ); // ensure inner sortables\r\n\r\n\t\t\t\t// Ensure metadata present/updated\r\n\t\t\t\titem.dataset.type    = 'section';\r\n\t\t\t\tconst cols           = item.querySelectorAll( ':scope > .wpbc_bfb__row > .wpbc_bfb__column' ).length || 1;\r\n\t\t\t\titem.dataset.columns = String( cols );\r\n\r\n\t\t\t\t// Select & notify subscribers (layout/min guards, etc.)\r\n\t\t\t\tthis.builder.select_field?.( item );\r\n\t\t\t\tthis.builder.bus?.emit?.( Core.WPBC_BFB_Events.STRUCTURE_CHANGE, { el: item, reason: 'section-move' } );\r\n\t\t\t\tthis.builder.usage?.update_palette_ui?.();\r\n\t\t\t\treturn true; // handled.\r\n\t\t\t}\r\n\r\n\t\t\t// Palette -> canvas: build a brand-new section using the same path as the dropdown/menu\r\n\t\t\tconst to   = evt.to?.closest?.( '.wpbc_bfb__column, .wpbc_bfb__form_preview_section_container' ) || evt.to;\r\n\t\t\tconst cols = parseInt( data?.columns || item.dataset.columns || 1, 10 ) || 1;\r\n\r\n\t\t\t// Remove the palette clone placeholder.\r\n\t\t\titem.parentNode && item.parentNode.removeChild( item );\r\n\r\n\t\t\t// Create the real section.\r\n\t\t\tthis.builder.pages_sections.add_section( to, cols );\r\n\r\n\t\t\t// Insert at the precise drop index.\r\n\t\t\tconst section = to.lastElementChild; // add_section appends to end.\r\n\t\t\tif ( evt.newIndex != null && evt.newIndex < to.children.length - 1 ) {\r\n\t\t\t\tconst ref = to.children[evt.newIndex] || null;\r\n\t\t\t\tto.insertBefore( section, ref );\r\n\t\t\t}\r\n\r\n\t\t\t// Finalize: overlay, selection, events, usage refresh.\r\n\t\t\tthis.builder.add_overlay_toolbar?.( section );\r\n\t\t\tthis.builder.select_field?.( section );\r\n\t\t\tthis.builder.bus?.emit?.( Core.WPBC_BFB_Events.FIELD_ADD, {\r\n\t\t\t\tel : section,\r\n\t\t\t\tid : section.dataset.id,\r\n\t\t\t\tuid: section.dataset.uid\r\n\t\t\t} );\r\n\t\t\tthis.builder.usage?.update_palette_ui?.();\r\n\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Destroy all Sortable instances created by this manager.\r\n\t\t *\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tdestroyAll() {\r\n\t\t\tthis._containers.forEach( ( el ) => {\r\n\t\t\t\tconst inst = Sortable.get?.( el );\r\n\t\t\t\tif ( inst ) {\r\n\t\t\t\t\tinst.destroy();\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\t\t\tthis._containers.clear();\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Small DOM contract and renderer helper\r\n\t *\r\n\t * @type {Readonly<{\r\n\t *                  SELECTORS: {pagePanel: string, field: string, validField: string, section: string, column:\r\n\t *     string, row: string, overlay: string}, CLASSES: {selected: string}, ATTR: {id: string, name: string, htmlId:\r\n\t *     string, usageKey: string, uid: string}}\r\n\t *        >}\r\n\t */\r\n\tCore.WPBC_BFB_DOM = Object.freeze( {\r\n\t\tSELECTORS: {\r\n\t\t\tpagePanel : '.wpbc_bfb__panel--preview',\r\n\t\t\tfield     : '.wpbc_bfb__field',\r\n\t\t\tvalidField: '.wpbc_bfb__field:not(.is-invalid)',\r\n\t\t\tsection   : '.wpbc_bfb__section',\r\n\t\t\tcolumn    : '.wpbc_bfb__column',\r\n\t\t\trow       : '.wpbc_bfb__row',\r\n\t\t\toverlay   : '.wpbc_bfb__overlay-controls'\r\n\t\t},\r\n\t\tCLASSES  : {\r\n\t\t\tselected: 'is-selected'\r\n\t\t},\r\n\t\tATTR     : {\r\n\t\t\tid      : 'data-id',\r\n\t\t\tname    : 'data-name',\r\n\t\t\thtmlId  : 'data-html_id',\r\n\t\t\tusageKey: 'data-usage_key',\r\n\t\t\tuid     : 'data-uid'\r\n\t\t}\r\n\t} );\r\n\r\n\tCore.WPBC_Form_Builder_Helper = class {\r\n\r\n\t\t/**\r\n\t\t * Create an HTML element.\r\n\t\t *\r\n\t\t * @param {string} tag - HTML tag name.\r\n\t\t * @param {string} [class_name=''] - Optional CSS class name.\r\n\t\t * @param {string} [inner_html=''] - Optional innerHTML.\r\n\t\t * @returns {HTMLElement} Created element.\r\n\t\t */\r\n\t\tstatic create_element( tag, class_name = '', inner_html = '' ) {\r\n\t\t\tconst el = document.createElement( tag );\r\n\t\t\tif ( class_name ) {\r\n\t\t\t\tel.className = class_name;\r\n\t\t\t}\r\n\t\t\tif ( inner_html ) {\r\n\t\t\t\tel.innerHTML = inner_html;\r\n\t\t\t}\r\n\t\t\treturn el;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Set multiple `data-*` attributes on a given element.\r\n\t\t *\r\n\t\t * @param {HTMLElement} el - Target element.\r\n\t\t * @param {Object} data_obj - Key-value pairs for data attributes.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tstatic set_data_attributes( el, data_obj ) {\r\n\t\t\tObject.entries( data_obj ).forEach( ( [ key, val ] ) => {\r\n\t\t\t\t// Previously: 2025-09-01 17:09:\r\n\t\t\t\t// const value = (typeof val === 'object') ? JSON.stringify( val ) : val;\r\n\t\t\t\t//New:\r\n\t\t\t\tlet value;\r\n\t\t\t\tif ( typeof val === 'object' && val !== null ) {\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tvalue = JSON.stringify( val );\r\n\t\t\t\t\t} catch {\r\n\t\t\t\t\t\tvalue = '';\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tvalue = val;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tel.setAttribute( 'data-' + key, value );\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Get all `data-*` attributes from an element and parse JSON where possible.\r\n\t\t *\r\n\t\t * @param {HTMLElement} el - Element to extract data from.\r\n\t\t * @returns {Object} Parsed key-value map of data attributes.\r\n\t\t */\r\n\t\tstatic get_all_data_attributes( el ) {\r\n\t\t\tconst data = {};\r\n\r\n\t\t\tif ( ! el || ! el.attributes ) {\r\n\t\t\t\treturn data;\r\n\t\t\t}\r\n\r\n\t\t\tArray.from( el.attributes ).forEach(\r\n\t\t\t\t( attr ) => {\r\n\t\t\t\t\tif ( attr.name.startsWith( 'data-' ) ) {\r\n\t\t\t\t\t\tconst key = attr.name.replace( /^data-/, '' );\r\n\t\t\t\t\t\ttry {\r\n\t\t\t\t\t\t\tdata[key] = JSON.parse( attr.value );\r\n\t\t\t\t\t\t} catch ( e ) {\r\n\t\t\t\t\t\t\tdata[key] = attr.value;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t);\r\n\r\n\t\t\t// Only default the label if it's truly absent (undefined/null), not when it's an empty string.\r\n\t\t\tconst hasExplicitLabel = Object.prototype.hasOwnProperty.call( data, 'label' );\r\n\t\t\tif ( ! hasExplicitLabel && data.id ) {\r\n\t\t\t\tdata.label = data.id.charAt( 0 ).toUpperCase() + data.id.slice( 1 );\r\n\t\t\t}\r\n\r\n\t\t\treturn data;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Render a simple label + type preview (used for unknown or fallback fields).\r\n\t\t *\r\n\t\t * @param {Object} field_data - Field data object.\r\n\t\t * @returns {string} HTML content.\r\n\t\t */\r\n\t\tstatic render_field_inner_html( field_data ) {\r\n\t\t\t// Make the fallback preview respect an empty label.\r\n\t\t\tconst hasLabel = Object.prototype.hasOwnProperty.call( field_data, 'label' );\r\n\t\t\tconst label    = hasLabel ? String( field_data.label ) : String( field_data.id || '(no label)' );\r\n\r\n\t\t\tconst type        = String( field_data.type || 'unknown' );\r\n\t\t\tconst is_required = field_data.required === true || field_data.required === 'true' || field_data.required === 1 || field_data.required === '1';\r\n\r\n\t\t\tconst wrapper = document.createElement( 'div' );\r\n\r\n\t\t\tconst spanLabel       = document.createElement( 'span' );\r\n\t\t\tspanLabel.className   = 'wpbc_bfb__field-label';\r\n\t\t\tspanLabel.textContent = label + (is_required ? ' *' : '');\r\n\t\t\twrapper.appendChild( spanLabel );\r\n\r\n\t\t\tconst spanType       = document.createElement( 'span' );\r\n\t\t\tspanType.className   = 'wpbc_bfb__field-type';\r\n\t\t\tspanType.textContent = type;\r\n\t\t\twrapper.appendChild( spanType );\r\n\r\n\t\t\treturn wrapper.innerHTML;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Debounce a function.\r\n\t\t *\r\n\t\t * @param {Function} fn - Function to debounce.\r\n\t\t * @param {number} wait - Delay in ms.\r\n\t\t * @returns {Function} Debounced function.\r\n\t\t */\r\n\t\tstatic debounce( fn, wait = 120 ) {\r\n\t\t\tlet t = null;\r\n\t\t\treturn function debounced( ...args ) {\r\n\t\t\t\tif ( t ) {\r\n\t\t\t\t\tclearTimeout( t );\r\n\t\t\t\t}\r\n\t\t\t\tt = setTimeout( () => fn.apply( this, args ), wait );\r\n\t\t\t};\r\n\t\t}\r\n\r\n\t};\r\n\r\n\t// Renderer registry. Allows late registration and avoids tight coupling to a global map.\r\n\tCore.WPBC_BFB_Field_Renderer_Registry = (function () {\r\n\t\tconst map = new Map();\r\n\t\treturn {\r\n\t\t\tregister( type, ClassRef ) {\r\n\t\t\t\tmap.set( String( type ), ClassRef );\r\n\t\t\t},\r\n\t\t\tget( type ) {\r\n\t\t\t\treturn map.get( String( type ) );\r\n\t\t\t}\r\n\t\t};\r\n\t})();\r\n\r\n}( window ));\r\n","// ---------------------------------------------------------------------------------------------------------------------\r\n// == File  /includes/page-form-builder/_out/core/bfb-fields.js == | 2025-09-10 15:47\r\n// ---------------------------------------------------------------------------------------------------------------------\r\n(function ( w ) {\r\n\t'use strict';\r\n\r\n\t// Single global namespace (idempotent & load-order safe).\r\n\tconst Core = ( w.WPBC_BFB_Core = w.WPBC_BFB_Core || {} );\r\n\tconst UI   = ( Core.UI = Core.UI || {} );\r\n\r\n\t/**\r\n\t * Base class for field renderers (static-only contract).\r\n\t * ================================================================================================================\r\n\t * Contract exposed to the builder (static methods on the CLASS itself):\r\n\t *   - render(el, data, ctx)              // REQUIRED\r\n\t *   - on_field_drop(data, el, meta)      // OPTIONAL (default provided)\r\n\t *\r\n\t * Helpers for subclasses:\r\n\t *   - get_defaults()     -> per-field defaults (MUST override in subclass to set type/label)\r\n\t *   - normalize_data(d)  -> shallow merge with defaults\r\n\t *   - get_template(id)   -> per-id cached wp.template compiler\r\n\t *\r\n\t * Subclass usage:\r\n\t *   class WPBC_BFB_Field_Text extends Core.WPBC_BFB_Field_Base { static get_defaults(){ ... } }\r\n\t *   WPBC_BFB_Field_Text.template_id = 'wpbc-bfb-field-text';\r\n\t * ================================================================================================================\r\n\t */\r\n\tCore.WPBC_BFB_Field_Base = class {\r\n\r\n\t\t/**\r\n\t\t * Default field data (generic baseline).\r\n\t\t * Subclasses MUST override to provide { type, label } appropriate for the field.\r\n\t\t * @returns {Object}\r\n\t\t */\r\n\t\tstatic get_defaults() {\r\n\t\t\treturn {\r\n\t\t\t\ttype        : 'field',\r\n\t\t\t\tlabel       : 'Field',\r\n\t\t\t\tname        : 'field',\r\n\t\t\t\thtml_id     : '',\r\n\t\t\t\tplaceholder : '',\r\n\t\t\t\trequired    : false,\r\n\t\t\t\tminlength   : '',\r\n\t\t\t\tmaxlength   : '',\r\n\t\t\t\tpattern     : '',\r\n\t\t\t\tcssclass    : '',\r\n\t\t\t\thelp        : ''\r\n\t\t\t};\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Shallow-merge incoming data with defaults.\r\n\t\t * @param {Object} data\r\n\t\t * @returns {Object}\r\n\t\t */\r\n\t\tstatic normalize_data( data ) {\r\n\t\t\tvar d        = data || {};\r\n\t\t\tvar defaults = this.get_defaults();\r\n\t\t\tvar out      = {};\r\n\t\t\tvar k;\r\n\r\n\t\t\tfor ( k in defaults ) {\r\n\t\t\t\tif ( Object.prototype.hasOwnProperty.call( defaults, k ) ) {\r\n\t\t\t\t\tout[k] = defaults[k];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tfor ( k in d ) {\r\n\t\t\t\tif ( Object.prototype.hasOwnProperty.call( d, k ) ) {\r\n\t\t\t\t\tout[k] = d[k];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn out;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Compile and cache a wp.template by id (per-id cache).\r\n\t\t * @param {string} template_id\r\n\t\t * @returns {Function|null}\r\n\t\t */\r\n\t\tstatic get_template(template_id) {\r\n\r\n\t\t\t// Accept either \"wpbc-bfb-field-text\" or \"tmpl-wpbc-bfb-field-text\".\r\n\t\t\tif ( ! template_id || ! window.wp || ! wp.template ) {\r\n\t\t\t\treturn null;\r\n\t\t\t}\r\n\t\t\tconst domId = template_id.startsWith( 'tmpl-' ) ? template_id : ('tmpl-' + template_id);\r\n\t\t\tif ( ! document.getElementById( domId ) ) {\r\n\t\t\t\treturn null;\r\n\t\t\t}\r\n\r\n\t\t\tif ( ! Core.__bfb_tpl_cache_map ) {\r\n\t\t\t\tCore.__bfb_tpl_cache_map = {};\r\n\t\t\t}\r\n\r\n\t\t\t// Normalize id for the compiler & cache. // wp.template expects id WITHOUT the \"tmpl-\" prefix !\r\n\t\t\tconst key = template_id.replace( /^tmpl-/, '' );\r\n\t\t\tif ( Core.__bfb_tpl_cache_map[key] ) {\r\n\t\t\t\treturn Core.__bfb_tpl_cache_map[key];\r\n\t\t\t}\r\n\r\n\t\t\tconst compiler = wp.template( key );     // <-- normalized id here\r\n\t\t\tif ( compiler ) {\r\n\t\t\t\tCore.__bfb_tpl_cache_map[key] = compiler;\r\n\t\t\t}\r\n\r\n\t\t\treturn compiler;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * REQUIRED: render preview into host element (full redraw; idempotent).\r\n\t\t * Subclasses should set static `template_id` to a valid wp.template id.\r\n\t\t * @param {HTMLElement} el\r\n\t\t * @param {Object}      data\r\n\t\t * @param {{mode?:string,builder?:any,tpl?:Function,sanit?:any}} ctx\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tstatic render( el, data, ctx ) {\r\n\t\t\tif ( ! el ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tvar compile = this.get_template( this.template_id );\r\n\t\t\tvar d       = this.normalize_data( data );\r\n\r\n\t\t\tvar s = (ctx && ctx.sanit) ? ctx.sanit : Core.WPBC_BFB_Sanitize;\r\n\r\n\t\t\t// Sanitize critical attributes before templating.\r\n\t\t\tif ( s ) {\r\n\t\t\t\td.html_id = d.html_id ? s.sanitize_html_id( String( d.html_id ) ) : '';\r\n\t\t\t\td.name    = s.sanitize_html_name( String( d.name || d.id || 'field' ) );\r\n\t\t\t} else {\r\n\t\t\t\td.html_id = d.html_id ? String( d.html_id ) : '';\r\n\t\t\t\td.name    = String( d.name || d.id || 'field' );\r\n\t\t\t}\r\n\r\n\t\t\t// Fall back to generic preview if template not available.\r\n\t\t\tif ( compile ) {\r\n\t\t\t\tel.innerHTML = compile( d );\r\n\r\n\t\t\t\t// After render, set attribute values via DOM so quotes/newlines are handled correctly.\r\n\t\t\t\tconst input = el.querySelector( 'input, textarea, select' );\r\n\t\t\t\tif ( input ) {\r\n\t\t\t\t\tif ( d.placeholder != null ) input.setAttribute( 'placeholder', String( d.placeholder ) );\r\n\t\t\t\t\tif ( d.title != null ) input.setAttribute( 'title', String( d.title ) );\r\n\t\t\t\t}\r\n\r\n\t\t\t} else {\r\n\t\t\t\tel.innerHTML = Core.WPBC_Form_Builder_Helper.render_field_inner_html( d );\r\n\t\t\t}\r\n\r\n\t\t\tel.dataset.type = d.type || 'field';\r\n\t\t\tel.setAttribute( 'data-label', (d.label != null ? String( d.label ) : '') ); // allow \"\".\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * OPTIONAL hook executed after field is dropped/loaded/preview.\r\n\t\t * Default extended:\r\n\t\t * - On first drop: stamp default label (existing behavior) and mark field as \"fresh\" for auto-name.\r\n\t\t * - On load: mark as loaded so later label edits do not rename the saved name.\r\n\t\t */\r\n\t\tstatic on_field_drop(data, el, meta) {\r\n\r\n\t\t\tconst context = (meta && meta.context) ? String( meta.context ) : '';\r\n\r\n\t\t\t// -----------------------------------------------------------------------------------------\r\n\t\t\t// NEW: Seed default \"help\" (and keep it in Structure) for all field packs that define it.\r\n\t\t\t// This fixes the mismatch where:\r\n\t\t\t//   - UI shows default help via normalize_data() / templates\r\n\t\t\t//   - but get_structure() / exporters see `help` as undefined/empty.\r\n\t\t\t//\r\n\t\t\t// Behavior:\r\n\t\t\t//   - Runs ONLY on initial drop (context === 'drop').\r\n\t\t\t//   - If get_defaults() exposes a non-empty \"help\", and data.help is\r\n\t\t\t//     missing / null / empty string -> we persist the default into `data`\r\n\t\t\t//     and notify Structure so exports see it.\r\n\t\t\t//   - On \"load\" we do nothing, so existing forms where user *cleared*\r\n\t\t\t//     help will not be overridden.\r\n\t\t\t// -----------------------------------------------------------------------------------------\r\n\t\t\tif ( context === 'drop' && data ) {\r\n\t\t\t\ttry {\r\n\t\t\t\t\tconst defs = (typeof this.get_defaults === 'function') ? this.get_defaults() : null;\r\n\t\t\t\t\tif ( defs && Object.prototype.hasOwnProperty.call( defs, 'help' ) ) {\r\n\t\t\t\t\t\tconst current    = Object.prototype.hasOwnProperty.call( data, 'help' ) ? data.help : undefined;\r\n\t\t\t\t\t\tconst hasValue   = (current !== undefined && current !== null && String( current ) !== '');\r\n\t\t\t\t\t\tconst defaultVal = defs.help;\r\n\r\n\t\t\t\t\t\tif ( ! hasValue && defaultVal != null && String( defaultVal ) !== '' ) {\r\n\t\t\t\t\t\t\t// 1) persist into data object (used by Structure).\r\n\t\t\t\t\t\t\tdata.help = defaultVal;\r\n\r\n\t\t\t\t\t\t\t// 2) mirror into dataset (for any DOM-based consumers).\r\n\t\t\t\t\t\t\tif ( el ) {\r\n\t\t\t\t\t\t\t\tel.dataset.help = String( defaultVal );\r\n\r\n\t\t\t\t\t\t\t\t// 3) notify Structure / listeners (if available).\r\n\t\t\t\t\t\t\t\ttry {\r\n\t\t\t\t\t\t\t\t\tCore.Structure?.update_field_prop?.( el, 'help', defaultVal );\r\n\t\t\t\t\t\t\t\t\tel.dispatchEvent(\r\n\t\t\t\t\t\t\t\t\t\tnew CustomEvent( 'wpbc_bfb_field_data_changed', { bubbles: true, detail : { key: 'help', value: defaultVal } } )\r\n\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t} catch ( _inner ) {}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t} catch ( _e ) {}\r\n\t\t\t}\r\n\t\t\t// -----------------------------------------------------------------------------------------\r\n\r\n\t\t\tif ( context === 'drop' && !Object.prototype.hasOwnProperty.call( data, 'label' ) ) {\r\n\t\t\t\tconst defs = this.get_defaults();\r\n\t\t\t\tdata.label = defs.label || 'Field';\r\n\t\t\t\tel.setAttribute( 'data-label', data.label );\r\n\t\t\t}\r\n\t\t\t// Mark provenance flags.\r\n\t\t\tif ( context === 'drop' ) {\r\n\t\t\t\tel.dataset.fresh      = '1';   // can auto-name on first label edit.\r\n\t\t\t\tel.dataset.autoname   = '1';\r\n\t\t\t\tel.dataset.was_loaded = '0';\r\n\t\t\t\t// Seed a provisional unique name immediately.\r\n\t\t\t\ttry {\r\n\t\t\t\t\tconst b = meta?.builder;\r\n\t\t\t\t\tif ( b?.id && (!el.hasAttribute( 'data-name' ) || !el.getAttribute( 'data-name' )) ) {\r\n\t\t\t\t\t\tconst S    = Core.WPBC_BFB_Sanitize;\r\n\t\t\t\t\t\tconst base = S.sanitize_html_name( el.getAttribute( 'data-id' ) || data?.id || data?.type || 'field' );\r\n\t\t\t\t\t\tconst uniq = b.id.ensure_unique_field_name( base, el );\r\n\t\t\t\t\t\tel.setAttribute( 'data-name', uniq );\r\n\t\t\t\t\t\tel.dataset.name_user_touched = '0';\r\n\t\t\t\t\t}\r\n\t\t\t\t} catch ( _ ) {}\r\n\r\n\t\t\t} else if ( context === 'load' ) {\r\n\t\t\t\tel.dataset.fresh      = '0';\r\n\t\t\t\tel.dataset.autoname   = '0';\r\n\t\t\t\tel.dataset.was_loaded = '1';   // never rename names for loaded fields.\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// --- Auto Rename \"Fresh\" field,  on entering the new Label ---\r\n\r\n\t\t/**\r\n\t\t * Create a conservative field \"name\" from a human label.\r\n\t\t * Uses the same constraints as sanitize_html_name (letters/digits/_- and leading letter).\r\n\t\t */\r\n\t\tstatic name_from_label(label) {\r\n\t\t\tconst s = Core.WPBC_BFB_Sanitize.sanitize_html_name( String( label ?? '' ) );\r\n\t\t\treturn s.toLowerCase() || 'field';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Auto-fill data-name from label ONLY for freshly dropped fields that were not edited yet.\r\n\t\t * - Never runs for sections.\r\n\t\t * - Never runs for loaded/existing fields.\r\n\t\t * - Stops as soon as user edits the Name manually.\r\n\t\t *\r\n\t\t * @param {WPBC_Form_Builder} builder\r\n\t\t * @param {HTMLElement} el  - .wpbc_bfb__field element\r\n\t\t * @param {string} labelVal\r\n\t\t */\r\n\t\tstatic maybe_autoname_from_label(builder, el, labelVal) {\r\n\t\t\tif ( !builder || !el ) return;\r\n\t\t\tif ( el.classList.contains( 'wpbc_bfb__section' ) ) return;\r\n\r\n\t\t\tconst allowAuto = el.dataset.autoname === '1';\r\n\r\n\t\t\tconst userTouched = el.dataset.name_user_touched === '1';\r\n\t\t\tconst isLoaded    = el.dataset.was_loaded === '1';\r\n\r\n\t\t\tif ( !allowAuto || userTouched || isLoaded ) return;\r\n\r\n\t\t\t// Only override placeholder-y names\r\n\t\t\tconst S = Core.WPBC_BFB_Sanitize;\r\n\r\n\t\t\tconst base   = this.name_from_label( labelVal );\r\n\t\t\tconst unique = builder.id.ensure_unique_field_name( base, el );\r\n\t\t\tel.setAttribute( 'data-name', unique );\r\n\r\n\t\t\tconst ins      = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\tconst nameCtrl = ins?.querySelector( '[data-inspector-key=\"name\"]' );\r\n\t\t\tif ( nameCtrl && 'value' in nameCtrl && nameCtrl.value !== unique ) nameCtrl.value = unique;\r\n\t\t}\r\n\r\n\r\n\t};\r\n\r\n\t/**\r\n\t * Select_Base (shared base for select-like packs)\r\n\t *\r\n\t * @type {Core.WPBC_BFB_Select_Base}\r\n\t */\r\n\tCore.WPBC_BFB_Select_Base = class extends Core.WPBC_BFB_Field_Base {\r\n\r\n\t\tstatic template_id            = null;                 // main preview template id\r\n\t\tstatic option_row_template_id = 'wpbc-bfb-inspector-select-option-row'; // row tpl id\r\n\t\tstatic kind                   = 'select';\r\n\t\tstatic __root_wired           = false;\r\n\t\tstatic __root_node            = null;\r\n\r\n\t\t// Single source of selectors used by the inspector UI.\r\n\t\tstatic ui = {\r\n\t\t\tlist   : '.wpbc_bfb__options_list',\r\n\t\t\tholder : '.wpbc_bfb__options_state[data-inspector-key=\"options\"]',\r\n\t\t\trow    : '.wpbc_bfb__options_row',\r\n\t\t\tlabel  : '.wpbc_bfb__opt-label',\r\n\t\t\tvalue  : '.wpbc_bfb__opt-value',\r\n\t\t\ttoggle : '.wpbc_bfb__opt-selected-chk',\r\n\t\t\tadd_btn: '.js-add-option',\r\n\r\n\t\t\tdrag_handle      : '.wpbc_bfb__drag-handle',\r\n\t\t\tmultiple_chk     : '.js-opt-multiple[data-inspector-key=\"multiple\"]',\r\n\t\t\tdefault_text     : '.js-default-value[data-inspector-key=\"default_value\"]',\r\n\t\t\tplaceholder_input: '.js-placeholder[data-inspector-key=\"placeholder\"]',\r\n\t\t\tplaceholder_note : '.js-placeholder-note',\r\n\t\t\tsize_input       : '.inspector__input[data-inspector-key=\"size\"]',\r\n\r\n\t\t\t// Dropdown menu integration.\r\n\t\t\tmenu_root  : '.wpbc_ui_el__dropdown',\r\n\t\t\tmenu_toggle: '[data-toggle=\"wpbc_dropdown\"]',\r\n\t\t\tmenu_action: '.ul_dropdown_menu_li_action[data-action]',\r\n\t\t\t// Value-differs toggle.\r\n\t\t\tvalue_differs_chk: '.js-value-differs[data-inspector-key=\"value_differs\"]',\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Build option value from label.\r\n\t\t * - If `differs === true` -> generate token (slug-like machine value).\r\n\t\t * - If `differs === false` -> keep human text; escape only dangerous chars.\r\n\t\t * @param {string} label\r\n\t\t * @param {boolean} differs\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic build_value_from_label(label, differs) {\r\n\t\t\tconst S = Core.WPBC_BFB_Sanitize;\r\n\t\t\tif ( differs ) {\r\n\t\t\t\treturn (S && typeof S.to_token === 'function')\r\n\t\t\t\t\t? S.to_token( String( label || '' ) )\r\n\t\t\t\t\t: String( label || '' ).trim().toLowerCase().replace( /\\s+/g, '_' ).replace( /[^\\w-]/g, '' );\r\n\t\t\t}\r\n\t\t\t// single-input mode: keep human text; template will escape safely.\r\n\t\t\treturn String( label == null ? '' : label );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Is the “value differs from label” toggle enabled?\r\n\t\t * @param {HTMLElement} panel\r\n\t\t * @returns {boolean}\r\n\t\t */\r\n\t\tstatic is_value_differs_enabled(panel) {\r\n\t\t\tconst chk = panel?.querySelector( this.ui.value_differs_chk );\r\n\t\t\treturn !!(chk && chk.checked);\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Ensure visibility/enabled state of Value inputs based on the toggle.\r\n\t\t * When disabled -> hide Value inputs and keep them mirrored from Label.\r\n\t\t * @param {HTMLElement} panel\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tstatic sync_value_inputs_visibility(panel) {\r\n\t\t\tconst differs = this.is_value_differs_enabled( panel );\r\n\t\t\tconst rows    = panel?.querySelectorAll( this.ui.row ) || [];\r\n\r\n\t\t\tfor ( let i = 0; i < rows.length; i++ ) {\r\n\t\t\t\tconst r      = rows[i];\r\n\t\t\t\tconst lbl_in = r.querySelector( this.ui.label );\r\n\t\t\t\tconst val_in = r.querySelector( this.ui.value );\r\n\t\t\t\tif ( !val_in ) continue;\r\n\r\n\t\t\t\tif ( differs ) {\r\n\t\t\t\t\t// Re-enable & show value input\r\n\t\t\t\t\tval_in.removeAttribute( 'disabled' );\r\n\t\t\t\t\tval_in.style.display = '';\r\n\r\n\t\t\t\t\t// If we have a cached custom value and the row wasn't edited while OFF, restore it\r\n\t\t\t\t\tconst hasCache   = !!val_in.dataset.cached_value;\r\n\t\t\t\t\tconst userEdited = r.dataset.value_user_touched === '1';\r\n\r\n\t\t\t\t\tif ( hasCache && !userEdited ) {\r\n\t\t\t\t\t\tval_in.value = val_in.dataset.cached_value;\r\n\t\t\t\t\t} else if ( !hasCache ) {\r\n\t\t\t\t\t\t// No cache: if value is just a mirrored label, offer a tokenized default\r\n\t\t\t\t\t\tconst lbl      = lbl_in ? lbl_in.value : '';\r\n\t\t\t\t\t\tconst mirrored = this.build_value_from_label( lbl, /*differs=*/false );\r\n\t\t\t\t\t\tif ( val_in.value === mirrored ) {\r\n\t\t\t\t\t\t\tval_in.value = this.build_value_from_label( lbl, /*differs=*/true );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// ON -> OFF: cache once, then mirror\r\n\t\t\t\t\tif ( !val_in.dataset.cached_value ) {\r\n\t\t\t\t\t\tval_in.dataset.cached_value = val_in.value || '';\r\n\t\t\t\t\t}\r\n\t\t\t\t\tconst lbl    = lbl_in ? lbl_in.value : '';\r\n\t\t\t\t\tval_in.value = this.build_value_from_label( lbl, /*differs=*/false );\r\n\r\n\t\t\t\t\tval_in.setAttribute( 'disabled', 'disabled' );\r\n\t\t\t\t\tval_in.style.display = 'none';\r\n\t\t\t\t\t// NOTE: do NOT mark as user_touched here\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Return whether this row’s value has been edited by user.\r\n\t\t * @param {HTMLElement} row\r\n\t\t * @returns {boolean}\r\n\t\t */\r\n\t\tstatic is_row_value_user_touched(row) {\r\n\t\t\treturn row?.dataset?.value_user_touched === '1';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Mark this row’s value as edited by user.\r\n\t\t * @param {HTMLElement} row\r\n\t\t */\r\n\t\tstatic mark_row_value_user_touched(row) {\r\n\t\t\tif ( row ) row.dataset.value_user_touched = '1';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Initialize “freshness” flags on a row (value untouched).\r\n\t\t * Call on creation/append of rows.\r\n\t\t * @param {HTMLElement} row\r\n\t\t */\r\n\t\tstatic init_row_fresh_flags(row) {\r\n\t\t\tif ( row ) {\r\n\t\t\t\tif ( !row.dataset.value_user_touched ) {\r\n\t\t\t\t\trow.dataset.value_user_touched = '0';\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// ---- defaults (packs can override) ----\r\n\t\tstatic get_defaults() {\r\n\t\t\treturn {\r\n\t\t\t\ttype         : this.kind,\r\n\t\t\t\tlabel        : 'Select',\r\n\t\t\t\tname         : '',\r\n\t\t\t\thtml_id      : '',\r\n\t\t\t\tplaceholder  : '--- Select ---',\r\n\t\t\t\trequired     : false,\r\n\t\t\t\tmultiple     : false,\r\n\t\t\t\tsize         : null,\r\n\t\t\t\tcssclass     : '',\r\n\t\t\t\thelp         : '',\r\n\t\t\t\tdefault_value: '',\r\n\t\t\t\toptions      : [\r\n\t\t\t\t\t{ label: 'Option 1', value: 'Option 1', selected: false },\r\n\t\t\t\t\t{ label: 'Option 2', value: 'Option 2', selected: false },\r\n\t\t\t\t\t{ label: 'Option 3', value: 'Option 3', selected: false },\r\n\t\t\t\t\t{ label: 'Option 4', value: 'Option 4', selected: false }\r\n\t\t\t\t],\r\n\t\t\t\tmin_width    : '240px'\r\n\t\t\t};\r\n\t\t}\r\n\r\n\t\t// ---- preview render (idempotent) ----\r\n\t\tstatic render(el, data, ctx) {\r\n\t\t\tif ( !el ) return;\r\n\r\n\t\t\tconst d = this.normalize_data( data );\r\n\r\n\t\t\tif ( d.min_width != null ) {\r\n\t\t\t\tel.dataset.min_width = String( d.min_width );\r\n\t\t\t\ttry {\r\n\t\t\t\t\tel.style.setProperty( '--wpbc-col-min', String( d.min_width ) );\r\n\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif ( d.html_id != null ) el.dataset.html_id = String( d.html_id || '' );\r\n\t\t\tif ( d.cssclass != null ) el.dataset.cssclass = String( d.cssclass || '' );\r\n\t\t\tif ( d.placeholder != null ) el.dataset.placeholder = String( d.placeholder || '' );\r\n\r\n\t\t\tconst tpl = this.get_template( this.template_id );\r\n\t\t\tif ( typeof tpl !== 'function' ) {\r\n\t\t\t\tel.innerHTML = '<div class=\"wpbc_bfb__error\" role=\"alert\">Template not found: ' + this.template_id + '.</div>';\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\ttry {\r\n\t\t\t\tel.innerHTML = tpl( d );\r\n\t\t\t} catch ( e ) {\r\n\t\t\t\twindow._wpbc?.dev?.error?.( 'Select_Base.render', e );\r\n\t\t\t\tel.innerHTML = '<div class=\"wpbc_bfb__error\" role=\"alert\">Error rendering field preview.</div>';\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tel.dataset.type = d.type || this.kind;\r\n\t\t\tel.setAttribute( 'data-label', (d.label != null ? String( d.label ) : '') );\r\n\r\n\t\t\ttry {\r\n\t\t\t\tCore.UI?.WPBC_BFB_Overlay?.ensure?.( ctx?.builder, el );\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t}\r\n\r\n\t\t\tif ( !el.dataset.options && Array.isArray( d.options ) && d.options.length ) {\r\n\t\t\t\ttry {\r\n\t\t\t\t\tel.dataset.options = JSON.stringify( d.options );\r\n\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// ---- drop seeding (options + placeholder) ----\r\n\t\tstatic on_field_drop(data, el, meta) {\r\n\t\t\ttry {\r\n\t\t\t\tsuper.on_field_drop?.( data, el, meta );\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t}\r\n\r\n\t\t\tconst is_drop = (meta && meta.context === 'drop');\r\n\r\n\t\t\tif ( is_drop ) {\r\n\t\t\t\tif ( !Array.isArray( data.options ) || !data.options.length ) {\r\n\t\t\t\t\tconst opts   = (this.get_defaults().options || []).map( (o) => ({\r\n\t\t\t\t\t\tlabel   : o.label,\r\n\t\t\t\t\t\tvalue   : o.value,\r\n\t\t\t\t\t\tselected: !!o.selected\r\n\t\t\t\t\t}) );\r\n\t\t\t\t\tdata.options = opts;\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tel.dataset.options = JSON.stringify( opts );\r\n\t\t\t\t\t\tel.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', { bubbles: true,\r\n\t\t\t\t\t\t\tdetail                                                                 : {\r\n\t\t\t\t\t\t\t\tkey  : 'options',\r\n\t\t\t\t\t\t\t\tvalue: opts\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} ) );\r\n\t\t\t\t\t\tCore.Structure?.update_field_prop?.( el, 'options', opts );\r\n\t\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst ph = (data.placeholder ?? '').toString().trim();\r\n\t\t\t\tif ( !ph ) {\r\n\t\t\t\t\tconst dflt       = this.get_defaults().placeholder || '--- Select ---';\r\n\t\t\t\t\tdata.placeholder = dflt;\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tel.dataset.placeholder = String( dflt );\r\n\t\t\t\t\t\tel.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', { bubbles: true,\r\n\t\t\t\t\t\t\tdetail                                                                 : {\r\n\t\t\t\t\t\t\t\tkey  : 'placeholder',\r\n\t\t\t\t\t\t\t\tvalue: dflt\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} ) );\r\n\t\t\t\t\t\tCore.Structure?.update_field_prop?.( el, 'placeholder', dflt );\r\n\t\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// ==============================\r\n\t\t// Inspector helpers (snake_case)\r\n\t\t// ==============================\r\n\t\tstatic get_panel_root(el) {\r\n\t\t\treturn el?.closest?.( '.wpbc_bfb__inspector__body' ) || el?.closest?.( '.wpbc_bfb__inspector' ) || null;\r\n\t\t}\r\n\r\n\t\tstatic get_list(panel) {\r\n\t\t\treturn panel ? panel.querySelector( this.ui.list ) : null;\r\n\t\t}\r\n\r\n\t\tstatic get_holder(panel) {\r\n\t\t\treturn panel ? panel.querySelector( this.ui.holder ) : null;\r\n\t\t}\r\n\r\n\t\tstatic make_uid() {\r\n\t\t\treturn 'wpbc_ins_auto_opt_' + Math.random().toString( 36 ).slice( 2, 10 );\r\n\t\t}\r\n\r\n\t\tstatic append_row(panel, data) {\r\n\t\t\tconst list = this.get_list( panel );\r\n\t\t\tif ( !list ) return;\r\n\r\n\t\t\tconst idx  = list.children.length;\r\n\t\t\tconst rowd = Object.assign( { label: '', value: '', selected: false, index: idx }, (data || {}) );\r\n\t\t\tif ( !rowd.uid ) rowd.uid = this.make_uid();\r\n\r\n\t\t\tconst tpl_id = this.option_row_template_id;\r\n\t\t\tconst tpl    = (window.wp && wp.template) ? wp.template( tpl_id ) : null;\r\n\t\t\tconst html   = tpl ? tpl( rowd ) : null;\r\n\r\n\t\t\t// In append_row() -> fallback HTML.\r\n\t\t\tconst wrap     = document.createElement( 'div' );\r\n\t\t\twrap.innerHTML = html || (\r\n\t\t\t\t'<div class=\"wpbc_bfb__options_row\" data-index=\"' + (rowd.index || 0) + '\">' +\r\n\t\t\t\t\t'<span class=\"wpbc_bfb__drag-handle\"><span class=\"wpbc_icn_drag_indicator\"></span></span>' +\r\n\t\t\t\t\t'<input type=\"text\" class=\"wpbc_bfb__opt-label\" placeholder=\"Label\" value=\"' + (rowd.label || '') + '\">' +\r\n\t\t\t\t\t'<input type=\"text\" class=\"wpbc_bfb__opt-value\" placeholder=\"Value\" value=\"' + (rowd.value || '') + '\">' +\r\n\t\t\t\t\t'<div class=\"wpbc_bfb__opt-selected\">' +\r\n\t\t\t\t\t\t'<div class=\"inspector__control wpbc_ui__toggle\">' +\r\n\t\t\t\t\t\t\t'<input type=\"checkbox\" class=\"wpbc_bfb__opt-selected-chk inspector__input\" id=\"' + rowd.uid + '\" role=\"switch\" ' + (rowd.selected ? 'checked aria-checked=\"true\"' : 'aria-checked=\"false\"') + '>' +\r\n\t\t\t\t\t\t\t'<label class=\"wpbc_ui__toggle_icon_radio\" for=\"' + rowd.uid + '\"></label>' +\r\n\t\t\t\t\t\t\t'<label class=\"wpbc_ui__toggle_label\" for=\"' + rowd.uid + '\">Default</label>' +\r\n\t\t\t\t\t\t'</div>' +\r\n\t\t\t\t\t'</div>' +\r\n\t\t\t\t\t// 3-dot dropdown (uses existing plugin dropdown JS).\r\n\t\t\t\t\t'<div class=\"wpbc_ui_el wpbc_ui_el_container wpbc_ui_el__dropdown\">' +\r\n\t\t\t\t\t\t'<a href=\"javascript:void(0)\" data-toggle=\"wpbc_dropdown\" aria-expanded=\"false\" class=\"ul_dropdown_menu_toggle\">' +\r\n\t\t\t\t\t\t\t'<i class=\"menu_icon icon-1x wpbc_icn_more_vert\"></i>' +\r\n\t\t\t\t\t\t'</a>' +\r\n\t\t\t\t\t\t'<ul class=\"ul_dropdown_menu\" role=\"menu\" style=\"right:0px; left:auto;\">' +\r\n\t\t\t\t\t\t\t'<li>' +\r\n\t\t\t\t\t\t\t\t'<a class=\"ul_dropdown_menu_li_action\" data-action=\"add_after\" href=\"javascript:void(0)\">' +\r\n\t\t\t\t\t\t\t\t\t'Add New' +\r\n\t\t\t\t\t\t\t\t\t'<i class=\"menu_icon icon-1x wpbc_icn_add_circle\"></i>' +\r\n\t\t\t\t\t\t\t\t'</a>' +\r\n\t\t\t\t\t\t\t'</li>' +\r\n\t\t\t\t\t\t\t'<li>' +\r\n\t\t\t\t\t\t\t\t'<a class=\"ul_dropdown_menu_li_action\" data-action=\"duplicate\" href=\"javascript:void(0)\">' +\r\n\t\t\t\t\t\t\t\t\t'Duplicate' +\r\n\t\t\t\t\t\t\t\t\t'<i class=\"menu_icon icon-1x wpbc_icn_content_copy\"></i>' +\r\n\t\t\t\t\t\t\t\t'</a>' +\r\n\t\t\t\t\t\t\t'</li>' +\r\n\t\t\t\t\t\t\t'<li class=\"divider\"></li>' +\r\n\t\t\t\t\t\t\t'<li>' +\r\n\t\t\t\t\t\t\t\t'<a class=\"ul_dropdown_menu_li_action\" data-action=\"remove\" href=\"javascript:void(0)\">' +\r\n\t\t\t\t\t\t\t\t\t'Remove' +\r\n\t\t\t\t\t\t\t\t\t'<i class=\"menu_icon icon-1x wpbc_icn_delete_outline\"></i>' +\r\n\t\t\t\t\t\t\t\t'</a>' +\r\n\t\t\t\t\t\t\t'</li>' +\r\n\t\t\t\t\t\t'</ul>' +\r\n\t\t\t\t\t'</div>' +\r\n\t\t\t\t'</div>'\r\n\t\t\t);\r\n\r\n\t\t\tconst node = wrap.firstElementChild;\r\n\t\t\t if (! node) {\r\n\t\t\t\t return;\r\n\t\t\t }\r\n\t\t\t// pre-hide Value input if toggle is OFF **before** appending.\r\n\t\t\tconst differs = this.is_value_differs_enabled( panel );\r\n\t\t\tconst valIn   = node.querySelector( this.ui.value );\r\n\t\t\tconst lblIn   = node.querySelector( this.ui.label );\r\n\r\n\t\t\tif ( !differs && valIn ) {\r\n\t\t\t\tif ( !valIn.dataset.cached_value ) {\r\n\t\t\t\t\tvalIn.dataset.cached_value = valIn.value || '';\r\n\t\t\t\t}\r\n\t\t\t\tif ( lblIn ) valIn.value = this.build_value_from_label( lblIn.value, false );\r\n\t\t\t\tvalIn.setAttribute( 'disabled', 'disabled' );\r\n\t\t\t\tvalIn.style.display = 'none';\r\n\t\t\t}\r\n\r\n\r\n\t\t\tthis.init_row_fresh_flags( node );\r\n\t\t\tlist.appendChild( node );\r\n\r\n\t\t\t// Keep your existing post-append sync as a safety net\r\n\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t}\r\n\r\n\t\tstatic close_dropdown(anchor_el) {\r\n\t\t\ttry {\r\n\t\t\t\tvar root = anchor_el?.closest?.( this.ui.menu_root );\r\n\t\t\t\tif ( root ) {\r\n\t\t\t\t\t// If your dropdown toggler toggles a class like 'open', close it.\r\n\t\t\t\t\troot.classList.remove( 'open' );\r\n\t\t\t\t\t// Or if it relies on aria-expanded on the toggle.\r\n\t\t\t\t\tvar t = root.querySelector( this.ui.menu_toggle );\r\n\t\t\t\t\tif ( t ) {\r\n\t\t\t\t\t\tt.setAttribute( 'aria-expanded', 'false' );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} catch ( _ ) { }\r\n\t\t}\r\n\r\n\t\tstatic insert_after(new_node, ref_node) {\r\n\t\t\tif ( ref_node?.parentNode ) {\r\n\t\t\t\tif ( ref_node.nextSibling ) {\r\n\t\t\t\t\tref_node.parentNode.insertBefore( new_node, ref_node.nextSibling );\r\n\t\t\t\t} else {\r\n\t\t\t\t\tref_node.parentNode.appendChild( new_node );\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tstatic commit_options(panel) {\r\n\t\t\tconst list   = this.get_list( panel );\r\n\t\t\tconst holder = this.get_holder( panel );\r\n\t\t\tif ( !list || !holder ) return;\r\n\r\n\t\t\tconst differs = this.is_value_differs_enabled( panel );\r\n\r\n\t\t\tconst rows    = list.querySelectorAll( this.ui.row );\r\n\t\t\tconst options = [];\r\n\t\t\tfor ( let i = 0; i < rows.length; i++ ) {\r\n\t\t\t\tconst r      = rows[i];\r\n\t\t\t\tconst lbl_in = r.querySelector( this.ui.label );\r\n\t\t\t\tconst val_in = r.querySelector( this.ui.value );\r\n\t\t\t\tconst chk    = r.querySelector( this.ui.toggle );\r\n\r\n\t\t\t\tconst lbl = (lbl_in && lbl_in.value) || '';\r\n\t\t\t\tlet val   = (val_in && val_in.value) || '';\r\n\r\n\t\t\t\t// If single-input mode -> hard mirror to label.\r\n\t\t\t\tif ( ! differs ) {\r\n\t\t\t\t\t// single-input mode: mirror Label, minimal escaping (no slug).\r\n\t\t\t\t\tval = this.build_value_from_label( lbl, /*differs=*/false );\r\n\t\t\t\t\tif ( val_in ) {\r\n\t\t\t\t\t\tval_in.value = val;   // keep hidden input in sync for any previews/debug.\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst sel = !!(chk && chk.checked);\r\n\t\t\t\toptions.push( { label: lbl, value: val, selected: sel } );\r\n\t\t\t}\r\n\r\n\t\t\ttry {\r\n\t\t\t\tholder.value = JSON.stringify( options );\r\n\t\t\t\tholder.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\tholder.dispatchEvent( new Event( 'change', { bubbles: true } ) );\r\n\t\t\t\tpanel.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', {\r\n\t\t\t\t\tbubbles: true, detail: {\r\n\t\t\t\t\t\tkey: 'options', value: options\r\n\t\t\t\t\t}\r\n\t\t\t\t} ) );\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t}\r\n\r\n\t\t\tthis.sync_default_value_lock( panel );\r\n\t\t\tthis.sync_placeholder_lock( panel );\r\n\r\n\t\t\t// Mirror to the selected field element so canvas/export sees current options immediately.\r\n\t\t\tconst field = panel.__selectbase_field\r\n\t\t\t\t|| document.querySelector( '.wpbc_bfb__field.is-selected, .wpbc_bfb__field--selected' );\r\n\t\t\tif ( field ) {\r\n\t\t\t\ttry {\r\n\t\t\t\t\tfield.dataset.options = JSON.stringify( options );\r\n\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t}\r\n\t\t\t\tCore.Structure?.update_field_prop?.( field, 'options', options );\r\n\t\t\t\tfield.dispatchEvent( new CustomEvent( 'wpbc_bfb_field_data_changed', {\r\n\t\t\t\t\tbubbles: true, detail: { key: 'options', value: options }\r\n\t\t\t\t} ) );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\tstatic ensure_sortable(panel) {\r\n\r\n\t\t\tconst list = this.get_list( panel );\r\n\t\t\tif ( ! list ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\ttry {\r\n\t\t\t\tconst existing = window.Sortable?.get?.( list );\r\n\t\t\t\tif ( existing ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst builder = window.wpbc_bfb_api?.get_builder?.() || window.wpbc_bfb || null;\r\n\r\n\t\t\t\t// Prefer the shared Sortable manager so the sidebar list uses\r\n\t\t\t\t// the dedicated \"simple_list\" config instead of the canvas config.\r\n\t\t\t\tif ( builder && builder.sortable && typeof builder.sortable.ensure === 'function' ) {\r\n\r\n\t\t\t\t\tbuilder.sortable.ensure(\r\n\t\t\t\t\t\tlist,\r\n\t\t\t\t\t\t'canvas',\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tsortable_kind     : 'simple_list',\r\n\t\t\t\t\t\t\thandle_selector   : this.ui.drag_handle,\r\n\t\t\t\t\t\t\tdraggable_selector: this.ui.row,\r\n\t\t\t\t\t\t\tonUpdate          : () => {\r\n\t\t\t\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t);\r\n\r\n\t\t\t\t} else if ( window.Sortable?.create ) {\r\n\t\t\t\t\t// Fallback if builder is not ready for some reason.\r\n\t\t\t\t\twindow.Sortable.create(\r\n\t\t\t\t\t\tlist,\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\thandle           : this.ui.drag_handle,\r\n\t\t\t\t\t\t\tdraggable        : this.ui.row,\r\n\t\t\t\t\t\t\tanimation        : 120,\r\n\t\t\t\t\t\t\tforceFallback    : true,\r\n\t\t\t\t\t\t\tfallbackOnBody   : false,\r\n\t\t\t\t\t\t\tfallbackTolerance: 8,\r\n\t\t\t\t\t\t\tremoveCloneOnHide: true,\r\n\t\t\t\t\t\t\tonUpdate         : () => {\r\n\t\t\t\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tlist.dataset.sortable_init = '1';\r\n\r\n\t\t\t} catch ( e ) {\r\n\t\t\t\twindow._wpbc?.dev?.error?.( 'Select_Base.ensure_sortable', e );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tstatic rebuild_if_empty(panel) {\r\n\t\t\tconst list   = this.get_list( panel );\r\n\t\t\tconst holder = this.get_holder( panel );\r\n\t\t\tif ( !list || !holder || list.children.length ) return;\r\n\r\n\t\t\tlet data = [];\r\n\t\t\ttry {\r\n\t\t\t\tdata = JSON.parse( holder.value || '[]' );\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t\tdata = [];\r\n\t\t\t}\r\n\r\n\t\t\tif ( !Array.isArray( data ) || !data.length ) {\r\n\t\t\t\tdata = (this.get_defaults().options || []).slice( 0 );\r\n\t\t\t\ttry {\r\n\t\t\t\t\tholder.value = JSON.stringify( data );\r\n\t\t\t\t\tholder.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\t\tholder.dispatchEvent( new Event( 'change', { bubbles: true } ) );\r\n\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tfor ( let i = 0; i < data.length; i++ ) {\r\n\t\t\t\tthis.append_row( panel, {\r\n\t\t\t\t\tlabel   : data[i]?.label || '',\r\n\t\t\t\t\tvalue   : data[i]?.value || '',\r\n\t\t\t\t\tselected: !!data[i]?.selected,\r\n\t\t\t\t\tindex   : i,\r\n\t\t\t\t\tuid     : this.make_uid()\r\n\t\t\t\t} );\r\n\t\t\t}\r\n\r\n\t\t\tthis.sync_default_value_lock( panel );\r\n\t\t\tthis.sync_placeholder_lock( panel );\r\n\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t}\r\n\r\n\t\tstatic has_row_defaults(panel) {\r\n\t\t\tconst checks = panel?.querySelectorAll( this.ui.toggle );\r\n\t\t\tif ( !checks?.length ) return false;\r\n\t\t\tfor ( let i = 0; i < checks.length; i++ ) if ( checks[i].checked ) return true;\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tstatic is_multiple_enabled(panel) {\r\n\t\t\tconst chk = panel?.querySelector( this.ui.multiple_chk );\r\n\t\t\treturn !!(chk && chk.checked);\r\n\t\t}\r\n\r\n\t\tstatic has_text_default_value(panel) {\r\n\t\t\tconst dv = panel?.querySelector( this.ui.default_text );\r\n\t\t\treturn !!(dv && String( dv.value || '' ).trim().length);\r\n\t\t}\r\n\r\n\t\tstatic sync_default_value_lock(panel) {\r\n\t\t\tconst input = panel?.querySelector( this.ui.default_text );\r\n\t\t\tconst note  = panel?.querySelector( '.js-default-value-note' );\r\n\t\t\tif ( !input ) return;\r\n\r\n\t\t\tconst lock     = this.has_row_defaults( panel );\r\n\t\t\tinput.disabled = !!lock;\r\n\t\t\tif ( lock ) {\r\n\t\t\t\tinput.setAttribute( 'aria-disabled', 'true' );\r\n\t\t\t\tif ( note ) note.style.display = '';\r\n\t\t\t} else {\r\n\t\t\t\tinput.removeAttribute( 'aria-disabled' );\r\n\t\t\t\tif ( note ) note.style.display = 'none';\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tstatic sync_placeholder_lock(panel) {\r\n\t\t\tconst input = panel?.querySelector( this.ui.placeholder_input );\r\n\t\t\tconst note  = panel?.querySelector( this.ui.placeholder_note );\r\n\r\n\t\t\t// NEW: compute multiple and toggle row visibility\r\n\t\t\tconst isMultiple     = this.is_multiple_enabled( panel );\r\n\t\t\tconst placeholderRow = input?.closest( '.inspector__row' ) || null;\r\n\t\t\tconst sizeInput      = panel?.querySelector( this.ui.size_input ) || null;\r\n\t\t\tconst sizeRow        = sizeInput?.closest( '.inspector__row' ) || null;\r\n\r\n\t\t\t// Show placeholder only for single-select; show size only for multiple\r\n\t\t\tif ( placeholderRow ) placeholderRow.style.display = isMultiple ? 'none' : '';\r\n\t\t\tif ( sizeRow ) sizeRow.style.display = isMultiple ? '' : 'none';\r\n\r\n\t\t\t// Existing behavior (keep as-is)\r\n\t\t\tif ( !input ) return;\r\n\r\n\t\t\tconst lock = isMultiple || this.has_row_defaults( panel ) || this.has_text_default_value( panel );\r\n\t\t\tif ( note && !note.id ) note.id = 'wpbc_placeholder_note_' + Math.random().toString( 36 ).slice( 2, 10 );\r\n\r\n\t\t\tinput.disabled = !!lock;\r\n\t\t\tif ( lock ) {\r\n\t\t\t\tinput.setAttribute( 'aria-disabled', 'true' );\r\n\t\t\t\tif ( note ) {\r\n\t\t\t\t\tnote.style.display = '';\r\n\t\t\t\t\tinput.setAttribute( 'aria-describedby', note.id );\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tinput.removeAttribute( 'aria-disabled' );\r\n\t\t\t\tinput.removeAttribute( 'aria-describedby' );\r\n\t\t\t\tif ( note ) note.style.display = 'none';\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tstatic enforce_single_default(panel, clicked) {\r\n\t\t\tif ( this.is_multiple_enabled( panel ) ) return;\r\n\r\n\t\t\tconst checks = panel?.querySelectorAll( this.ui.toggle );\r\n\t\t\tif ( !checks?.length ) return;\r\n\r\n\t\t\tif ( clicked && clicked.checked ) {\r\n\t\t\t\tfor ( let i = 0; i < checks.length; i++ ) if ( checks[i] !== clicked ) {\r\n\t\t\t\t\tchecks[i].checked = false;\r\n\t\t\t\t\tchecks[i].setAttribute( 'aria-checked', 'false' );\r\n\t\t\t\t}\r\n\t\t\t\tclicked.setAttribute( 'aria-checked', 'true' );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tlet kept = false;\r\n\t\t\tfor ( let j = 0; j < checks.length; j++ ) if ( checks[j].checked ) {\r\n\t\t\t\tif ( !kept ) {\r\n\t\t\t\t\tkept = true;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tchecks[j].checked = false;\r\n\t\t\t\t\tchecks[j].setAttribute( 'aria-checked', 'false' );\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tthis.sync_default_value_lock( panel );\r\n\t\t\tthis.sync_placeholder_lock( panel );\r\n\t\t}\r\n\r\n\t\t// ---- one-time bootstrap of a panel ----\r\n\t\tstatic bootstrap_panel(panel) {\r\n\t\t\tif ( !panel ) return;\r\n\t\t\tif ( !panel.querySelector( '.wpbc_bfb__options_editor' ) ) return; // only select-like UIs\r\n\t\t\tif ( panel.dataset.selectbase_bootstrapped === '1' ) {\r\n\t\t\t\tthis.ensure_sortable( panel );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tthis.rebuild_if_empty( panel );\r\n\t\t\tthis.ensure_sortable( panel );\r\n\t\t\tpanel.dataset.selectbase_bootstrapped = '1';\r\n\r\n\t\t\tthis.sync_default_value_lock( panel );\r\n\t\t\tthis.sync_placeholder_lock( panel );\r\n\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t}\r\n\r\n\t\t// ---- hook into inspector lifecycle (fires ONCE) ----\r\n\t\tstatic wire_once() {\r\n\t\t\tif ( Core.__selectbase_wired ) return;\r\n\t\t\tCore.__selectbase_wired = true;\r\n\r\n\t\t\tconst on_ready_or_render = (ev) => {\r\n\t\t\t\tconst panel = ev?.detail?.panel;\r\n\t\t\t\tconst field = ev?.detail?.el || ev?.detail?.field || null;\r\n\t\t\t\tif ( !panel ) return;\r\n\t\t\t\tif ( field ) panel.__selectbase_field = field;\r\n\t\t\t\tthis.bootstrap_panel( panel );\r\n\t\t\t\t// If the inspector root was remounted, ensure root listeners are (re)bound.\r\n\t\t\t\tthis.wire_root_listeners();\r\n\t\t\t};\r\n\r\n\t\t\tdocument.addEventListener( 'wpbc_bfb_inspector_ready', on_ready_or_render );\r\n\t\t\tdocument.addEventListener( 'wpbc_bfb_inspector_render', on_ready_or_render );\r\n\r\n\t\t\tthis.wire_root_listeners();\r\n\t\t}\r\n\r\n\t\tstatic wire_root_listeners() {\r\n\r\n\t\t\t// If already wired AND the stored root is still in the DOM, bail out.\r\n\t\t\tif ( this.__root_wired && this.__root_node?.isConnected ) return;\r\n\r\n\t\t\tconst root = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\tif ( !root ) {\r\n\t\t\t\t// Root missing (e.g., SPA re-render) — clear flags so we can wire later.\r\n\t\t\t\tthis.__root_wired = false;\r\n\t\t\t\tthis.__root_node  = null;\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tthis.__root_node                   = root;\r\n\t\t\tthis.__root_wired                  = true;\r\n\t\t\troot.dataset.selectbase_root_wired = '1';\r\n\r\n\t\t\tconst get_panel = (target) =>\r\n\t\t\t\ttarget?.closest?.( '.wpbc_bfb__inspector__body' ) ||\r\n\t\t\t\troot.querySelector( '.wpbc_bfb__inspector__body' ) || null;\r\n\r\n\t\t\t// Click handlers: add / delete / duplicate\r\n\t\t\troot.addEventListener( 'click', (e) => {\r\n\t\t\t\tconst panel = get_panel( e.target );\r\n\t\t\t\tif ( !panel ) return;\r\n\r\n\t\t\t\tthis.bootstrap_panel( panel );\r\n\r\n\t\t\t\tconst ui = this.ui;\r\n\r\n\t\t\t\t// Existing \"Add option\" button (top toolbar)\r\n\t\t\t\tconst add = e.target.closest?.( ui.add_btn );\r\n\t\t\t\tif ( add ) {\r\n\t\t\t\t\tthis.append_row( panel, { label: '', value: '', selected: false } );\r\n\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Dropdown menu actions.\r\n\t\t\t\tconst menu_action = e.target.closest?.( ui.menu_action );\r\n\t\t\t\tif ( menu_action ) {\r\n\t\t\t\t\te.preventDefault();\r\n\t\t\t\t\te.stopPropagation();\r\n\r\n\t\t\t\t\tconst action = (menu_action.getAttribute( 'data-action' ) || '').toLowerCase();\r\n\t\t\t\t\tconst row    = menu_action.closest?.( ui.row );\r\n\r\n\t\t\t\t\tif ( !row ) {\r\n\t\t\t\t\t\tthis.close_dropdown( menu_action );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif ( 'add_after' === action ) {\r\n\t\t\t\t\t\t// Add empty row after current\r\n\t\t\t\t\t\tconst prev_count = this.get_list( panel )?.children.length || 0;\r\n\t\t\t\t\t\tthis.append_row( panel, { label: '', value: '', selected: false } );\r\n\t\t\t\t\t\t// Move the newly added last row just after current row to preserve \"add after\"\r\n\t\t\t\t\t\tconst list = this.get_list( panel );\r\n\t\t\t\t\t\tif ( list && list.lastElementChild && list.lastElementChild !== row ) {\r\n\t\t\t\t\t\t\tthis.insert_after( list.lastElementChild, row );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t\t\t\t} else if ( 'duplicate' === action ) {\r\n\t\t\t\t\t\tconst lbl = (row.querySelector( ui.label ) || {}).value || '';\r\n\t\t\t\t\t\tconst val = (row.querySelector( ui.value ) || {}).value || '';\r\n\t\t\t\t\t\tconst sel = !!((row.querySelector( ui.toggle ) || {}).checked);\r\n\t\t\t\t\t\tthis.append_row( panel, { label: lbl, value: val, selected: sel, uid: this.make_uid() } );\r\n\t\t\t\t\t\t// Place the new row right after the current.\r\n\t\t\t\t\t\tconst list = this.get_list( panel );\r\n\r\n\t\t\t\t\t\tif ( list && list.lastElementChild && list.lastElementChild !== row ) {\r\n\t\t\t\t\t\t\tthis.insert_after( list.lastElementChild, row );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tthis.enforce_single_default( panel, null );\r\n\t\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t\t\t\t} else if ( 'remove' === action ) {\r\n\t\t\t\t\t\tif ( row && row.parentNode ) row.parentNode.removeChild( row );\r\n\t\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tthis.close_dropdown( menu_action );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t}, true );\r\n\r\n\r\n\t\t\t// Input delegation.\r\n\t\t\troot.addEventListener( 'input', (e) => {\r\n\t\t\t\tconst panel = get_panel( e.target );\r\n\t\t\t\tif ( ! panel ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tconst ui                = this.ui;\r\n\t\t\t\tconst is_label_or_value = e.target.classList?.contains( 'wpbc_bfb__opt-label' ) || e.target.classList?.contains( 'wpbc_bfb__opt-value' );\r\n\t\t\t\tconst is_toggle         = e.target.classList?.contains( 'wpbc_bfb__opt-selected-chk' );\r\n\t\t\t\tconst is_multiple       = e.target.matches?.( ui.multiple_chk );\r\n\t\t\t\tconst is_default_text   = e.target.matches?.( ui.default_text );\r\n\t\t\t\tconst is_value_differs  = e.target.matches?.( ui.value_differs_chk );\r\n\r\n\t\t\t\t// Handle \"value differs\" toggle live\r\n\t\t\t\tif ( is_value_differs ) {\r\n\t\t\t\t\tthis.sync_value_inputs_visibility( panel );\r\n\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Track when the user edits VALUE explicitly\r\n\t\t\t\tif ( e.target.classList?.contains( 'wpbc_bfb__opt-value' ) ) {\r\n\t\t\t\t\tconst row = e.target.closest( this.ui.row );\r\n\t\t\t\t\tthis.mark_row_value_user_touched( row );\r\n\t\t\t\t\t// Keep the cache updated so toggling OFF/ON later restores the latest custom value\r\n\t\t\t\t\te.target.dataset.cached_value = e.target.value || '';\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Auto-fill VALUE from LABEL if value is fresh (and differs is ON); if differs is OFF, we mirror anyway in commit\r\n\t\t\t\tif ( e.target.classList?.contains( 'wpbc_bfb__opt-label' ) ) {\r\n\t\t\t\t\tconst row     = e.target.closest( ui.row );\r\n\t\t\t\t\tconst val_in  = row?.querySelector( ui.value );\r\n\t\t\t\t\tconst differs = this.is_value_differs_enabled( panel );\r\n\r\n\t\t\t\t\tif ( val_in ) {\r\n\t\t\t\t\t\tif ( !differs ) {\r\n\t\t\t\t\t\t\t// single-input mode: mirror human label with minimal escaping\r\n\t\t\t\t\t\t\tval_in.value = this.build_value_from_label( e.target.value, false );\r\n\t\t\t\t\t\t} else if ( !this.is_row_value_user_touched( row ) ) {\r\n\t\t\t\t\t\t\t// separate-value mode, only while fresh\r\n\t\t\t\t\t\t\tval_in.value = this.build_value_from_label( e.target.value, true );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\r\n\t\t\t\tif ( is_label_or_value || is_toggle || is_multiple ) {\r\n\t\t\t\t\tif ( is_toggle ) e.target.setAttribute( 'aria-checked', e.target.checked ? 'true' : 'false' );\r\n\t\t\t\t\tif ( is_toggle || is_multiple ) this.enforce_single_default( panel, is_toggle ? e.target : null );\r\n\t\t\t\t\tthis.commit_options( panel );\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif ( is_default_text ) {\r\n\t\t\t\t\tthis.sync_default_value_lock( panel );\r\n\t\t\t\t\tthis.sync_placeholder_lock( panel );\r\n\t\t\t\t\tconst holder = this.get_holder( panel );\r\n\t\t\t\t\tif ( holder ) {\r\n\t\t\t\t\t\tholder.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\t\t\tholder.dispatchEvent( new Event( 'change', { bubbles: true } ) );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}, true );\r\n\r\n\r\n\t\t\t// Change delegation\r\n\t\t\troot.addEventListener( 'change', (e) => {\r\n\t\t\t\tconst panel = get_panel( e.target );\r\n\t\t\t\tif ( !panel ) return;\r\n\r\n\t\t\t\tconst ui        = this.ui;\r\n\t\t\t\tconst is_toggle = e.target.classList?.contains( 'wpbc_bfb__opt-selected-chk' );\r\n\t\t\t\tconst is_multi  = e.target.matches?.( ui.multiple_chk );\r\n\t\t\t\tif ( !is_toggle && !is_multi ) return;\r\n\r\n\t\t\t\tif ( is_toggle ) e.target.setAttribute( 'aria-checked', e.target.checked ? 'true' : 'false' );\r\n\t\t\t\tthis.enforce_single_default( panel, is_toggle ? e.target : null );\r\n\t\t\t\tthis.commit_options( panel );\r\n\t\t\t}, true );\r\n\r\n\t\t\t// Lazy bootstrap\r\n\t\t\troot.addEventListener( 'mouseenter', (e) => {\r\n\t\t\t\tconst panel = get_panel( e.target );\r\n\t\t\t\tif ( panel && e.target?.closest?.( this.ui.list ) ) this.bootstrap_panel( panel );\r\n\t\t\t}, true );\r\n\r\n\t\t\troot.addEventListener( 'mousedown', (e) => {\r\n\t\t\t\tconst panel = get_panel( e.target );\r\n\t\t\t\tif ( panel && e.target?.closest?.( this.ui.drag_handle ) ) this.bootstrap_panel( panel );\r\n\t\t\t}, true );\r\n\t\t}\r\n\r\n\t};\r\n\r\n\ttry { Core.WPBC_BFB_Select_Base.wire_once(); } catch (_) {}\r\n\t// Try immediately (if root is already in DOM), then again on DOMContentLoaded.\r\n\tCore.WPBC_BFB_Select_Base.wire_root_listeners();\r\n\r\n\tdocument.addEventListener('DOMContentLoaded', () => { Core.WPBC_BFB_Select_Base.wire_root_listeners();  });\r\n\r\n}( window ));","// ---------------------------------------------------------------------------------------------------------------------\r\n// == File  /includes/page-form-builder/_out/core/bfb-ui.js == | 2025-09-10 15:47\r\n// ---------------------------------------------------------------------------------------------------------------------\r\n(function (w, d) {\r\n\t'use strict';\r\n\r\n\t// Single global namespace (idempotent & load-order safe).\r\n\tconst Core = (w.WPBC_BFB_Core = w.WPBC_BFB_Core || {});\r\n\tconst UI   = (Core.UI = Core.UI || {});\r\n\r\n\t// --- Highlight Element,  like Generator brn  -  Tiny UI helpers ------------------------------------\r\n\tUI._pulse_timers = UI._pulse_timers || new Map(); // el -> timer_id\r\n\tUI._pulse_meta   = UI._pulse_meta   || new Map(); // el -> { token, last_ts, debounce_id, color_set }\r\n\t// Pulse tuning (milliseconds).\r\n\tUI.PULSE_THROTTLE_MS  = Number.isFinite( UI.PULSE_THROTTLE_MS ) ? UI.PULSE_THROTTLE_MS : 500;\r\n\tUI.PULSE_DEBOUNCE_MS  = Number.isFinite( UI.PULSE_DEBOUNCE_MS ) ? UI.PULSE_DEBOUNCE_MS : 750;\r\n\r\n\t// Debounce STRUCTURE_CHANGE for continuous inspector controls (sliders / scrubbing).\r\n\t// Tune: 180..350 is usually a sweet spot.\r\n\tUI.STRUCTURE_CHANGE_DEBOUNCE_MS = Number.isFinite( UI.STRUCTURE_CHANGE_DEBOUNCE_MS ) ? UI.STRUCTURE_CHANGE_DEBOUNCE_MS : 180;\r\n\t// Change this to tune speed: 50..120 ms is a good range. Can be configured in <div data-len-group data-len-throttle=\"180\">...</div>.\r\n\tUI.VALUE_SLIDER_THROTTLE_MS = Number.isFinite( UI.VALUE_SLIDER_THROTTLE_MS ) ? UI.VALUE_SLIDER_THROTTLE_MS : 120;\r\n\r\n\t/**\r\n\t * Cancel any running pulse sequence for an element.\r\n\t * Uses token invalidation so already-scheduled callbacks become no-ops.\r\n\t *\r\n\t * @param {HTMLElement} el\r\n\t */\r\n\tUI.cancel_pulse = function (el) {\r\n\t\tif ( !el ) { return; }\r\n\t\ttry {\r\n\t\t\tclearTimeout( UI._pulse_timers.get( el ) );\r\n\t\t} catch ( _ ) {}\r\n\t\tUI._pulse_timers.delete( el );\r\n\r\n\t\tvar meta = UI._pulse_meta.get( el ) || {};\r\n\t\tmeta.token = (Number.isFinite( meta.token ) ? meta.token : 0) + 1;\r\n\t\tmeta.color_set = false;\r\n\t\ttry { el.classList.remove( 'wpbc_bfb__scroll-pulse', 'wpbc_bfb__highlight-pulse' ); } catch ( _ ) {}\r\n\t\ttry { el.style.removeProperty( '--wpbc-bfb-pulse-color' ); } catch ( _ ) {}\r\n\t\tUI._pulse_meta.set( el, meta );\r\n\t\ttry { clearTimeout( meta.debounce_id ); } catch ( _ ) {}\r\n\t\tmeta.debounce_id = 0;\r\n\t};\r\n\r\n\t/**\r\n\t * Force-restart a CSS animation on a class.\r\n\t * @param {HTMLElement} el\r\n\t * @param {string} cls\r\n\t */\r\n\tUI._restart_css_animation = function (el, cls) {\r\n\t\tif ( ! el ) { return; }\r\n\t\ttry {\r\n\t\t\tel.classList.remove( cls );\r\n\t\t} catch ( _ ) {}\r\n\t\t// Force reflow so the next add() retriggers the keyframes.\r\n\t\tvoid el.offsetWidth;\r\n\t\ttry {\r\n\t\t\tel.classList.add( cls );\r\n\t\t} catch ( _ ) {}\r\n\t};\r\n\r\n\t/**\r\n\t\tSingle pulse (back-compat).\r\n\t\t@param {HTMLElement} el\r\n\t\t@param {number} dur_ms\r\n\t */\r\n\tUI.pulse_once = function (el, dur_ms) {\r\n\t\tif ( ! el ) { return; }\r\n\t\tvar cls = 'wpbc_bfb__scroll-pulse';\r\n\t\tvar ms  = Number.isFinite( dur_ms ) ? dur_ms : 700;\r\n\r\n\t\tUI.cancel_pulse( el );\r\n\r\n\t\tvar meta  = UI._pulse_meta.get( el ) || {};\r\n\t\tvar token = (Number.isFinite( meta.token ) ? meta.token : 0) + 1;\r\n\t\tmeta.token = token;\r\n\t\tUI._pulse_meta.set( el, meta );\r\n\r\n\t\tUI._restart_css_animation( el, cls );\r\n\t\tvar t = setTimeout( function () {\r\n\t\t\t// ignore if a newer pulse started.\r\n\t\t\tvar m = UI._pulse_meta.get( el ) || {};\r\n\t\t\tif ( m.token !== token ) { return; }\r\n\t\t\ttry {\r\n\t\t\t\tel.classList.remove( cls );\r\n\t\t\t} catch ( _ ) {}\r\n\t\t\tUI._pulse_timers.delete( el );\r\n\t\t}, ms );\r\n\t\tUI._pulse_timers.set( el, t );\r\n\t};\r\n\r\n\t/**\r\n\t\tMulti-blink sequence with optional per-call color override.\r\n\t\t@param {HTMLElement} el\r\n\t\t@param {number} [times=3]\r\n\t\t@param {number} [on_ms=280]\r\n\t\t@param {number} [off_ms=180]\r\n\t\t@param {string} [hex_color] Optional CSS color (e.g. '#ff4d4f' or 'rgb(...)').\r\n\t */\r\n\tUI.pulse_sequence = function (el, times, on_ms, off_ms, hex_color) {\r\n\t\tif ( !el || !d.body.contains( el ) ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tvar cls   = 'wpbc_bfb__highlight-pulse';\r\n\t\tvar count = Number.isFinite( times ) ? times : 2;\r\n\t\tvar on    = Number.isFinite( on_ms ) ? on_ms : 280;\r\n\t\tvar off   = Number.isFinite( off_ms ) ? off_ms : 180;\r\n\r\n\t\t// Throttle: avoid reflow spam if called repeatedly while typing/dragging.\r\n\t\tvar meta = UI._pulse_meta.get( el ) || {};\r\n\t\tvar now  = Date.now();\r\n\t\tvar throttle_ms = Number.isFinite( UI.PULSE_THROTTLE_MS ) ? UI.PULSE_THROTTLE_MS : 120;\r\n\t\tif ( Number.isFinite( meta.last_ts ) && (now - meta.last_ts) < throttle_ms ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tmeta.last_ts = now;\r\n\r\n\t\t// cancel any running pulse and reset class (token invalidation).\r\n\t\tUI.cancel_pulse( el );\r\n\r\n\t\t// new token for this run\r\n\t\tvar token = (Number.isFinite( meta.token ) ? meta.token : 0) + 1;\r\n\t\tmeta.token = token;\r\n\r\n\t\tvar have_color = !!hex_color && typeof hex_color === 'string';\r\n\t\tif ( have_color ) {\r\n\t\t\ttry {\r\n\t\t\t\tel.style.setProperty( '--wpbc-bfb-pulse-color', hex_color );\r\n\t\t\t} catch ( _ ) {}\r\n\t\t\tmeta.color_set = true;\r\n\t\t}\r\n\t\tUI._pulse_meta.set( el, meta );\r\n\r\n\t\tvar i = 0;\r\n\t\t(function tick() {\r\n\t\t\tvar m = UI._pulse_meta.get( el ) || {};\r\n\t\t\tif ( m.token !== token ) {\r\n\t\t\t\t// canceled/replaced\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tif ( i >= count ) {\r\n\t\t\t\tUI._pulse_timers.delete( el );\r\n\t\t\t\tif ( have_color ) {\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tel.style.removeProperty( '--wpbc-bfb-pulse-color' );\r\n\t\t\t\t\t} catch ( _ ) {}\r\n\t\t\t\t}\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tUI._restart_css_animation( el, cls );\r\n\t\t\tUI._pulse_timers.set( el, setTimeout( function () {     // ON -> OFF\r\n\t\t\t\tvar m2 = UI._pulse_meta.get( el ) || {};\r\n\t\t\t\tif ( m2.token !== token ) { return; }\r\n\t\t\t\ttry {\r\n\t\t\t\t\tel.classList.remove( cls );\r\n\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t}\r\n\t\t\t\tUI._pulse_timers.set( el, setTimeout( function () { // OFF gap -> next\r\n\t\t\t\t\tvar m3 = UI._pulse_meta.get( el ) || {};\r\n\t\t\t\t\tif ( m3.token !== token ) { return; }\r\n\t\t\t\t\ti++;\r\n\t\t\t\t\ttick();\r\n\t\t\t\t}, off ) );\r\n\t\t\t}, on ) );\r\n\t\t})();\r\n\t};\r\n\r\n\r\n\t/**\r\n\t * Debounced query + pulse.\r\n\t * Useful for `input` events (sliders / typing) to avoid forced reflow spam.\r\n\t *\r\n\t * @param {HTMLElement|string} root_or_selector\r\n\t * @param {string} selector\r\n\t * @param {number} wait_ms\r\n\t * @param {number} [a]\r\n\t * @param {number} [b]\r\n\t * @param {number} [c]\r\n\t * @param {string} [color]\r\n\t */\r\n\tUI.pulse_query_debounced = function (root_or_selector, selector, wait_ms, a, b, c, color) {\r\n\t\tvar root = (typeof root_or_selector === 'string') ? d : (root_or_selector || d);\r\n\t\tvar sel  = (typeof root_or_selector === 'string') ? root_or_selector : selector;\r\n\t\tif ( !sel ) { return; }\r\n\t\tvar el = root.querySelector( sel );\r\n\t\tif ( !el ) { return; }\r\n\r\n\t\tvar def_ms = Number.isFinite( UI.PULSE_DEBOUNCE_MS ) ? UI.PULSE_DEBOUNCE_MS : 120;\r\n\t\tvar ms     = Number.isFinite( wait_ms ) ? wait_ms : def_ms;\r\n\t\tvar meta = UI._pulse_meta.get( el ) || {};\r\n\t\ttry { clearTimeout( meta.debounce_id ); } catch ( _ ) {}\r\n\t\tmeta.debounce_id = setTimeout( function () {\r\n\t\t\tUI.pulse_sequence( el, a, b, c, color );\r\n\t\t}, ms );\r\n\t\tUI._pulse_meta.set( el, meta );\r\n\t};\r\n\r\n\t/**\r\n\t\tQuery + pulse:\r\n\t\t(BC) If only 3rd arg is a number and no 4th/5th -> single long pulse.\r\n\t\tOtherwise -> strong sequence (defaults 3×280/180).\r\n\t\tOptional 6th arg: color.\r\n\t\t@param {HTMLElement|string} root_or_selector\r\n\t\t@param {string} [selector]\r\n\t\t@param {number} [a]\r\n\t\t@param {number} [b]\r\n\r\n\t\t@param {number} [c]\r\n\r\n\t\t@param {string} [color]\r\n\t */\r\n\tUI.pulse_query = function (root_or_selector, selector, a, b, c, color) {\r\n\t\tvar root = (typeof root_or_selector === 'string') ? d : (root_or_selector || d);\r\n\t\tvar sel  = (typeof root_or_selector === 'string') ? root_or_selector : selector;\r\n\t\tif ( !sel ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tvar el = root.querySelector( sel );\r\n\t\tif ( !el ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n// Back-compat: UI.pulseQuery(root, sel, dur_ms)\r\n\t\tif ( Number.isFinite( a ) && b === undefined && c === undefined ) {\r\n\t\t\treturn UI.pulse_once( el, a );\r\n\t\t}\r\n// New: sequence; params optional; supports optional color.\r\n\t\tUI.pulse_sequence( el, a, b, c, color );\r\n\t};\r\n\r\n\t/**\r\n\tConvenience helper (snake_case) to call a strong pulse with options.\r\n\r\n\t@param {HTMLElement} el\r\n\r\n\t@param {Object} [opts]\r\n\r\n\t@param {number} [opts.times=3]\r\n\r\n\t@param {number} [opts.on_ms=280]\r\n\r\n\t@param {number} [opts.off_ms=180]\r\n\r\n\t@param {string} [opts.color]\r\n\t */\r\n\tUI.pulse_sequence_strong = function (el, opts) {\r\n\t\topts = opts || {};\r\n\t\tUI.pulse_sequence(\r\n\t\t\tel,\r\n\t\t\tNumber.isFinite( opts.times ) ? opts.times : 3,\r\n\t\t\tNumber.isFinite( opts.on_ms ) ? opts.on_ms : 280,\r\n\t\t\tNumber.isFinite( opts.off_ms ) ? opts.off_ms : 180,\r\n\t\t\topts.color\r\n\t\t);\r\n\t};\r\n\r\n\r\n\t/**\r\n\t * Base class for BFB modules.\r\n\t */\r\n\tUI.WPBC_BFB_Module = class {\r\n\t\t/** @param {WPBC_Form_Builder} builder */\r\n\t\tconstructor(builder) {\r\n\t\t\tthis.builder = builder;\r\n\t\t}\r\n\r\n\t\t/** Initialize the module. */\r\n\t\tinit() {\r\n\t\t}\r\n\r\n\t\t/** Cleanup the module. */\r\n\t\tdestroy() {\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Central overlay/controls manager for fields/sections.\r\n\t * Pure UI composition; all actions route back into the builder instance.\r\n\t */\r\n\tUI.WPBC_BFB_Overlay = class {\n\n\t\t/**\n\t\t * Synchronize every overlay settings button with the real Inspector state.\n\t\t *\n\t\t * A selected canvas item can remain selected while another right-bar panel is\n\t\t * visible. Combining both states prevents a stale pressed button after the\n\t\t * administrator switches away from the Inspector.\n\t\t *\n\t\t * @param {WPBC_Form_Builder} builder - Active Form Builder instance.\n\t\t * @param {HTMLButtonElement[]|NodeListOf<HTMLButtonElement>|null} [settings_buttons=null]\n\t\t *     Optional bounded controls to reconcile during incremental rendering.\n\t\t * @returns {void}\n\t\t */\n\t\tstatic sync_settings_button_states(builder, settings_buttons = null) {\n\n\t\t\tconst pages_container = builder?.pages_container;\n\t\t\tif ( !pages_container?.querySelectorAll ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst inspector         = document.getElementById( 'wpbc_bfb__inspector' );\n\t\t\tconst inspector_is_open = !!inspector\n\t\t\t\t&& !inspector.hasAttribute( 'hidden' )\n\t\t\t\t&& inspector.getAttribute( 'aria-hidden' ) !== 'true';\n\t\t\tconst selectable_query  = `${Core.WPBC_BFB_DOM.SELECTORS.field}, ${Core.WPBC_BFB_DOM.SELECTORS.section}`;\n\n\t\t\tconst buttons = settings_buttons || pages_container.querySelectorAll( '.wpbc_bfb__settings-btn' );\n\n\t\t\tArray.from( buttons ).forEach( (settings_button) => {\n\t\t\t\tconst owner      = settings_button.closest( selectable_query );\n\t\t\t\tconst is_pressed = inspector_is_open\n\t\t\t\t\t&& !!owner?.classList?.contains( Core.WPBC_BFB_DOM.CLASSES.selected );\n\n\t\t\t\tsettings_button.setAttribute( 'aria-pressed', is_pressed ? 'true' : 'false' );\n\t\t\t} );\n\t\t}\n\n\t\t/**\n\t\t * Ensure an overlay exists and is wired up on the element.\n\t\t * @param {WPBC_Form_Builder} builder\r\n\t\t * @param {HTMLElement} el - field or section element\r\n\t\t */\r\n\t\tstatic ensure(builder, el) {\r\n\r\n\t\t\tif ( !el ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tconst isSection = el.classList.contains( 'wpbc_bfb__section' );\r\n\r\n\t\t\t// let overlay = el.querySelector( Core.WPBC_BFB_DOM.SELECTORS.overlay );\r\n\t\t\tlet overlay = el.querySelector( `:scope > ${Core.WPBC_BFB_DOM.SELECTORS.overlay}` );\r\n\t\t\tif ( !overlay ) {\r\n\t\t\t\toverlay = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__overlay-controls' );\r\n\t\t\t\tel.prepend( overlay );\r\n\t\t\t}\r\n\r\n\t\t\t// Drag handle.\r\n\t\t\tif ( !overlay.querySelector( '.wpbc_bfb__drag-handle' ) ) {\r\n\t\t\t\tconst dragClass = isSection ? 'wpbc_bfb__drag-handle section-drag-handle' : 'wpbc_bfb__drag-handle';\r\n\t\t\t\toverlay.appendChild(\r\n\t\t\t\t\tCore.WPBC_Form_Builder_Helper.create_element( 'span', dragClass, '<span class=\"wpbc_icn_drag_indicator\"></span>' )\r\n\t\t\t\t);\r\n\t\t\t}\n\n\t\t\t// SETTINGS button (shown for both fields & sections).\n\t\t\tlet settings_btn = overlay.querySelector( '.wpbc_bfb__settings-btn' );\n\t\t\tif ( !settings_btn ) {\n\t\t\t\tsettings_btn         = Core.WPBC_Form_Builder_Helper.create_element( 'button', 'wpbc_bfb__settings-btn', '<i class=\"menu_icon icon-1x wpbc_icn_near_me wpbc_icn_rotate_270\"></i>' );\n\t\t\t\tsettings_btn.type    = 'button';\n\t\t\t\tsettings_btn.title   = 'Open settings';\n\t\t\t\tsettings_btn.setAttribute( 'aria-label', settings_btn.title );\n\t\t\t\tsettings_btn.setAttribute( 'aria-controls', 'wpbc_bfb__inspector' );\n\t\t\t\tsettings_btn.setAttribute( 'aria-pressed', 'false' );\n\t\t\t\tsettings_btn.onclick = (e) => {\n\t\t\t\t\te.preventDefault();\r\n\t\t\t\t\t// Select THIS element and scroll it into view.\r\n\t\t\t\t\tbuilder.select_field( el, { scrollIntoView: true } );\r\n\r\n\t\t\t\t\t// Auto-open Inspector from the overlay “Settings” button.\r\n\t\t\t\t\twpbc_bfb__dispatch_event_safe(\r\n\t\t\t\t\t\t'wpbc_bfb:show_panel',\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tpanel_id: 'wpbc_bfb__inspector',\r\n\t\t\t\t\t\t\ttab_id  : 'wpbc_tab_inspector'\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t);\r\n\r\n\t\t\t\t\t// Try to bring the inspector into view / focus first input.\r\n\t\t\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\t\t\tif ( ins ) {\r\n\t\t\t\t\t\tins.scrollIntoView( { behavior: 'smooth', block: 'nearest' } );\r\n\t\t\t\t\t\t// Focus first interactive control (best-effort).\r\n\t\t\t\t\t\tsetTimeout( () => {\r\n\t\t\t\t\t\t\tconst focusable = ins.querySelector( 'input,select,textarea,button,[contenteditable],[tabindex]:not([tabindex=\"-1\"])' );\r\n\t\t\t\t\t\t\tfocusable?.focus?.();\r\n\t\t\t\t\t\t}, 260 );\r\n\t\t\t\t\t}\r\n\t\t\t\t};\r\n\r\n\t\t\t\toverlay.appendChild( settings_btn );\r\n\t\t\t}\r\n\n\t\t\toverlay.setAttribute( 'role', 'toolbar' );\n\t\t\toverlay.setAttribute( 'aria-label', el.classList.contains( 'wpbc_bfb__section' ) ? 'Section tools' : 'Field tools' );\n\t\t\tUI.WPBC_BFB_Overlay.sync_settings_button_states( builder, [ settings_btn ] );\n\n\t\t\treturn overlay;\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * WPBC Layout Chips helper - visual layout picker (chips), e.g., \"50%/50%\", to a section overlay.\r\n\t *\r\n\t * Renders Equal/Presets/Custom chips into a host container and wires them to apply the layout.\r\n\t */\r\n\tUI.WPBC_BFB_Layout_Chips = class {\r\n\r\n\t\t/** Read per-column min (px) from CSS var set by the guard. */\r\n\t\tstatic _get_col_min_px(col) {\r\n\t\t\tconst v = getComputedStyle( col ).getPropertyValue( '--wpbc-col-min' ) || '0';\r\n\t\t\tconst n = parseFloat( v );\r\n\t\t\treturn Number.isFinite( n ) ? Math.max( 0, n ) : 0;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Turn raw weights (e.g. [1,1], [2,1,1]) into effective \"available-%\" bases that\r\n\t\t * (a) sum to the row's available %, and (b) meet every column's min px.\r\n\t\t * Returns an array of bases (numbers) or null if impossible to satisfy mins.\r\n\t\t */\r\n\t\tstatic _fit_weights_respecting_min(builder, row, weights) {\r\n\t\t\tconst cols = Array.from( row.querySelectorAll( ':scope > .wpbc_bfb__column' ) );\r\n\t\t\tconst n    = cols.length;\r\n\t\t\tif ( !n ) return null;\r\n\t\t\tif ( !Array.isArray( weights ) || weights.length !== n ) return null;\r\n\r\n\t\t\t// available % after gaps (from LayoutService)\r\n\t\t\tconst gp       = builder.col_gap_percent;\r\n\t\t\tconst eff      = builder.layout.compute_effective_bases_from_row( row, gp );\r\n\t\t\tconst availPct = eff.available;               // e.g. 94 if 2 cols and 3% gap\r\n\t\t\tconst rowPx    = row.getBoundingClientRect().width;\r\n\t\t\tconst availPx  = rowPx * (availPct / 100);\r\n\r\n\t\t\t// collect minima in % of \"available\"\r\n\t\t\tconst minPct = cols.map( (c) => {\r\n\t\t\t\tconst minPx = UI.WPBC_BFB_Layout_Chips._get_col_min_px( c );\r\n\t\t\t\tif ( availPx <= 0 ) return 0;\r\n\t\t\t\treturn (minPx / availPx) * availPct;\r\n\t\t\t} );\r\n\r\n\t\t\t// If mins alone don't fit, bail.\r\n\t\t\tconst sumMin = minPct.reduce( (a, b) => a + b, 0 );\r\n\t\t\tif ( sumMin > availPct - 1e-6 ) {\r\n\t\t\t\treturn null; // impossible to respect mins; don't apply preset\r\n\t\t\t}\r\n\r\n\t\t\t// Target percentages from weights, normalized to availPct.\r\n\t\t\tconst wSum      = weights.reduce( (a, w) => a + (Number( w ) || 0), 0 ) || n;\r\n\t\t\tconst targetPct = weights.map( (w) => ((Number( w ) || 0) / wSum) * availPct );\r\n\r\n\t\t\t// Lock columns that would be below min, then distribute the remainder\r\n\t\t\t// across the remaining columns proportionally to their targetPct.\r\n\t\t\tconst locked  = new Array( n ).fill( false );\r\n\t\t\tlet lockedSum = 0;\r\n\t\t\tfor ( let i = 0; i < n; i++ ) {\r\n\t\t\t\tif ( targetPct[i] < minPct[i] ) {\r\n\t\t\t\t\tlocked[i] = true;\r\n\t\t\t\t\tlockedSum += minPct[i];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tlet remaining     = availPct - lockedSum;\r\n\t\t\tconst freeIdx     = [];\r\n\t\t\tlet freeTargetSum = 0;\r\n\t\t\tfor ( let i = 0; i < n; i++ ) {\r\n\t\t\t\tif ( !locked[i] ) {\r\n\t\t\t\t\tfreeIdx.push( i );\r\n\t\t\t\t\tfreeTargetSum += targetPct[i];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tconst result = new Array( n ).fill( 0 );\r\n\t\t\t// Seed locked with their minima.\r\n\t\t\tfor ( let i = 0; i < n; i++ ) {\r\n\t\t\t\tif ( locked[i] ) result[i] = minPct[i];\r\n\t\t\t}\r\n\r\n\t\t\tif ( freeIdx.length === 0 ) {\r\n\t\t\t\t// everything locked exactly at min; any leftover (shouldn't happen)\r\n\t\t\t\t// would be ignored to keep simplicity and stability.\r\n\t\t\t\treturn result;\r\n\t\t\t}\r\n\r\n\t\t\tif ( remaining <= 0 ) {\r\n\t\t\t\t// nothing left to distribute; keep exactly mins on locked,\r\n\t\t\t\t// nothing for free (degenerate but consistent)\r\n\t\t\t\treturn result;\r\n\t\t\t}\r\n\r\n\t\t\tif ( freeTargetSum <= 0 ) {\r\n\t\t\t\t// distribute equally among free columns\r\n\t\t\t\tconst each = remaining / freeIdx.length;\r\n\t\t\t\tfreeIdx.forEach( (i) => (result[i] = each) );\r\n\t\t\t\treturn result;\r\n\t\t\t}\r\n\r\n\t\t\t// Distribute remaining proportionally to free columns' targetPct\r\n\t\t\tfreeIdx.forEach( (i) => {\r\n\t\t\t\tresult[i] = remaining * (targetPct[i] / freeTargetSum);\r\n\t\t\t} );\r\n\t\t\treturn result;\r\n\t\t}\r\n\r\n\t\t/** Apply a preset but guard it by minima; returns true if applied, false if skipped. */\r\n\t\tstatic _apply_preset_with_min_guard(builder, section_el, weights) {\r\n\t\t\tconst row = section_el.querySelector( ':scope > .wpbc_bfb__row' );\r\n\t\t\tif ( !row ) return false;\r\n\r\n\t\t\tconst fitted = UI.WPBC_BFB_Layout_Chips._fit_weights_respecting_min( builder, row, weights );\r\n\t\t\tif ( !fitted ) {\r\n\t\t\t\tbuilder?._announce?.( 'Not enough space for this layout because of fields’ minimum widths.' );\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\t// `fitted` already sums to the row’s available %, so we can apply bases directly.\r\n\t\t\tbuilder.layout.apply_bases_to_row( row, fitted );\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Build and append layout chips for a section.\r\n\t\t *\r\n\t\t * @param {WPBC_Form_Builder} builder - The form builder instance.\r\n\t\t * @param {HTMLElement} section_el - The .wpbc_bfb__section element.\r\n\t\t * @param {HTMLElement} host_el - Container where chips should be rendered.\r\n\t\t * @returns {void}\r\n\t\t */\r\n\t\tstatic render_for_section(builder, section_el, host_el) {\r\n\r\n\t\t\tif ( !builder || !section_el || !host_el ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst row = section_el.querySelector( ':scope > .wpbc_bfb__row' );\r\n\t\t\tif ( !row ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst cols = row.querySelectorAll( ':scope > .wpbc_bfb__column' ).length || 1;\r\n\r\n\t\t\t// Clear host.\r\n\t\t\thost_el.innerHTML = '';\r\n\r\n\t\t\t// Equal chip.\r\n\t\t\thost_el.appendChild(\r\n\t\t\t\tUI.WPBC_BFB_Layout_Chips._make_chip( builder, section_el, Array( cols ).fill( 1 ), 'Equal' )\r\n\t\t\t);\r\n\r\n\t\t\t// Presets based on column count.\r\n\t\t\tconst presets = builder.layout.build_presets_for_columns( cols );\r\n\t\t\tpresets.forEach( (weights) => {\r\n\t\t\t\thost_el.appendChild(\r\n\t\t\t\t\tUI.WPBC_BFB_Layout_Chips._make_chip( builder, section_el, weights, null )\r\n\t\t\t\t);\r\n\t\t\t} );\r\n\r\n\t\t\t// Custom chip.\r\n\t\t\tconst customBtn       = document.createElement( 'button' );\r\n\t\t\tcustomBtn.type        = 'button';\r\n\t\t\tcustomBtn.className   = 'wpbc_bfb__layout_chip';\r\n\t\t\tcustomBtn.textContent = 'Custom…';\r\n\t\t\tcustomBtn.title       = `Enter ${cols} percentages`;\r\n\t\t\tcustomBtn.addEventListener( 'click', () => {\r\n\t\t\t\tconst example = (cols === 2) ? '50,50' : (cols === 3 ? '20,60,20' : '25,25,25,25');\r\n\t\t\t\tconst text    = prompt( `Enter ${cols} percentages (comma or space separated):`, example );\r\n\t\t\t\tif ( text == null ) return;\r\n\t\t\t\tconst weights = builder.layout.parse_weights( text );\r\n\t\t\t\tif ( weights.length !== cols ) {\r\n\t\t\t\t\talert( `Please enter exactly ${cols} numbers.` );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\t// OLD:\r\n\t\t\t\t// builder.layout.apply_layout_preset( section_el, weights, builder.col_gap_percent );\r\n\t\t\t\t// Guarded apply:.\r\n\t\t\t\tif ( !UI.WPBC_BFB_Layout_Chips._apply_preset_with_min_guard( builder, section_el, weights ) ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\thost_el.querySelectorAll( '.wpbc_bfb__layout_chip' ).forEach( c => c.classList.remove( 'is-active' ) );\r\n\t\t\t\tcustomBtn.classList.add( 'is-active' );\r\n\t\t\t} );\r\n\t\t\thost_el.appendChild( customBtn );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Create a single layout chip button.\r\n\t\t *\r\n\t\t * @private\r\n\t\t * @param {WPBC_Form_Builder} builder\r\n\t\t * @param {HTMLElement} section_el\r\n\t\t * @param {number[]} weights\r\n\t\t * @param {string|null} label\r\n\t\t * @returns {HTMLButtonElement}\r\n\t\t */\r\n\t\tstatic _make_chip(builder, section_el, weights, label = null) {\r\n\r\n\t\t\tconst btn     = document.createElement( 'button' );\r\n\t\t\tbtn.type      = 'button';\r\n\t\t\tbtn.className = 'wpbc_bfb__layout_chip';\r\n\r\n\t\t\tconst title = label || builder.layout.format_preset_label( weights );\r\n\t\t\tbtn.title   = title;\r\n\r\n\t\t\t// Visual miniature.\r\n\t\t\tconst vis     = document.createElement( 'div' );\r\n\t\t\tvis.className = 'wpbc_bfb__layout_chip-vis';\r\n\t\t\tconst sum     = weights.reduce( (a, b) => a + (Number( b ) || 0), 0 ) || 1;\r\n\t\t\tweights.forEach( (w) => {\r\n\t\t\t\tconst bar      = document.createElement( 'span' );\r\n\t\t\t\tbar.style.flex = `0 0 calc( ${((Number( w ) || 0) / sum * 100).toFixed( 3 )}% - 1.5px )`;\r\n\t\t\t\tvis.appendChild( bar );\r\n\t\t\t} );\r\n\t\t\tbtn.appendChild( vis );\r\n\r\n\t\t\tconst txt       = document.createElement( 'span' );\r\n\t\t\ttxt.className   = 'wpbc_bfb__layout_chip-label';\r\n\t\t\ttxt.textContent = label || builder.layout.format_preset_label( weights );\r\n\t\t\tbtn.appendChild( txt );\r\n\r\n\t\t\tbtn.addEventListener( 'click', () => {\r\n\t\t\t\t// OLD:\r\n\t\t\t\t// builder.layout.apply_layout_preset( section_el, weights, builder.col_gap_percent );\r\n\r\n\t\t\t\t// NEW:\r\n\t\t\t\tif ( !UI.WPBC_BFB_Layout_Chips._apply_preset_with_min_guard( builder, section_el, weights ) ) {\r\n\t\t\t\t\treturn; // do not toggle active if we didn't change layout\r\n\t\t\t\t}\r\n\r\n\t\t\t\tbtn.parentElement?.querySelectorAll( '.wpbc_bfb__layout_chip' ).forEach( c => c.classList.remove( 'is-active' ) );\r\n\t\t\t\tbtn.classList.add( 'is-active' );\r\n\t\t\t} );\r\n\r\n\t\t\treturn btn;\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Selection controller for fields and announcements.\r\n\t */\r\n\tUI.WPBC_BFB_Selection_Controller = class extends UI.WPBC_BFB_Module {\r\n\r\n\t\tinit() {\r\n\r\n\t\t\tthis._selected_uid              = null;\r\n\t\t\tthis.builder.select_field       = this.select_field.bind( this );\r\n\t\t\tthis.builder.get_selected_field = this.get_selected_field.bind( this );\n\t\t\tthis._on_clear                  = this.on_clear.bind( this );\n\t\t\tthis._on_panel_shown            = this._sync_settings_button_states.bind( this );\n\r\n\t\t\t// Centralized delete command used by keyboard + inspector + overlay.\r\n\t\t\tthis.builder.delete_item = (el) => {\r\n\t\t\t\tif ( !el ) {\r\n\t\t\t\t\treturn null;\r\n\t\t\t\t}\r\n\t\t\t\tconst b        = this.builder;\r\n\t\t\t\tconst neighbor = b._find_neighbor_selectable?.( el ) || null;\r\n\t\t\t\tel.remove();\r\n\t\t\t\t// Use local Core constants (not a global) to avoid ReferenceErrors.\r\n\t\t\t\tb.bus?.emit?.( Core.WPBC_BFB_Events.FIELD_REMOVE, { el, id: el?.dataset?.id, uid: el?.dataset?.uid } );\r\n\t\t\t\tb.usage?.update_palette_ui?.();\r\n\t\t\t\t// Notify generic structure listeners, too:\r\n\t\t\t\tb.bus?.emit?.( Core.WPBC_BFB_Events.STRUCTURE_CHANGE, { reason: 'delete', el } );\r\n\t\t\t\t// Defer selection a tick so the DOM is fully settled before Inspector hydrates.\r\n\t\t\t\trequestAnimationFrame( () => {\r\n\t\t\t\t\t// This calls inspector.bind_to_field() and opens the Inspector panel.\r\n\t\t\t\t\tb.select_field?.( neighbor || null, { scrollIntoView: !!neighbor } );\r\n\t\t\t\t} );\r\n\t\t\t\treturn neighbor;\r\n\t\t\t};\r\n\t\t\tthis.builder.bus.on( Core.WPBC_BFB_Events.CLEAR_SELECTION, this._on_clear );\r\n\t\t\tthis.builder.bus.on( Core.WPBC_BFB_Events.STRUCTURE_LOADED, this._on_clear );\r\n\t\t\t// delegated click selection (capture ensures we win before bubbling to containers).\r\n\t\t\tthis._on_canvas_click = this._handle_canvas_click.bind( this );\n\t\t\tthis.builder.pages_container.addEventListener( 'click', this._on_canvas_click, true );\n\t\t\tdocument.addEventListener( 'wpbc_bfb:panel_shown', this._on_panel_shown );\n\t\t\tthis._sync_settings_button_states();\n\t\t}\n\r\n\t\tdestroy() {\r\n\t\t\tthis.builder.bus.off( Core.WPBC_BFB_Events.CLEAR_SELECTION, this._on_clear );\r\n\r\n\t\t\tif ( this._on_canvas_click ) {\n\t\t\t\tthis.builder.pages_container.removeEventListener( 'click', this._on_canvas_click, true );\n\t\t\t\tthis._on_canvas_click = null;\n\t\t\t}\n\n\t\t\tif ( this._on_panel_shown ) {\n\t\t\t\tdocument.removeEventListener( 'wpbc_bfb:panel_shown', this._on_panel_shown );\n\t\t\t\tthis._on_panel_shown = null;\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Refresh overlay button state after selection or right-bar panel changes.\n\t\t *\n\t\t * @returns {void}\n\t\t */\n\t\t_sync_settings_button_states() {\n\t\t\tUI.WPBC_BFB_Overlay.sync_settings_button_states( this.builder );\n\t\t}\n\r\n\t\t/**\r\n\t\t * Delegated canvas click -> select closest field/section (inner beats outer).\r\n\t\t * @private\r\n\t\t * @param {MouseEvent} e\r\n\t\t */\r\n\t\t_handle_canvas_click(e) {\r\n\t\t\tconst root = this.builder.pages_container;\r\n\t\t\tif ( !root ) return;\r\n\r\n\t\t\t// Ignore clicks on controls/handles/resizers, etc.\r\n\t\t\tconst IGNORE = [\r\n\t\t\t\t'.wpbc_bfb__overlay-controls',\r\n\t\t\t\t'.wpbc_bfb__layout_picker',\r\n\t\t\t\t'.wpbc_bfb__drag-handle',\r\n\t\t\t\t'.wpbc_bfb__field-remove-btn',\r\n\t\t\t\t'.wpbc_bfb__field-move-up',\r\n\t\t\t\t'.wpbc_bfb__field-move-down',\r\n\t\t\t\t'.wpbc_bfb__column-resizer'\r\n\t\t\t].join( ',' );\r\n\r\n\t\t\tif ( e.target.closest( IGNORE ) ) {\r\n\t\t\t\treturn; // let those controls do their own thing.\r\n\t\t\t}\r\n\r\n\t\t\t// Find the closest selectable (field OR section) from the click target.\r\n\t\t\tlet hit = e.target.closest?.(\r\n\t\t\t\t`${Core.WPBC_BFB_DOM.SELECTORS.validField}, ${Core.WPBC_BFB_DOM.SELECTORS.section}, .wpbc_bfb__column`\r\n\t\t\t);\r\n\r\n\t\t\tif ( !hit || !root.contains( hit ) ) {\r\n\t\t\t\tthis.select_field( null );           // Clear selection on blank click.\r\n\t\t\t\treturn;                              // Empty space is handled elsewhere.\r\n\t\t\t}\r\n\r\n\t\t\t// NEW: if user clicked a COLUMN -> remember tab key on its SECTION, but still select the section.\r\n\t\t\tlet preselect_tab_key = null;\r\n\t\t\tif ( hit.classList.contains( 'wpbc_bfb__column' ) ) {\r\n\t\t\t\tconst row  = hit.closest( '.wpbc_bfb__row' );\r\n\t\t\t\tconst cols = row ? Array.from( row.querySelectorAll( ':scope > .wpbc_bfb__column' ) ) : [];\r\n\t\t\t\tconst idx  = Math.max( 0, cols.indexOf( hit ) );\r\n\t\t\t\tconst sec  = hit.closest( '.wpbc_bfb__section' );\r\n\t\t\t\tif ( sec ) {\r\n\t\t\t\t\tpreselect_tab_key = String( idx + 1 );              // tabs are 1-based in ui-column-styles.js\r\n\t\t\t\t\t// Hint for the renderer (it reads this BEFORE rendering and restores the tab).\r\n\t\t\t\t\tsec.dataset.col_styles_active_tab = preselect_tab_key;\r\n\t\t\t\t\t// promote selection to the section (same UX as before).\r\n\t\t\t\t\thit                               = sec;\r\n\t\t\t\t\t// NEW: visually mark which column is being edited\r\n\t\t\t\t\tif ( UI && UI.WPBC_BFB_Column_Styles && UI.WPBC_BFB_Column_Styles.set_selected_col_flag ) {\r\n\t\t\t\t\t\tUI.WPBC_BFB_Column_Styles.set_selected_col_flag( sec, preselect_tab_key );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// Select and stop bubbling so outer containers don’t reselect a parent.\r\n\t\t\tthis.select_field( hit );\r\n\t\t\te.stopPropagation();\r\n\r\n\t\t\t// Also set the tab after the inspector renders (works even if it was already open).\r\n\t\t\tif ( preselect_tab_key ) {\r\n\t\t\t\t(window.requestAnimationFrame || setTimeout)( function () {\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tconst ins  = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\t\t\t\tconst tabs = ins && ins.querySelector( '[data-bfb-slot=\"column_styles\"] [data-wpbc-tabs]' );\r\n\t\t\t\t\t\tif ( tabs && window.wpbc_ui_tabs && typeof window.wpbc_ui_tabs.set_active === 'function' ) {\r\n\t\t\t\t\t\t\twindow.wpbc_ui_tabs.set_active( tabs, preselect_tab_key );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t\t}\r\n\t\t\t\t}, 0 );\r\n\r\n\t\t\t\t// Politely ask the Inspector to focus/open the \"Column Styles\" group and tab.\r\n\t\t\t\twpbc_bfb__dispatch_event_safe(\r\n\t\t\t\t\t'wpbc_bfb:inspector_focus',\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tgroup  : 'column_styles',\r\n\t\t\t\t\t\ttab_key: preselect_tab_key\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Select a field element or clear selection.\r\n\t\t *\r\n\t\t * @param {HTMLElement|null} field_el\r\n\t\t * @param {{scrollIntoView?: boolean}} [opts = {}]\r\n\t\t */\r\n\t\tselect_field(field_el, { scrollIntoView = false } = {}) {\r\n\t\t\tconst root   = this.builder.pages_container;\r\n\t\t\tconst prevEl = this.get_selected_field?.() || null;   // the one we’re leaving.\r\n\r\n\t\t\t// Ignore elements not in the canvas.\r\n\t\t\tif ( field_el && !root.contains( field_el ) ) {\r\n\t\t\t\tfield_el = null; // treat as \"no selection\".\r\n\t\t\t}\r\n\r\n\t\t\t// NEW: if we are leaving a section, clear its column highlight\r\n\t\t\tif (\r\n\t\t\t\tprevEl && prevEl !== field_el &&\r\n\t\t\t\tprevEl.classList?.contains( 'wpbc_bfb__section' ) &&\r\n\t\t\t\tUI?.WPBC_BFB_Column_Styles?.clear_selected_col_flag\r\n\t\t\t) {\r\n\t\t\t\tUI.WPBC_BFB_Column_Styles.clear_selected_col_flag( prevEl );\r\n\t\t\t}\r\n\r\n\t\t\t// If we're leaving a field, permanently stop auto-name for it.\r\n\t\t\tif ( prevEl && prevEl !== field_el && prevEl.classList?.contains( 'wpbc_bfb__field' ) ) {\r\n\t\t\t\tprevEl.dataset.autoname = '0';\r\n\t\t\t\tprevEl.dataset.fresh    = '0';\r\n\t\t\t}\r\n\r\n\t\t\troot.querySelectorAll( '.is-selected' ).forEach( (n) => {\r\n\t\t\t\tn.classList.remove( 'is-selected' );\r\n\t\t\t} );\r\n\t\t\tif ( !field_el ) {\r\n\t\t\t\tconst prev         = this._selected_uid || null;\r\n\t\t\t\tthis._selected_uid = null;\r\n\t\t\t\tthis.builder.inspector?.clear?.();\r\n\t\t\t\troot.classList.remove( 'has-selection' );\r\n\t\t\t\tthis.builder.bus.emit( Core.WPBC_BFB_Events.CLEAR_SELECTION, { prev_uid: prev, source: 'builder' } );\r\n\r\n\t\t\t\t// Auto-open \"Add Fields\" when nothing is selected.\r\n\t\t\t\twpbc_bfb__dispatch_event_safe(\n\t\t\t\t\t'wpbc_bfb:show_panel',\n\t\t\t\t\t{\r\n\t\t\t\t\t\tpanel_id: 'wpbc_bfb__palette_add_new',\r\n\t\t\t\t\t\ttab_id  : 'wpbc_tab_library'\r\n\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t\tthis._sync_settings_button_states();\n\n\t\t\t\treturn;\n\t\t\t}\r\n\t\t\tfield_el.classList.add( 'is-selected' );\r\n\t\t\tthis._selected_uid = field_el.getAttribute( 'data-uid' ) || null;\r\n\r\n\t\t\t// Fallback: ensure sections announce themselves as type=\"section\".\r\n\t\t\tif ( field_el.classList.contains( 'wpbc_bfb__section' ) && !field_el.dataset.type ) {\r\n\t\t\t\tfield_el.dataset.type = 'section';\r\n\t\t\t}\r\n\r\n\t\t\tif ( scrollIntoView ) {\r\n\t\t\t\tfield_el.scrollIntoView( { behavior: 'smooth', block: 'center' } );\r\n\t\t\t}\r\n\t\t\tthis.builder.inspector?.bind_to_field?.( field_el );\r\n\r\n\t\t\t// Fallback: ensure inspector enhancers (incl. ValueSlider) run every bind.\r\n\t\t\ttry {\r\n\t\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' )\r\n\t\t\t\t\t|| document.querySelector( '.wpbc_bfb__inspector' );\r\n\t\t\t\tif ( ins ) {\r\n\t\t\t\t\tUI.InspectorEnhancers?.scan?.( ins );              // runs all enhancers\r\n\t\t\t\t\tUI.WPBC_BFB_ValueSlider?.init_on?.( ins );         // extra belt-and-suspenders\r\n\t\t\t\t}\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t}\r\n\r\n\t\t\t// NEW: when selecting a section, reflect its active tab as the highlighted column.\r\n\t\t\tif ( field_el.classList.contains( 'wpbc_bfb__section' ) &&\r\n\t\t\t\tUI?.WPBC_BFB_Column_Styles?.set_selected_col_flag ) {\r\n\t\t\t\tvar k = (field_el.dataset && field_el.dataset.col_styles_active_tab)\r\n\t\t\t\t\t? field_el.dataset.col_styles_active_tab : '1';\r\n\t\t\t\tUI.WPBC_BFB_Column_Styles.set_selected_col_flag( field_el, k );\r\n\t\t\t}\r\n\r\n\t\t\t// Keep sections & fields in the same flow:\r\n\t\t\t// 1) Generic hydrator for simple dataset-backed controls.\r\n\t\t\tif ( field_el ) {\r\n\t\t\t\tUI.WPBC_BFB_Inspector_Bridge._generic_hydrate_controls?.( this.builder, field_el );\r\n\t\t\t\tUI.WPBC_BFB_Inspector_Bridge._hydrate_special_controls?.( this.builder, field_el );\r\n\t\t\t}\r\n\r\n\t\t\t// Auto-open Inspector when a user selects a field/section .\r\n\t\t\twpbc_bfb__dispatch_event_safe(\n\t\t\t\t'wpbc_bfb:show_panel',\n\t\t\t\t{\r\n\t\t\t\t\tpanel_id: 'wpbc_bfb__inspector',\r\n\t\t\t\t\ttab_id  : 'wpbc_tab_inspector'\r\n\t\t\t\t}\n\t\t\t);\n\t\t\tthis._sync_settings_button_states();\n\n\t\t\troot.classList.add( 'has-selection' );\n\t\t\tthis.builder.bus.emit( Core.WPBC_BFB_Events.SELECT, { uid: this._selected_uid, el: field_el } );\r\n\t\t\tconst label = field_el?.querySelector( '.wpbc_bfb__field-label' )?.textContent || (field_el.classList.contains( 'wpbc_bfb__section' ) ? 'section' : '') || field_el?.dataset?.id || 'item';\r\n\t\t\tthis.builder._announce( 'Selected ' + label + '.' );\r\n\t\t}\r\n\r\n\t\t/** @returns {HTMLElement|null} */\r\n\t\tget_selected_field() {\r\n\t\t\tif ( !this._selected_uid ) {\r\n\t\t\t\treturn null;\r\n\t\t\t}\r\n\t\t\tconst esc_attr = Core.WPBC_BFB_Sanitize.esc_attr_value_for_selector( this._selected_uid );\r\n\t\t\treturn this.builder.pages_container.querySelector( `.wpbc_bfb__field[data-uid=\"${esc_attr}\"], .wpbc_bfb__section[data-uid=\"${esc_attr}\"]` );\r\n\t\t}\r\n\r\n\t\t/** @param {CustomEvent} ev */\r\n\t\ton_clear(ev) {\r\n\t\t\tconst src = ev?.detail?.source ?? ev?.source;\r\n\t\t\tif ( src !== 'builder' ) {\r\n\t\t\t\tthis.select_field( null );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t};\r\n\r\n\t/**\r\n\t * Bridges the builder with the Inspector and sanitizes id/name edits.\r\n\t */\r\n\tUI.WPBC_BFB_Inspector_Bridge = class extends UI.WPBC_BFB_Module {\r\n\r\n\t\tinit() {\r\n\t\t\tthis._attach_inspector();\r\n\t\t\tthis._bind_id_sanitizer();\r\n\t\t\tthis._open_inspector_after_field_added();\r\n\t\t\tthis._bind_focus_shortcuts();\r\n\t\t}\r\n\r\n\t\t_attach_inspector() {\r\n\t\t\tconst b      = this.builder;\r\n\t\t\tconst attach = () => {\r\n\t\t\t\tif ( typeof window.WPBC_BFB_Inspector === 'function' ) {\r\n\t\t\t\t\tb.inspector = new WPBC_BFB_Inspector( document.getElementById( 'wpbc_bfb__inspector' ), b );\r\n\t\t\t\t\tthis._bind_id_sanitizer();\r\n\t\t\t\t\tdocument.removeEventListener( 'wpbc_bfb_inspector_ready', attach );\r\n\t\t\t\t}\r\n\t\t\t};\r\n\t\t\t// Ensure we bind after late ready as well.\r\n\t\t\tif ( typeof window.WPBC_BFB_Inspector === 'function' ) {\r\n\t\t\t\tattach();\r\n\t\t\t} else {\r\n\t\t\t\tb.inspector = {\r\n\t\t\t\t\tbind_to_field() {\r\n\t\t\t\t\t}, clear() {\r\n\t\t\t\t\t}\r\n\t\t\t\t};\r\n\t\t\t\tdocument.addEventListener( 'wpbc_bfb_inspector_ready', attach );\r\n\t\t\t\tsetTimeout( attach, 0 );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Listen for \"focus\" hints from the canvas and open the right group/tab.\r\n\t\t * - Supports: group === 'column_styles'\r\n\t\t * - Also scrolls the group into view.\r\n\t\t */\r\n\t\t_bind_focus_shortcuts() {\r\n\t\t\t/** @param {CustomEvent} e */\r\n\t\t\tconst on_focus = (e) => {\r\n\t\t\t\ttry {\r\n\t\t\t\t\tconst grp_key = e && e.detail && e.detail.group;\r\n\t\t\t\t\tconst tab_key = e && e.detail && e.detail.tab_key;\r\n\t\t\t\t\tif ( !grp_key ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' ) || document.querySelector( '.wpbc_bfb__inspector' );\r\n\t\t\t\t\tif ( !ins ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif ( grp_key === 'column_styles' ) {\r\n\t\t\t\t\t\t// Find the Column Styles slot/group.\r\n\t\t\t\t\t\tconst slot = ins.querySelector( '[data-bfb-slot=\"column_styles\"]' ) || ins.querySelector( '[data-inspector-group-key=\"column_styles\"]' );\r\n\t\t\t\t\t\tif ( slot ) {\r\n\t\t\t\t\t\t\t// Open collapsible container if present.\r\n\t\t\t\t\t\t\tconst group_wrap = slot.closest( '.inspector__group' ) || slot.closest( '[data-inspector-group]' );\r\n\t\t\t\t\t\t\tif ( group_wrap && !group_wrap.classList.contains( 'is-open' ) ) {\r\n\t\t\t\t\t\t\t\tgroup_wrap.classList.add( 'is-open' );\r\n\t\t\t\t\t\t\t\t// Mirror ARIA state if your header uses aria-expanded.\r\n\t\t\t\t\t\t\t\tconst header_btn = group_wrap.querySelector( '[aria-expanded]' );\r\n\t\t\t\t\t\t\t\tif ( header_btn ) {\r\n\t\t\t\t\t\t\t\t\theader_btn.setAttribute( 'aria-expanded', 'true' );\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t// Optional: set the requested tab key if tabs exist in this group.\r\n\t\t\t\t\t\t\tif ( tab_key ) {\r\n\t\t\t\t\t\t\t\tconst tabs = slot.querySelector( '[data-wpbc-tabs]' );\r\n\t\t\t\t\t\t\t\tif ( tabs && window.wpbc_ui_tabs && typeof window.wpbc_ui_tabs.set_active === 'function' ) {\r\n\t\t\t\t\t\t\t\t\twindow.wpbc_ui_tabs.set_active( tabs, String( tab_key ) );\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t// Bring into view for convenience.\r\n\t\t\t\t\t\t\ttry {\r\n\t\t\t\t\t\t\t\t// Uncomment (Only  if needed) this to AUTO SCROLL to  specific COLUMN in the section:.\r\n\t\t\t\t\t\t\t\t// slot.scrollIntoView( { behavior: 'smooth', block: 'nearest' } );\r\n\t\t\t\t\t\t\t} catch ( _e ) {}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t} catch ( _e ) {}\r\n\t\t\t};\r\n\r\n\t\t\tthis._on_inspector_focus = on_focus;\r\n\t\t\tdocument.addEventListener( 'wpbc_bfb:inspector_focus', on_focus, true );\r\n\t\t}\r\n\r\n\t\tdestroy() {\r\n\t\t\ttry {\r\n\t\t\t\tif ( this._on_inspector_focus ) {\r\n\t\t\t\t\tdocument.removeEventListener( 'wpbc_bfb:inspector_focus', this._on_inspector_focus, true );\r\n\t\t\t\t\tthis._on_inspector_focus = null;\r\n\t\t\t\t}\r\n\t\t\t} catch ( _e ) {\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Hydrate inspector inputs for \"special\" keys that we handle explicitly.\r\n\t\t * Works for both fields and sections.\r\n\t\t * @param {WPBC_Form_Builder} builder\r\n\t\t * @param {HTMLElement} sel\r\n\t\t */\r\n\t\tstatic _hydrate_special_controls(builder, sel) {\r\n\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\tif ( !ins || !sel ) return;\r\n\r\n\t\t\tconst setVal = (key, val) => {\r\n\t\t\t\tconst ctrl = ins.querySelector( `[data-inspector-key=\"${key}\"]` );\r\n\t\t\t\tif ( ctrl && 'value' in ctrl ) ctrl.value = String( val ?? '' );\r\n\t\t\t};\r\n\r\n\t\t\t// Internal id / name / public html_id.\r\n\t\t\tsetVal( 'id', sel.getAttribute( 'data-id' ) || '' );\r\n\t\t\tsetVal( 'name', sel.getAttribute( 'data-name' ) || '' );\r\n\t\t\tsetVal( 'html_id', sel.getAttribute( 'data-html_id' ) || '' );\r\n\r\n\t\t\t// Section-only extras are harmless to set for fields (controls may not exist).\r\n\t\t\tsetVal( 'cssclass', sel.getAttribute( 'data-cssclass' ) || '' );\r\n\t\t\tsetVal( 'label', sel.getAttribute( 'data-label' ) || '' );\r\n\t\t}\r\n\r\n\r\n\t\t/**\r\n\t\t * Hydrate inspector inputs that declare a generic dataset mapping via\r\n\t\t * [data-inspector-key] but do NOT declare a custom value_from adapter.\r\n\t\t * This makes sections follow the same data flow as fields with almost no glue.\r\n\t\t *\r\n\t\t * @param {WPBC_Form_Builder} builder\r\n\t\t * @param {HTMLElement} sel - currently selected field/section\r\n\t\t */\r\n\t\tstatic _generic_hydrate_controls(builder, sel) {\r\n\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\tif ( !ins || !sel ) return;\r\n\r\n\t\t\tconst SKIP = /^(id|name|html_id|cssclass|label)$/; // handled by _hydrate_special_controls\r\n\r\n\t\t\t// NEW: read schema for the selected element’s type.\r\n\t\t\tconst schemas     = window.WPBC_BFB_Schemas || {};\r\n\t\t\tconst typeKey     = (sel.dataset && sel.dataset.type) || '';\r\n\t\t\tconst schemaEntry = schemas[typeKey] || null;\r\n\t\t\tconst propsSchema = (schemaEntry && schemaEntry.schema && schemaEntry.schema.props) ? schemaEntry.schema.props : {};\r\n\t\t\tconst hasOwn      = Function.prototype.call.bind( Object.prototype.hasOwnProperty );\r\n\t\t\tconst getDefault  = (key) => {\r\n\t\t\t\tconst meta = propsSchema[key];\r\n\t\t\t\treturn (meta && hasOwn( meta, 'default' )) ? meta.default : undefined;\r\n\t\t\t};\r\n\r\n\t\t\tins.querySelectorAll( '[data-inspector-key]' ).forEach( (ctrl) => {\r\n\t\t\t\tconst key = String( ctrl.dataset?.inspectorKey || '' ).toLowerCase();\r\n\t\t\t\tif ( !key || SKIP.test( key ) ) return;\r\n\r\n\t\t\t\t// Element-level lock.\r\n\t\t\t\tconst dl = (ctrl.dataset?.locked || '').trim().toLowerCase();\r\n\t\t\t\tif ( dl === '1' || dl === 'true' || dl === 'yes' ) return;\r\n\r\n\t\t\t\t// Respect explicit adapters.\r\n\t\t\t\tif ( ctrl.dataset?.value_from || ctrl.dataset?.valueFrom ) return;\r\n\r\n\t\t\t\tconst raw      = sel.dataset ? sel.dataset[key] : undefined;\r\n\t\t\t\tconst hasRaw   = sel.dataset ? hasOwn( sel.dataset, key ) : false;\r\n\t\t\t\tconst defValue = getDefault( key );\r\n\r\n\t\t\t\t// Best-effort control typing with schema default fallback when value is absent.\r\n\r\n\t\t\t\tif ( ctrl instanceof HTMLInputElement && (ctrl.type === 'checkbox' || ctrl.type === 'radio') ) {\r\n\t\t\t\t\t// If dataset is missing the key entirely -> use schema default (boolean).\r\n\t\t\t\t\tif ( !hasRaw ) {\r\n\t\t\t\t\t\tctrl.checked = !!defValue;\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t// An explicit empty value is the legacy persisted representation of false.\r\n\t\t\t\t\t\tctrl.checked = Core.WPBC_BFB_Sanitize.coerce_boolean( raw, false );\r\n\t\t\t\t\t}\r\n\t\t\t\t} else if ( 'value' in ctrl ) {\r\n\t\t\t\t\tif ( hasRaw ) {\r\n\t\t\t\t\t\tctrl.value = (raw != null) ? String( raw ) : '';\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tctrl.value = (defValue == null) ? '' : String( defValue );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t_bind_id_sanitizer() {\r\n\t\t\tconst b   = this.builder;\r\n\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\tif ( ! ins ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tif ( ins.__wpbc_bfb_id_sanitizer_bound ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tins.__wpbc_bfb_id_sanitizer_bound = true;\r\n\r\n\t\t\tconst handler = (e) => {\r\n\r\n\t\t\t\tconst t = e.target;\r\n\t\t\t\tif ( !t || !('value' in t) ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tconst key       = (t.dataset?.inspectorKey || '').toLowerCase();\r\n\t\t\t\tconst sel       = b.get_selected_field?.();\r\n\t\t\t\tconst isSection = sel?.classList?.contains( 'wpbc_bfb__section' );\r\n\t\t\t\tif ( !sel ) return;\r\n\r\n\t\t\t\t// Unified emitter that always includes the element reference.\r\n\t\t\t\tconst EV              = Core.WPBC_BFB_Events;\r\n\t\t\t\t// STRUCTURE_CHANGE can be \"expensive\" because other listeners may trigger full canvas refresh.\r\n\t\t\t\t// Debounce only continuous controls (e.g. value slider scrubbing) on the INPUT phase.\r\n\t\t\t\tconst ensure_sc_debounce_state = () => {\r\n\t\t\t\t\tif ( b.__wpbc_bfb_sc_debounce_state ) {\r\n\t\t\t\t\t\treturn b.__wpbc_bfb_sc_debounce_state;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tb.__wpbc_bfb_sc_debounce_state = { timer_id: 0, pending_payload: null };\r\n\t\t\t\t\treturn b.__wpbc_bfb_sc_debounce_state;\r\n\t\t\t\t};\r\n\r\n\t\t\t\tconst cancel_sc_debounced_emit = () => {\r\n\t\t\t\t\tconst st = b.__wpbc_bfb_sc_debounce_state;\r\n\t\t\t\t\tif ( !st ) return;\r\n\t\t\t\t\ttry { clearTimeout( st.timer_id ); } catch ( _ ) {}\r\n\t\t\t\t\tst.timer_id        = 0;\r\n\t\t\t\t\tst.pending_payload = null;\r\n\t\t\t\t};\r\n\r\n\t\t\t\tconst bus_emit_change = (reason, extra = {}) => {\r\n\t\t\t\t\t// If we’re committing something (change/blur/etc), drop any pending \"input\" emit.\r\n\t\t\t\t\tcancel_sc_debounced_emit();\r\n\t\t\t\t\tb.bus?.emit?.( EV.STRUCTURE_CHANGE, { reason, el: sel, ...extra } );\r\n\t\t\t\t};\r\n\r\n\t\t\t\tconst bus_emit_change_debounced = (reason, extra = {}, wait_ms) => {\r\n\t\t\t\t\tconst st = ensure_sc_debounce_state();\r\n\t\t\t\t\tconst ms = Number.isFinite( wait_ms )\r\n\t\t\t\t\t\t? wait_ms\r\n\t\t\t\t\t\t: (Number.isFinite( UI.STRUCTURE_CHANGE_DEBOUNCE_MS ) ? UI.STRUCTURE_CHANGE_DEBOUNCE_MS : 240);\r\n\r\n\t\t\t\t\t// Capture the CURRENT selected element into the payload now (stable ref).\r\n\t\t\t\t\tst.pending_payload = { reason, el: sel, ...extra, debounced: true };\r\n\r\n\t\t\t\t\ttry { clearTimeout( st.timer_id ); } catch ( _ ) {}\r\n\t\t\t\t\tst.timer_id = setTimeout( function () {\r\n\t\t\t\t\t\tst.timer_id = 0;\r\n\t\t\t\t\t\tconst payload = st.pending_payload;\r\n\t\t\t\t\t\tst.pending_payload = null;\r\n\t\t\t\t\t\tif ( payload ) {\r\n\t\t\t\t\t\t\tb.bus?.emit?.( EV.STRUCTURE_CHANGE, payload );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}, ms );\r\n\t\t\t\t};\r\n\r\n\t\t\t\t// ---- FIELD/SECTION: internal id ----\r\n\t\t\t\tif ( key === 'id' ) {\r\n\t\t\t\t\tconst unique = b.id.set_field_id( sel, t.value );\r\n\t\t\t\t\tif ( b.preview_mode && !isSection ) {\r\n\t\t\t\t\t\tb.render_preview( sel );\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( t.value !== unique ) {\r\n\t\t\t\t\t\tt.value = unique;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbus_emit_change( 'id-change' );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// ---- FIELD/SECTION: public HTML id ----\r\n\t\t\t\tif ( key === 'html_id' ) {\r\n\t\t\t\t\tconst applied = b.id.set_field_html_id( sel, t.value );\r\n\t\t\t\t\t// For sections, also set the real DOM id so anchors/CSS can target it.\r\n\t\t\t\t\tif ( isSection ) {\r\n\t\t\t\t\t\tsel.id = applied || '';\r\n\t\t\t\t\t} else if ( b.preview_mode ) {\r\n\t\t\t\t\t\tb.render_preview( sel );\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( t.value !== applied ) {\r\n\t\t\t\t\t\tt.value = applied;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbus_emit_change( 'html-id-change' );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// ---- FIELDS ONLY: name ----\r\n\t\t\t\tif ( key === 'name' && !isSection ) {\r\n\r\n\t\t\t\t\t// Live typing: sanitize only (NO uniqueness yet) to avoid \"-2\" spam\r\n\t\t\t\t\tif ( e.type === 'input' ) {\r\n\t\t\t\t\t\tconst before    = t.value;\r\n\t\t\t\t\t\tconst sanitized = Core.WPBC_BFB_Sanitize.sanitize_html_name( before );\r\n\t\t\t\t\t\tif ( before !== sanitized ) {\r\n\t\t\t\t\t\t\t// optional: preserve caret to avoid jump\r\n\t\t\t\t\t\t\tconst selStart = t.selectionStart, selEnd = t.selectionEnd;\r\n\t\t\t\t\t\t\tt.value        = sanitized;\r\n\t\t\t\t\t\t\ttry {\r\n\t\t\t\t\t\t\t\tt.setSelectionRange( selStart, selEnd );\r\n\t\t\t\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn; // uniqueness on change/blur\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Commit (change/blur)\r\n\t\t\t\t\tconst raw = String( t.value ?? '' ).trim();\r\n\r\n\t\t\t\t\tif ( !raw ) {\r\n\t\t\t\t\t\t// RESEED: keep name non-empty and provisional (autoname stays ON)\r\n\t\t\t\t\t\tconst S    = Core.WPBC_BFB_Sanitize;\r\n\t\t\t\t\t\tconst base = S.sanitize_html_name( sel.getAttribute( 'data-id' ) || sel.dataset.id || sel.dataset.type || 'field' );\r\n\t\t\t\t\t\tconst uniq = b.id.ensure_unique_field_name( base, sel );\r\n\r\n\t\t\t\t\t\tsel.setAttribute( 'data-name', uniq );\r\n\t\t\t\t\t\tsel.dataset.autoname          = '1';\r\n\t\t\t\t\t\tsel.dataset.name_user_touched = '0';\r\n\r\n\t\t\t\t\t\t// Keep DOM in sync if we’re not re-rendering\r\n\t\t\t\t\t\tif ( !b.preview_mode ) {\r\n\t\t\t\t\t\t\tconst ctrl = sel.querySelector( 'input,textarea,select' );\r\n\t\t\t\t\t\t\tif ( ctrl ) ctrl.setAttribute( 'name', uniq );\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tb.render_preview( sel );\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif ( t.value !== uniq ) t.value = uniq;\r\n\t\t\t\t\t\tbus_emit_change( 'name-reseed' );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Non-empty commit: user takes control; disable autoname going forward\r\n\t\t\t\t\tsel.dataset.name_user_touched = '1';\r\n\t\t\t\t\tsel.dataset.autoname          = '0';\r\n\r\n\t\t\t\t\tconst sanitized = Core.WPBC_BFB_Sanitize.sanitize_html_name( raw );\r\n\t\t\t\t\tconst unique    = b.id.set_field_name( sel, sanitized );\r\n\r\n\t\t\t\t\tif ( !b.preview_mode ) {\r\n\t\t\t\t\t\tconst ctrl = sel.querySelector( 'input,textarea,select' );\r\n\t\t\t\t\t\tif ( ctrl ) ctrl.setAttribute( 'name', unique );\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tb.render_preview( sel );\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif ( t.value !== unique ) t.value = unique;\r\n\t\t\t\t\tbus_emit_change( 'name-change' );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// ---- SECTIONS & FIELDS: cssclass (live apply; no re-render) ----\r\n\t\t\t\tif ( key === 'cssclass' ) {\r\n\t\t\t\t\tconst next       = Core.WPBC_BFB_Sanitize.sanitize_css_classlist( t.value || '' );\r\n\t\t\t\t\tconst desiredArr = next.split( /\\s+/ ).filter( Boolean );\r\n\t\t\t\t\tconst desiredSet = new Set( desiredArr );\r\n\r\n\t\t\t\t\t// Core classes are never touched.\r\n\t\t\t\t\tconst isCore = (cls) => cls === 'is-selected' || cls.startsWith( 'wpbc_' );\r\n\r\n\t\t\t\t\t// Snapshot before mutating (DOMTokenList is live).\r\n\t\t\t\t\tconst beforeClasses = Array.from( sel.classList );\r\n\t\t\t\t\tconst customBefore  = beforeClasses.filter( (c) => !isCore( c ) );\r\n\r\n\t\t\t\t\t// Remove stray non-core classes not in desired.\r\n\t\t\t\t\tcustomBefore.forEach( (c) => {\r\n\t\t\t\t\t\tif ( !desiredSet.has( c ) ) sel.classList.remove( c );\r\n\t\t\t\t\t} );\r\n\r\n\t\t\t\t\t// Add missing desired classes in one go.\r\n\t\t\t\t\tconst missing = desiredArr.filter( (c) => !customBefore.includes( c ) );\r\n\t\t\t\t\tif ( missing.length ) sel.classList.add( ...missing );\r\n\r\n\t\t\t\t\t// Keep dataset in sync (avoid useless attribute writes).\r\n\t\t\t\t\tif ( sel.getAttribute( 'data-cssclass' ) !== next ) {\r\n\t\t\t\t\t\tsel.setAttribute( 'data-cssclass', next );\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Emit only if something actually changed.\r\n\t\t\t\t\tconst afterClasses = Array.from( sel.classList );\r\n\t\t\t\t\tconst changed      = afterClasses.length !== beforeClasses.length || beforeClasses.some( (c, i) => c !== afterClasses[i] );\r\n\r\n\t\t\t\t\tconst detail = { key: 'cssclass', phase: e.type };\r\n\t\t\t\t\tif ( isSection ) {\r\n\t\t\t\t\t\tbus_emit_change( 'cssclass-change', detail );\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tbus_emit_change( 'prop-change', detail );\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\r\n\t\t\t\t// ---- SECTIONS: label ----\r\n\t\t\t\tif ( isSection && key === 'label' ) {\r\n\t\t\t\t\tconst val = String( t.value ?? '' );\r\n\t\t\t\t\tsel.setAttribute( 'data-label', val );\r\n\t\t\t\t\tbus_emit_change( 'label-change' );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// ---- FIELDS: label (auto-name while typing; freeze on commit) ----\r\n\t\t\t\tif ( !isSection && key === 'label' ) {\r\n\t\t\t\t\tconst val         = String( t.value ?? '' );\r\n\t\t\t\t\tsel.dataset.label = val;\r\n\r\n\t\t\t\t\t// while typing, allow auto-name (if flags permit)\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tCore.WPBC_BFB_Field_Base.maybe_autoname_from_label( b, sel, val );\r\n\t\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// if user committed the label (blur/change), freeze future auto-name\r\n\t\t\t\t\tif ( e.type !== 'input' ) {\r\n\t\t\t\t\t\tsel.dataset.autoname = '0';   // stop future label->name sync\r\n\t\t\t\t\t\tsel.dataset.fresh    = '0';   // also kill the \"fresh\" escape hatch\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Optional UI nicety: disable Name when auto is ON, enable when OFF\r\n\t\t\t\t\tconst ins      = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\t\t\tconst nameCtrl = ins?.querySelector( '[data-inspector-key=\"name\"]' );\r\n\t\t\t\t\tif ( nameCtrl ) {\r\n\t\t\t\t\t\tconst autoActive =\r\n\t\t\t\t\t\t\t\t  (sel.dataset.autoname ?? '1') !== '0' &&\r\n\t\t\t\t\t\t\t\t  sel.dataset.name_user_touched !== '1' &&\r\n\t\t\t\t\t\t\t\t  sel.dataset.was_loaded !== '1';\r\n\t\t\t\t\t\tnameCtrl.toggleAttribute( 'disabled', autoActive );\r\n\t\t\t\t\t\tif ( autoActive && !nameCtrl.placeholder ) {\r\n\t\t\t\t\t\t\tnameCtrl.placeholder = b?.i18n?.auto_from_label ?? 'auto — from label';\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif ( !autoActive && nameCtrl.placeholder === (b?.i18n?.auto_from_label ?? 'auto — from label') ) {\r\n\t\t\t\t\t\t\tnameCtrl.placeholder = '';\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Always re-render the preview so label changes are visible immediately.\r\n\t\t\t\t\tb.render_preview( sel );\r\n\t\t\t\t\tbus_emit_change( 'label-change' );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\r\n\t\t\t\t// ---- DEFAULT (GENERIC): dataset writer for both fields & sections ----\r\n\t\t\t\t// Any inspector control with [data-inspector-key] that doesn't have a custom\r\n\t\t\t\t// adapter/value_from will simply read/write sel.dataset[key].\r\n\t\t\t\tif ( key ) {\r\n\r\n\t\t\t\t\tconst selfLocked = /^(1|true|yes)$/i.test( (t.dataset?.locked || '').trim() );\r\n\t\t\t\t\tif ( selfLocked ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Skip keys we handled above to avoid double work.\r\n\t\t\t\t\tif ( key === 'id' || key === 'name' || key === 'html_id' || key === 'cssclass' || key === 'label' ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tlet nextVal = '';\r\n\t\t\t\t\tif ( t instanceof HTMLInputElement && (t.type === 'checkbox' || t.type === 'radio') ) {\r\n\t\t\t\t\t\t// Persist both boolean states explicitly so schema defaults cannot replace false.\r\n\t\t\t\t\t\tnextVal = t.checked ? 'true' : 'false';\r\n\t\t\t\t\t} else if ( 'value' in t ) {\r\n\t\t\t\t\t\tnextVal = String( t.value ?? '' );\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// Persist to dataset.\r\n\t\t\t\t\tif ( sel?.dataset ) sel.dataset[key] = nextVal;\r\n\r\n\t\t\t\t\t// Generator controls are \"UI inputs\" — avoid STRUCTURE_CHANGE spam while dragging/typing.\r\n\t\t\t\t\tconst is_gen_key = (key.indexOf( 'gen_' ) === 0);\r\n\r\n\t\t\t\t\t// Re-render on visual keys so preview stays in sync (calendar label/help, etc.).\r\n\t\t\t\t\tconst visualKeys = new Set( [ 'help', 'placeholder', 'min_width', 'cssclass' ] );\r\n\t\t\t\t\tif ( !isSection && (visualKeys.has( key ) || key.startsWith( 'ui_' )) ) {\r\n\t\t\t\t\t\t// Light heuristic: only re-render on commit for heavy inputs; live for short ones is fine.\r\n\t\t\t\t\t\tif ( e.type === 'change' || key === 'help' || key === 'placeholder' ) {\r\n\t\t\t\t\t\t\tb.render_preview( sel );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif ( !(is_gen_key && e.type === 'input') ) {\r\n\t\t\t\t\t\t// Debounce continuous value slider input events to avoid full-canvas refresh spam.\r\n\t\t\t\t\t\t// We detect the slider group via [data-len-group] wrapper.\r\n\t\t\t\t\t\tconst is_len_group_ctrl = !!(t && t.closest && t.closest( '[data-len-group]' ));\r\n\r\n\t\t\t\t\t\tif ( is_len_group_ctrl && e.type === 'input' ) {\r\n\t\t\t\t\t\t\tbus_emit_change_debounced( 'prop-change', { key, phase: e.type } );\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tbus_emit_change( 'prop-change', { key, phase: e.type } );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t};\r\n\r\n\t\t\tins.addEventListener( 'change', handler, true );\r\n\t\t\t// reflect instantly while typing as well.\r\n\t\t\tins.addEventListener( 'input', handler, true );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Open Inspector after a field is added.\r\n\t\t * @private\r\n\t\t */\r\n\t\t_open_inspector_after_field_added() {\r\n\t\t\tconst EV = Core.WPBC_BFB_Events;\r\n\t\t\tthis.builder?.bus?.on?.( EV.FIELD_ADD, (e) => {\r\n\t\t\t\tconst el = e?.detail?.el || null;\r\n\t\t\t\tif ( el && this.builder?.select_field ) {\r\n\t\t\t\t\tthis.builder.select_field( el, { scrollIntoView: true } );\r\n\t\t\t\t}\r\n\t\t\t\t// Show Inspector Palette.\r\n\t\t\t\twpbc_bfb__dispatch_event_safe(\r\n\t\t\t\t\t'wpbc_bfb:show_panel',\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tpanel_id: 'wpbc_bfb__inspector',\r\n\t\t\t\t\t\ttab_id  : 'wpbc_tab_inspector'\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t} );\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Keyboard shortcuts for selection, deletion, and movement.\r\n\t */\r\n\tUI.WPBC_BFB_Keyboard_Controller = class extends UI.WPBC_BFB_Module {\r\n\t\tinit() {\r\n\t\t\tthis._on_key = this.on_key.bind( this );\r\n\t\t\tdocument.addEventListener( 'keydown', this._on_key, true );\r\n\t\t}\r\n\r\n\t\tdestroy() {\r\n\t\t\tdocument.removeEventListener( 'keydown', this._on_key, true );\r\n\t\t}\r\n\r\n\t\t/** @param {KeyboardEvent} e */\r\n\t\ton_key(e) {\r\n\t\t\tconst b         = this.builder;\r\n\t\t\tconst is_typing = this._is_typing_anywhere();\r\n\t\t\tif ( e.key === 'Escape' ) {\r\n\t\t\t\tif ( is_typing ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tthis.builder.bus.emit( Core.WPBC_BFB_Events.CLEAR_SELECTION, { source: 'esc' } );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tconst selected = b.get_selected_field?.();\r\n\t\t\tif ( !selected || is_typing ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tif ( e.key === 'Delete' || e.key === 'Backspace' ) {\r\n\t\t\t\te.preventDefault();\r\n\t\t\t\tb.delete_item?.( selected );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tif ( (e.altKey || e.ctrlKey || e.metaKey) && (e.key === 'ArrowUp' || e.key === 'ArrowDown') && !e.shiftKey ) {\r\n\t\t\t\te.preventDefault();\r\n\t\t\t\tconst dir = (e.key === 'ArrowUp') ? 'up' : 'down';\r\n\t\t\t\tb.move_item?.( selected, dir );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tif ( e.key === 'Enter' ) {\r\n\t\t\t\te.preventDefault();\r\n\t\t\t\tb.select_field( selected, { scrollIntoView: true } );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/** @returns {boolean} */\r\n\t\t_is_typing_anywhere() {\r\n\t\t\tconst a   = document.activeElement;\r\n\t\t\tconst tag = a?.tagName;\r\n\t\t\tif ( tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || (a?.isContentEditable === true) ) {\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\treturn !!(ins && a && ins.contains( a ));\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Column resize logic for section rows.\r\n\t */\r\n\tUI.WPBC_BFB_Resize_Controller = class extends UI.WPBC_BFB_Module {\r\n\t\tinit() {\r\n\t\t\tthis.builder.init_resize_handler = this.handle_resize.bind( this );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * read the CSS var (kept local so it doesn’t depend on the Min-Width module)\r\n\t\t *\r\n\t\t * @param col\r\n\t\t * @returns {number|number}\r\n\t\t * @private\r\n\t\t */\r\n\t\t_get_col_min_px(col) {\r\n\t\t\tconst v = getComputedStyle( col ).getPropertyValue( '--wpbc-col-min' ) || '0';\r\n\t\t\tconst n = parseFloat( v );\r\n\t\t\treturn Number.isFinite( n ) ? Math.max( 0, n ) : 0;\r\n\t\t}\r\n\r\n\t\t/** @param {MouseEvent} e */\r\n\t\thandle_resize(e) {\r\n\t\t\tconst b = this.builder;\r\n\t\t\te.preventDefault();\r\n\t\t\tif ( e.button !== 0 ) return;\r\n\r\n\t\t\tconst resizer   = e.currentTarget;\r\n\t\t\tconst row_el    = resizer.parentElement;\r\n\t\t\tconst cols      = Array.from( row_el.querySelectorAll( ':scope > .wpbc_bfb__column' ) );\r\n\t\t\tconst left_col  = resizer?.previousElementSibling;\r\n\t\t\tconst right_col = resizer?.nextElementSibling;\r\n\t\t\tif ( !left_col || !right_col || !left_col.classList.contains( 'wpbc_bfb__column' ) || !right_col.classList.contains( 'wpbc_bfb__column' ) ) return;\r\n\r\n\t\t\tconst left_index  = cols.indexOf( left_col );\r\n\t\t\tconst right_index = cols.indexOf( right_col );\r\n\t\t\tif ( left_index === -1 || right_index !== left_index + 1 ) return;\r\n\r\n\t\t\tconst start_x        = e.clientX;\r\n\t\t\tconst left_start_px  = left_col.getBoundingClientRect().width;\r\n\t\t\tconst right_start_px = right_col.getBoundingClientRect().width;\r\n\t\t\tconst pair_px        = Math.max( 0, left_start_px + right_start_px );\r\n\r\n\t\t\tconst gp         = b.col_gap_percent;\r\n\t\t\tconst computed   = b.layout.compute_effective_bases_from_row( row_el, gp );\r\n\t\t\tconst available  = computed.available;                 // % of the “full 100” after gaps\r\n\t\t\tconst bases      = computed.bases.slice( 0 );            // current effective %\r\n\t\t\tconst pair_avail = bases[left_index] + bases[right_index];\r\n\r\n\t\t\t// Bail if we can’t compute sane deltas.\r\n\t\t\tif (!pair_px || !Number.isFinite(pair_avail) || pair_avail <= 0) return;\r\n\r\n\t\t\t// --- MIN CLAMPS (pixels) -------------------------------------------------\r\n\t\t\tconst pctToPx       = (pct) => (pair_px * (pct / pair_avail)); // pair-local percent -> px\r\n\t\t\tconst genericMinPct = Math.min( 0.1, available );                  // original 0.1% floor (in “available %” space)\r\n\t\t\tconst genericMinPx  = pctToPx( genericMinPct );\r\n\r\n\t\t\tconst leftMinPx  = Math.max( this._get_col_min_px( left_col ), genericMinPx );\r\n\t\t\tconst rightMinPx = Math.max( this._get_col_min_px( right_col ), genericMinPx );\r\n\r\n\t\t\t// freeze text selection + cursor\r\n\t\t\tconst prev_user_select         = document.body.style.userSelect;\r\n\t\t\tdocument.body.style.userSelect = 'none';\r\n\t\t\trow_el.style.cursor            = 'col-resize';\r\n\r\n\t\t\tconst on_mouse_move = (ev) => {\r\n\t\t\t\tif ( !pair_px ) return;\r\n\r\n\t\t\t\t// work in pixels, clamp by each side’s min\r\n\t\t\t\tconst delta_px   = ev.clientX - start_x;\r\n\t\t\t\tlet newLeftPx    = left_start_px + delta_px;\r\n\t\t\t\tnewLeftPx        = Math.max( leftMinPx, Math.min( pair_px - rightMinPx, newLeftPx ) );\r\n\t\t\t\tconst newRightPx = pair_px - newLeftPx;\r\n\r\n\t\t\t\t// translate back to pair-local percentages\r\n\t\t\t\tconst newLeftPct      = (newLeftPx / pair_px) * pair_avail;\r\n\t\t\t\tconst newBases        = bases.slice( 0 );\r\n\t\t\t\tnewBases[left_index]  = newLeftPct;\r\n\t\t\t\tnewBases[right_index] = pair_avail - newLeftPct;\r\n\r\n\t\t\t\tb.layout.apply_bases_to_row( row_el, newBases );\r\n\t\t\t};\r\n\r\n\t\t\tconst on_mouse_up = () => {\r\n\t\t\t\tdocument.removeEventListener( 'mousemove', on_mouse_move );\r\n\t\t\t\tdocument.removeEventListener( 'mouseup', on_mouse_up );\r\n\t\t\t\twindow.removeEventListener( 'mouseup', on_mouse_up );\r\n\t\t\t\tdocument.removeEventListener( 'mouseleave', on_mouse_up );\r\n\t\t\t\tdocument.body.style.userSelect = prev_user_select || '';\r\n\t\t\t\trow_el.style.cursor            = '';\r\n\r\n\t\t\t\t// normalize to the row’s available % again\r\n\t\t\t\tconst normalized = b.layout.compute_effective_bases_from_row( row_el, gp );\r\n\t\t\t\tb.layout.apply_bases_to_row( row_el, normalized.bases );\r\n\t\t\t};\r\n\r\n\t\t\tdocument.addEventListener( 'mousemove', on_mouse_move );\r\n\t\t\tdocument.addEventListener( 'mouseup', on_mouse_up );\r\n\t\t\twindow.addEventListener( 'mouseup', on_mouse_up );\r\n\t\t\tdocument.addEventListener( 'mouseleave', on_mouse_up );\r\n\t\t}\r\n\r\n\t};\r\n\r\n\t/**\r\n\t * Page and section creation, rebuilding, and nested Sortable setup.\r\n\t */\r\n\tUI.WPBC_BFB_Pages_Sections = class extends UI.WPBC_BFB_Module {\r\n\r\n\t\tinit() {\r\n\t\t\tthis.builder.add_page                  = (opts) => this.add_page( opts );\r\n\t\t\tthis.builder.add_section               = (container, cols) => this.add_section( container, cols );\r\n\t\t\tthis.builder.rebuild_section           = (section_data, container) => this.rebuild_section( section_data, container );\r\n\t\t\tthis.builder.init_all_nested_sortables = (el) => this.init_all_nested_sortables( el );\r\n\t\t\tthis.builder.init_section_sortable     = (el) => this.init_section_sortable( el );\r\n\t\t\tthis.builder.pages_sections            = this;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Give every field/section in a cloned subtree a fresh data-uid so\r\n\t\t * uniqueness checks don't exclude their originals.\r\n\t\t */\r\n\t\t_retag_uids_in_subtree(root) {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tif ( !root ) return;\r\n\t\t\tconst nodes = [];\r\n\t\t\tif ( root.classList?.contains( 'wpbc_bfb__section' ) || root.classList?.contains( 'wpbc_bfb__field' ) ) {\r\n\t\t\t\tnodes.push( root );\r\n\t\t\t}\r\n\t\t\tnodes.push( ...root.querySelectorAll( '.wpbc_bfb__section, .wpbc_bfb__field' ) );\r\n\t\t\tnodes.forEach( (el) => {\r\n\t\t\t\tconst prefix   = el.classList.contains( 'wpbc_bfb__section' ) ? 's' : 'f';\r\n\t\t\t\tel.dataset.uid = `${prefix}-${++b._uid_counter}-${Date.now()}-${Math.random().toString( 36 ).slice( 2, 7 )}`;\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Bump \"foo\", \"foo-2\", \"foo-3\", ...\r\n\t\t */\r\n\t\t_make_unique(base, taken) {\r\n\t\t\tconst s = Core.WPBC_BFB_Sanitize;\r\n\t\t\tlet v   = String( base || '' );\r\n\t\t\tif ( !v ) v = 'field';\r\n\t\t\tconst m  = v.match( /-(\\d+)$/ );\r\n\t\t\tlet n    = m ? (parseInt( m[1], 10 ) || 1) : 1;\r\n\t\t\tlet stem = m ? v.replace( /-\\d+$/, '' ) : v;\r\n\t\t\twhile ( taken.has( v ) ) {\r\n\t\t\t\tn = Math.max( 2, n + 1 );\r\n\t\t\t\tv = `${stem}-${n}`;\r\n\t\t\t}\r\n\t\t\ttaken.add( v );\r\n\t\t\treturn v;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Strict, one-pass de-duplication for a newly-inserted subtree.\r\n\t\t * - Ensures unique data-id (internal), data-name (fields), data-html_id (public)\r\n\t\t * - Also updates DOM: <section id>, <input id>, <label for>, and input[name].\r\n\t\t */\r\n\t\t_dedupe_subtree_strict(root) {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tconst s = Core.WPBC_BFB_Sanitize;\r\n\t\t\tif ( !root || !b?.pages_container ) return;\r\n\r\n\t\t\t// 1) Build \"taken\" sets from outside the subtree.\r\n\t\t\tconst takenDataId   = new Set();\r\n\t\t\tconst takenDataName = new Set();\r\n\t\t\tconst takenHtmlId   = new Set();\r\n\t\t\tconst takenDomId    = new Set();\r\n\r\n\t\t\t// All fields/sections outside root\r\n\t\t\tb.pages_container.querySelectorAll( '.wpbc_bfb__field, .wpbc_bfb__section' ).forEach( el => {\r\n\t\t\t\tif ( root.contains( el ) ) return;\r\n\t\t\t\tconst did  = el.getAttribute( 'data-id' );\r\n\t\t\t\tconst dnam = el.getAttribute( 'data-name' );\r\n\t\t\t\tconst hid  = el.getAttribute( 'data-html_id' );\r\n\t\t\t\tif ( did ) takenDataId.add( did );\r\n\t\t\t\tif ( dnam ) takenDataName.add( dnam );\r\n\t\t\t\tif ( hid ) takenHtmlId.add( hid );\r\n\t\t\t} );\r\n\r\n\t\t\t// All DOM ids outside root (labels, inputs, anything)\r\n\t\t\tdocument.querySelectorAll( '[id]' ).forEach( el => {\r\n\t\t\t\tif ( root.contains( el ) ) return;\r\n\t\t\t\tif ( el.id ) takenDomId.add( el.id );\r\n\t\t\t} );\r\n\r\n\t\t\tconst nodes = [];\r\n\t\t\tif ( root.classList?.contains( 'wpbc_bfb__section' ) || root.classList?.contains( 'wpbc_bfb__field' ) ) {\r\n\t\t\t\tnodes.push( root );\r\n\t\t\t}\r\n\t\t\tnodes.push( ...root.querySelectorAll( '.wpbc_bfb__section, .wpbc_bfb__field' ) );\r\n\r\n\t\t\t// 2) Walk the subtree and fix collisions deterministically.\r\n\t\t\tnodes.forEach( el => {\r\n\t\t\t\tconst isField   = el.classList.contains( 'wpbc_bfb__field' );\r\n\t\t\t\tconst isSection = el.classList.contains( 'wpbc_bfb__section' );\r\n\r\n\t\t\t\t// INTERNAL data-id\r\n\t\t\t\t{\r\n\t\t\t\t\tconst raw  = el.getAttribute( 'data-id' ) || '';\r\n\t\t\t\t\tconst base = s.sanitize_html_id( raw ) || (isSection ? 'section' : 'field');\r\n\t\t\t\t\tconst uniq = this._make_unique( base, takenDataId );\r\n\t\t\t\t\tif ( uniq !== raw ) el.setAttribute( 'data-id', uniq );\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// HTML name (fields only)\r\n\t\t\t\tif ( isField ) {\r\n\t\t\t\t\tconst raw = el.getAttribute( 'data-name' ) || '';\r\n\t\t\t\t\tif ( raw ) {\r\n\t\t\t\t\t\tconst base = s.sanitize_html_name( raw );\r\n\t\t\t\t\t\tconst uniq = this._make_unique( base, takenDataName );\r\n\t\t\t\t\t\tif ( uniq !== raw ) {\r\n\t\t\t\t\t\t\tel.setAttribute( 'data-name', uniq );\r\n\t\t\t\t\t\t\t// Update inner control immediately\r\n\t\t\t\t\t\t\tconst input = el.querySelector( 'input, textarea, select' );\r\n\t\t\t\t\t\t\tif ( input ) input.setAttribute( 'name', uniq );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Public HTML id (fields + sections)\r\n\t\t\t\t{\r\n\t\t\t\t\tconst raw = el.getAttribute( 'data-html_id' ) || '';\r\n\t\t\t\t\tif ( raw ) {\r\n\t\t\t\t\t\tconst base          = s.sanitize_html_id( raw );\r\n\t\t\t\t\t\t// Reserve against BOTH known data-html_id and real DOM ids.\r\n\t\t\t\t\t\tconst combinedTaken = new Set( [ ...takenHtmlId, ...takenDomId ] );\r\n\t\t\t\t\t\tlet candidate       = this._make_unique( base, combinedTaken );\r\n\t\t\t\t\t\t// Record into the real sets so future checks see the reservation.\r\n\t\t\t\t\t\ttakenHtmlId.add( candidate );\r\n\t\t\t\t\t\ttakenDomId.add( candidate );\r\n\r\n\t\t\t\t\t\tif ( candidate !== raw ) el.setAttribute( 'data-html_id', candidate );\r\n\r\n\t\t\t\t\t\t// Reflect to DOM immediately\r\n\t\t\t\t\t\tif ( isSection ) {\r\n\t\t\t\t\t\t\tel.id = candidate || '';\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tconst input = el.querySelector( 'input, textarea, select' );\r\n\t\t\t\t\t\t\tconst label = el.querySelector( 'label.wpbc_bfb__field-label' );\r\n\t\t\t\t\t\t\tif ( input ) input.id = candidate || '';\r\n\t\t\t\t\t\t\tif ( label ) label.htmlFor = candidate || '';\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else if ( isSection ) {\r\n\t\t\t\t\t\t// Ensure no stale DOM id if data-html_id was cleared\r\n\t\t\t\t\t\tel.removeAttribute( 'id' );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t_make_add_columns_control(page_el, section_container, insert_pos = 'bottom') {\r\n\r\n\t\t\t// Accept insert_pos ('top'|'bottom'), default 'bottom'.\r\n\r\n\t\t\tconst tpl = document.getElementById( 'wpbc_bfb__add_columns_template' );\r\n\t\t\tif ( !tpl ) {\r\n\t\t\t\treturn null;\r\n\t\t\t}\r\n\r\n\t\t\t// Clone *contents* (not the id), unhide, and add a page-scoped class.\r\n\t\t\tconst src = (tpl.content && tpl.content.firstElementChild) ? tpl.content.firstElementChild : tpl.firstElementChild;\r\n\t\t\tif ( !src ) {\r\n\t\t\t\treturn null;\r\n\t\t\t}\r\n\r\n\t\t\tconst clone = src.cloneNode( true );\r\n\t\t\tclone.removeAttribute( 'hidden' );\r\n\t\t\tif ( clone.id ) {\r\n\t\t\t\tclone.removeAttribute( 'id' );\r\n\t\t\t}\r\n\t\t\tclone.querySelectorAll( '[id]' ).forEach( n => n.removeAttribute( 'id' ) );\r\n\r\n\t\t\t// Mark where this control inserts sections.\r\n\t\t\tclone.dataset.insert = insert_pos; // 'top' | 'bottom'\r\n\r\n\t\t\t// // Optional UI hint for users (keeps existing markup intact).\r\n\t\t\t// const hint = clone.querySelector( '.nav-tab-text .selected_value' );\r\n\t\t\t// if ( hint ) {\r\n\t\t\t// \thint.textContent = (insert_pos === 'top') ? ' (add at top)' : ' (add at bottom)';\r\n\t\t\t// }\r\n\r\n\t\t\t// Click on options - add section with N columns.\r\n\t\t\tclone.addEventListener( 'click', (e) => {\r\n\t\t\t\tconst a = e.target.closest( '.ul_dropdown_menu_li_action_add_sections' );\r\n\t\t\t\tif ( !a ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\te.preventDefault();\r\n\r\n\t\t\t\t// Read N either from data-cols or fallback to parsing text like \"3 Columns\".\r\n\t\t\t\tlet cols = parseInt( a.dataset.cols || (a.textContent.match( /\\b(\\d+)\\s*Column/i )?.[1] ?? '1'), 10 );\r\n\t\t\t\tcols     = Math.max( 1, Math.min( 4, cols ) );\r\n\r\n\t\t\t\t// NEW: honor the control's insertion position\r\n\t\t\t\tthis.add_section( section_container, cols, insert_pos );\r\n\r\n\t\t\t\t// Reflect last choice (unchanged)\r\n\t\t\t\tconst val = clone.querySelector( '.selected_value' );\r\n\t\t\t\tif ( val ) {\r\n\t\t\t\t\tval.textContent = ` (${cols})`;\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\r\n\t\t\treturn clone;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * @param {{scroll?: boolean}} [opts = {}]\r\n\t\t * @returns {HTMLElement}\r\n\t\t */\r\n\t\tadd_page({ scroll = true } = {}) {\r\n\t\t\tconst b       = this.builder;\r\n\t\t\tconst page_el = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__panel wpbc_bfb__panel--preview  wpbc_bfb_form wpbc_container wpbc_form wpbc_container_booking_form' );\r\n\t\t\tpage_el.setAttribute( 'data-page', ++b.page_counter );\r\n\r\n\t\t\t// \"Page 1 | X\" - Render page Title with Remove X button.\r\n\t\t\tconst controls_html = UI.render_wp_template( 'wpbc-bfb-tpl-page-remove', { page_number: b.page_counter } );\r\n\t\t\tpage_el.innerHTML   = controls_html + '<div class=\"wpbc_bfb__form_preview_section_container wpbc_wizard__border_container\"></div>';\r\n\r\n\t\t\tb.pages_container.appendChild( page_el );\r\n\t\t\tif ( scroll ) {\r\n\t\t\t\tpage_el.scrollIntoView( { behavior: 'smooth', block: 'start' } );\r\n\t\t\t}\r\n\r\n\t\t\tconst section_container         = page_el.querySelector( '.wpbc_bfb__form_preview_section_container' );\r\n\t\t\tconst section_count_on_add_page = 2;\r\n\t\t\tthis.init_section_sortable( section_container );\r\n\t\t\tthis.add_section( section_container, section_count_on_add_page );\r\n\r\n\t\t\t// Dropdown control cloned from the hidden template.\r\n\t\t\tconst controls_host_top = page_el.querySelector( '.wpbc_bfb__controls' );\r\n\t\t\tconst ctrl_top          = this._make_add_columns_control( page_el, section_container, 'top' );\r\n\t\t\tif ( ctrl_top ) {\r\n\t\t\t\tcontrols_host_top.appendChild( ctrl_top );\r\n\t\t\t}\r\n\t\t\t// Bottom control bar after the section container.\r\n\t\t\tconst controls_host_bottom = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__controls wpbc_bfb__controls--bottom' );\r\n\t\t\tsection_container.after( controls_host_bottom );\r\n\t\t\tconst ctrl_bottom = this._make_add_columns_control( page_el, section_container, 'bottom' );\r\n\t\t\tif ( ctrl_bottom ) {\r\n\t\t\t\tcontrols_host_bottom.appendChild( ctrl_bottom );\r\n\t\t\t}\r\n\r\n\t\t\treturn page_el;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * @param {HTMLElement} container\r\n\t\t * @param {number}      cols\r\n\t\t * @param {'top'|'bottom'} [insert_pos='bottom']  // NEW\r\n\t\t */\r\n\t\tadd_section(container, cols, insert_pos = 'bottom') {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tcols    = Math.max( 1, parseInt( cols, 10 ) || 1 );\r\n\r\n\t\t\tconst section = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__section' );\r\n\t\t\tsection.setAttribute( 'data-id', `section-${++b.section_counter}-${Date.now()}` );\r\n\t\t\tsection.setAttribute( 'data-uid', `s-${++b._uid_counter}-${Date.now()}-${Math.random().toString( 36 ).slice( 2, 7 )}` );\r\n\t\t\tsection.setAttribute( 'data-type', 'section' );\r\n\t\t\tsection.setAttribute( 'data-label', 'Section' );\r\n\t\t\tsection.setAttribute( 'data-columns', String( cols ) );\r\n\t\t\t// Do not persist or seed per-column styles by default (opt-in via inspector).\r\n\r\n\t\t\tconst row = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__row wpbc__row' );\r\n\t\t\tfor ( let i = 0; i < cols; i++ ) {\r\n\t\t\t\tconst col           = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__column wpbc__field' );\r\n\t\t\t\tcol.style.flexBasis = (100 / cols) + '%';\r\n\t\t\t\t// No default CSS vars here; real columns remain unaffected until user activates styles.\r\n\t\t\t\tb.init_sortable?.( col );\r\n\t\t\t\trow.appendChild( col );\r\n\t\t\t\tif ( i < cols - 1 ) {\r\n\t\t\t\t\tconst resizer = Core.WPBC_Form_Builder_Helper.create_element( 'div', 'wpbc_bfb__column-resizer' );\r\n\t\t\t\t\tresizer.addEventListener( 'mousedown', b.init_resize_handler );\r\n\t\t\t\t\trow.appendChild( resizer );\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tsection.appendChild( row );\r\n\t\t\tb.layout.set_equal_bases( row, b.col_gap_percent );\r\n\t\t\tb.add_overlay_toolbar( section );\r\n\t\t\tsection.setAttribute( 'tabindex', '0' );\r\n\t\t\tthis.init_all_nested_sortables( section );\r\n\r\n\t\t\t// Insertion policy: top | bottom.\r\n\t\t\tif ( insert_pos === 'top' && container.firstElementChild ) {\r\n\t\t\t\tcontainer.insertBefore( section, container.firstElementChild );\r\n\t\t\t} else {\r\n\t\t\t\tcontainer.appendChild( section );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * @param {Object} section_data\r\n\t\t * @param {HTMLElement} container\r\n\t\t * @returns {HTMLElement} The rebuilt section element.\r\n\t\t */\r\n\t\trebuild_section(section_data, container) {\r\n\t\t\tconst b         = this.builder;\r\n\t\t\tconst cols_data = Array.isArray( section_data?.columns ) ? section_data.columns : [];\r\n\t\t\tthis.add_section( container, cols_data.length || 1 );\r\n\t\t\tconst section = container.lastElementChild;\r\n\t\t\tif ( !section.dataset.uid ) {\r\n\t\t\t\tsection.setAttribute( 'data-uid', `s-${++b._uid_counter}-${Date.now()}-${Math.random().toString( 36 ).slice( 2, 7 )}` );\r\n\t\t\t}\r\n\t\t\tsection.setAttribute( 'data-id', section_data?.id || `section-${++b.section_counter}-${Date.now()}` );\r\n\t\t\tsection.setAttribute( 'data-type', 'section' );\r\n\t\t\tsection.setAttribute( 'data-label', section_data?.label || 'Section' );\r\n\t\t\tsection.setAttribute( 'data-columns', String( (section_data?.columns || []).length || 1 ) );\r\n\t\t\t// Persisted attributes\r\n\t\t\tif ( section_data?.html_id ) {\r\n\t\t\t\tsection.setAttribute( 'data-html_id', String( section_data.html_id ) );\r\n\t\t\t\t// give the container a real id so anchors/CSS can target it\r\n\t\t\t\tsection.id = String( section_data.html_id );\r\n\t\t\t}\r\n\r\n\t\t\t// NEW: restore persisted per-column styles (raw JSON string).\r\n\t\t\tif ( section_data?.col_styles != null ) {\r\n\t\t\t\tconst json = String( section_data.col_styles );\r\n\t\t\t\tsection.setAttribute( 'data-col_styles', json );\r\n\t\t\t\ttry {\r\n\t\t\t\t\tsection.dataset.col_styles = json;\r\n\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// (No render_preview() call here on purpose: sections’ builder DOM uses .wpbc_bfb__row/.wpbc_bfb__column.)\r\n\r\n\r\n\t\t\tif ( section_data?.cssclass ) {\r\n\t\t\t\tsection.setAttribute( 'data-cssclass', String( section_data.cssclass ) );\r\n\t\t\t\t// keep core classes, then add custom class(es)\r\n\t\t\t\tString( section_data.cssclass ).split( /\\s+/ ).filter( Boolean ).forEach( cls => section.classList.add( cls ) );\r\n\t\t\t}\r\n\r\n\t\t\tconst row = section.querySelector( '.wpbc_bfb__row' );\r\n\t\t\t// Delegate parsing + activation + application to the Column Styles service.\r\n\t\t\ttry {\r\n\t\t\t\tconst json = section.getAttribute( 'data-col_styles' )\r\n\t\t\t\t\t|| (section.dataset ? (section.dataset.col_styles || '') : '');\r\n\t\t\t\tconst arr  = UI.WPBC_BFB_Column_Styles.parse_col_styles( json );\r\n\t\t\t\tUI.WPBC_BFB_Column_Styles.apply( section, arr );\r\n\t\t\t} catch ( _e ) {\r\n\t\t\t}\r\n\r\n\t\t\tcols_data.forEach( (col_data, index) => {\r\n\t\t\t\tconst columns_only  = row.querySelectorAll( ':scope > .wpbc_bfb__column' );\r\n\t\t\t\tconst col           = columns_only[index];\r\n\t\t\t\tcol.style.flexBasis = col_data.width || '100%';\r\n\t\t\t\t(col_data.items || []).forEach( (item) => {\r\n\t\t\t\t\tif ( !item || !item.type ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( item.type === 'field' ) {\r\n\t\t\t\t\t\tconst el = b.build_field( item.data );\r\n\t\t\t\t\t\tif ( el ) {\r\n\t\t\t\t\t\t\tcol.appendChild( el );\r\n\t\t\t\t\t\t\tb.trigger_field_drop_callback( el, 'load' );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( item.type === 'section' ) {\r\n\t\t\t\t\t\tthis.rebuild_section( item.data, col );\r\n\t\t\t\t\t}\r\n\t\t\t\t} );\r\n\t\t\t} );\r\n\t\t\tconst computed = b.layout.compute_effective_bases_from_row( row, b.col_gap_percent );\r\n\t\t\tb.layout.apply_bases_to_row( row, computed.bases );\r\n\t\t\tthis.init_all_nested_sortables( section );\r\n\r\n\t\t\t// NEW: retag UIDs first (so uniqueness checks don't exclude originals), then dedupe all keys.\r\n\t\t\tthis._retag_uids_in_subtree( section );\r\n\t\t\tthis._dedupe_subtree_strict( section );\r\n\t\t\treturn section;\r\n\t\t}\r\n\r\n\t\t/** @param {HTMLElement} container */\r\n\t\tinit_all_nested_sortables(container) {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tif ( container.classList.contains( 'wpbc_bfb__form_preview_section_container' ) ) {\r\n\t\t\t\tthis.init_section_sortable( container );\r\n\t\t\t}\r\n\t\t\tcontainer.querySelectorAll( '.wpbc_bfb__section' ).forEach( (section) => {\r\n\t\t\t\tsection.querySelectorAll( '.wpbc_bfb__column' ).forEach( (col) => {\r\n\t\t\t\t\tthis.init_section_sortable( col );\r\n\t\t\t\t} );\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t/** @param {HTMLElement} container */\r\n\t\tinit_section_sortable(container) {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tif ( !container ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tconst is_column    = container.classList.contains( 'wpbc_bfb__column' );\r\n\t\t\tconst is_top_level = container.classList.contains( 'wpbc_bfb__form_preview_section_container' );\r\n\t\t\tif ( !is_column && !is_top_level ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tb.init_sortable?.( container );\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Serialization and deserialization of pages/sections/fields.\r\n\t */\r\n\tUI.WPBC_BFB_Structure_IO = class extends UI.WPBC_BFB_Module {\r\n\t\tinit() {\r\n\t\t\tthis.builder.get_structure        = () => this.serialize();\r\n\t\t\tthis.builder.load_saved_structure = (s, opts) => this.deserialize( s, opts );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Normalize option values when a field explicitly disables separate values.\r\n\t\t *\r\n\t\t * Older Builder versions persisted an unchecked value_differs toggle as an\r\n\t\t * empty string. Treat that explicit legacy value as false, while retaining\r\n\t\t * the schema default when the property is genuinely absent.\r\n\t\t *\r\n\t\t * @param {Object} field_data Serialized field data.\r\n\t\t * @returns {Object} Normalized serialized field data.\r\n\t\t */\r\n\t\t_normalize_field_option_values(field_data) {\r\n\t\t\tconst has_value_differs = Object.prototype.hasOwnProperty.call( field_data, 'value_differs' );\r\n\t\t\tif ( !has_value_differs ) {\r\n\t\t\t\treturn field_data;\r\n\t\t\t}\r\n\r\n\t\t\tconst value_differs   = Core.WPBC_BFB_Sanitize.coerce_boolean( field_data.value_differs, false );\r\n\t\t\tfield_data.value_differs = value_differs;\r\n\r\n\t\t\tif ( !value_differs && Array.isArray( field_data.options ) ) {\r\n\t\t\t\tfield_data.options = field_data.options.map( ( option_record ) => {\r\n\t\t\t\t\tif ( !option_record || typeof option_record !== 'object' ) {\r\n\t\t\t\t\t\treturn option_record;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\treturn Object.assign(\r\n\t\t\t\t\t\t{},\r\n\t\t\t\t\t\toption_record,\r\n\t\t\t\t\t\t{ value: String( option_record.label == null ? '' : option_record.label ) }\r\n\t\t\t\t\t);\r\n\t\t\t\t} );\r\n\t\t\t}\r\n\r\n\t\t\treturn field_data;\r\n\t\t}\r\n\r\n\t\t/** @returns {Array} */\r\n\t\tserialize() {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tthis._normalize_ids();\r\n\t\t\tthis._normalize_names();\r\n\t\t\tconst pages = [];\r\n\t\t\tb.pages_container.querySelectorAll( '.wpbc_bfb__panel--preview' ).forEach( (page_el, page_index) => {\r\n\t\t\t\tconst container = page_el.querySelector( '.wpbc_bfb__form_preview_section_container' );\r\n\t\t\t\tconst content   = [];\r\n\t\t\t\tif ( !container ) {\r\n\t\t\t\t\tpages.push( { page: page_index + 1, content } );\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tcontainer.querySelectorAll( ':scope > *' ).forEach( (child) => {\r\n\t\t\t\t\tif ( child.classList.contains( 'wpbc_bfb__section' ) ) {\r\n\t\t\t\t\t\tcontent.push( { type: 'section', data: this.serialize_section( child ) } );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( child.classList.contains( 'wpbc_bfb__field' ) ) {\r\n\t\t\t\t\t\tif ( child.classList.contains( 'is-invalid' ) ) {\r\n\t\t\t\t\t\t\treturn;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tconst f_data = this._normalize_field_option_values(\r\n\t\t\t\t\t\t\tCore.WPBC_Form_Builder_Helper.get_all_data_attributes( child )\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\t// Drop ephemeral/editor-only flags\r\n\t\t\t\t\t\t[ 'uid', 'fresh', 'autoname', 'was_loaded', 'name_user_touched' ]\r\n\t\t\t\t\t\t\t.forEach( k => {\r\n\t\t\t\t\t\t\t\tif ( k in f_data ) delete f_data[k];\r\n\t\t\t\t\t\t\t} );\r\n\t\t\t\t\t\tcontent.push( { type: 'field', data: f_data } );\r\n\t\t\t\t\t}\r\n\t\t\t\t} );\r\n\t\t\t\tpages.push( { page: page_index + 1, content } );\r\n\t\t\t} );\r\n\t\t\treturn pages;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * @param {HTMLElement} section_el\r\n\t\t * @returns {{id:string,label:string,html_id:string,cssclass:string,col_styles:string,columns:Array}}\r\n\t\t */\r\n\t\tserialize_section(section_el) {\r\n\t\t\tconst row = section_el.querySelector( ':scope > .wpbc_bfb__row' );\r\n\r\n\t\t\t// NEW: read per-column styles from dataset/attributes (underscore & hyphen)\r\n\t\t\tvar col_styles_raw =\r\n\t\t\t\t\tsection_el.getAttribute( 'data-col_styles' ) ||\r\n\t\t\t\t\t(section_el.dataset ? (section_el.dataset.col_styles) : '') ||\r\n\t\t\t\t\t'';\r\n\r\n\t\t\tconst base = {\r\n\t\t\t\tid        : section_el.dataset.id,\r\n\t\t\t\tlabel     : section_el.dataset.label || '',\r\n\t\t\t\thtml_id   : section_el.dataset.html_id || '',\r\n\t\t\t\tcssclass  : section_el.dataset.cssclass || '',\r\n\t\t\t\tcol_styles: String( col_styles_raw )        // <-- NEW: keep as raw JSON string\r\n\t\t\t};\r\n\r\n\t\t\tif ( !row ) {\r\n\t\t\t\treturn Object.assign( {}, base, { columns: [] } );\r\n\t\t\t}\r\n\r\n\t\t\tconst columns = [];\r\n\t\t\trow.querySelectorAll( ':scope > .wpbc_bfb__column' ).forEach( function (col) {\r\n\t\t\t\tconst width = col.style.flexBasis || '100%';\r\n\t\t\t\tconst items = [];\r\n\t\t\t\tArray.prototype.forEach.call( col.children, function (child) {\r\n\t\t\t\t\tif ( child.classList.contains( 'wpbc_bfb__section' ) ) {\r\n\t\t\t\t\t\titems.push( { type: 'section', data: this.serialize_section( child ) } );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( child.classList.contains( 'wpbc_bfb__field' ) ) {\r\n\t\t\t\t\t\tif ( child.classList.contains( 'is-invalid' ) ) {\r\n\t\t\t\t\t\t\treturn;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tconst f_data = this._normalize_field_option_values(\r\n\t\t\t\t\t\t\tCore.WPBC_Form_Builder_Helper.get_all_data_attributes( child )\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\t[ 'uid', 'fresh', 'autoname', 'was_loaded', 'name_user_touched' ].forEach( function (k) {\r\n\t\t\t\t\t\t\tif ( k in f_data ) {\r\n\t\t\t\t\t\t\t\tdelete f_data[k];\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} );\r\n\t\t\t\t\t\titems.push( { type: 'field', data: f_data } );\r\n\t\t\t\t\t}\r\n\t\t\t\t}.bind( this ) );\r\n\t\t\t\tcolumns.push( { width: width, items: items } );\r\n\t\t\t}.bind( this ) );\r\n\r\n\t\t\t// Clamp persisted col_styles to the actual number of columns on Save.\r\n\t\t\ttry {\r\n\t\t\t\tconst colCount = columns.length;\r\n\t\t\t\tconst raw      = String( col_styles_raw || '' ).trim();\r\n\r\n\t\t\t\tif ( raw ) {\r\n\t\t\t\t\tlet arr = [];\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tconst parsed = JSON.parse( raw );\r\n\t\t\t\t\t\tarr          = Array.isArray( parsed ) ? parsed : (parsed && Array.isArray( parsed.columns ) ? parsed.columns : []);\r\n\t\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t\t\tarr = [];\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif ( colCount <= 0 ) {\r\n\t\t\t\t\t\tbase.col_styles = '[]';\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tif ( arr.length > colCount ) arr.length = colCount;\r\n\t\t\t\t\t\twhile ( arr.length < colCount ) arr.push( {} );\r\n\t\t\t\t\t\tbase.col_styles = JSON.stringify( arr );\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tbase.col_styles = '';\r\n\t\t\t\t}\r\n\t\t\t} catch ( _e ) {\r\n\t\t\t}\r\n\r\n\t\t\treturn Object.assign( {}, base, { columns: columns } );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * @param {Array} structure\r\n\t\t * @param {{deferIfTyping?: boolean}} [opts = {}]\r\n\t\t */\r\n\t\tdeserialize(structure, { deferIfTyping = true } = {}) {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tif ( deferIfTyping && this._is_typing_in_inspector() ) {\r\n\t\t\t\tclearTimeout( this._defer_timer );\r\n\t\t\t\tthis._defer_timer = setTimeout( () => {\r\n\t\t\t\t\tthis.deserialize( structure, { deferIfTyping: false } );\r\n\t\t\t\t}, 150 );\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tb.pages_container.innerHTML = '';\r\n\t\t\tb.page_counter              = 0;\r\n\t\t\t(structure || []).forEach( (page_data) => {\r\n\t\t\t\tconst page_el               = b.pages_sections.add_page( { scroll: false } );\r\n\t\t\t\tconst section_container     = page_el.querySelector( '.wpbc_bfb__form_preview_section_container' );\r\n\t\t\t\tsection_container.innerHTML = '';\r\n\t\t\t\tb.init_section_sortable?.( section_container );\r\n\t\t\t\t(page_data.content || []).forEach( (item) => {\r\n\t\t\t\t\tif ( item.type === 'section' ) {\r\n\t\t\t\t\t\t// Now returns the element; attributes (incl. col_styles) are applied inside rebuild.\r\n\t\t\t\t\t\tb.pages_sections.rebuild_section( item.data, section_container );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( item.type === 'field' ) {\r\n\t\t\t\t\t\tconst el = b.build_field( item.data );\r\n\t\t\t\t\t\tif ( el ) {\r\n\t\t\t\t\t\t\tsection_container.appendChild( el );\r\n\t\t\t\t\t\t\tb.trigger_field_drop_callback( el, 'load' );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t} );\r\n\t\t\t} );\r\n\t\t\tb.usage?.update_palette_ui?.();\r\n\t\t\tb.bus.emit( Core.WPBC_BFB_Events.STRUCTURE_LOADED, { structure } );\r\n\t\t}\r\n\r\n\t\t_normalize_ids() {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tb.pages_container.querySelectorAll( '.wpbc_bfb__panel--preview .wpbc_bfb__field:not(.is-invalid)' ).forEach( (el) => {\r\n\t\t\t\tconst data = Core.WPBC_Form_Builder_Helper.get_all_data_attributes( el );\r\n\t\t\t\tconst want = Core.WPBC_BFB_Sanitize.sanitize_html_id( data.id || '' ) || 'field';\r\n\t\t\t\tconst uniq = b.id.ensure_unique_field_id( want, el );\r\n\t\t\t\tif ( data.id !== uniq ) {\r\n\t\t\t\t\tel.setAttribute( 'data-id', uniq );\r\n\t\t\t\t\tif ( b.preview_mode ) {\r\n\t\t\t\t\t\tb.render_preview( el );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t_normalize_names() {\r\n\t\t\tconst b = this.builder;\r\n\t\t\tb.pages_container.querySelectorAll( '.wpbc_bfb__panel--preview .wpbc_bfb__field:not(.is-invalid)' ).forEach( (el) => {\r\n\t\t\t\tconst data = Core.WPBC_Form_Builder_Helper.get_all_data_attributes( el );\r\n\t\t\t\tconst base = Core.WPBC_BFB_Sanitize.sanitize_html_name( (data.name != null) ? data.name : data.id ) || 'field';\r\n\t\t\t\tconst uniq = b.id.ensure_unique_field_name( base, el );\r\n\t\t\t\tif ( data.name !== uniq ) {\r\n\t\t\t\t\tel.setAttribute( 'data-name', uniq );\r\n\t\t\t\t\tif ( b.preview_mode ) {\r\n\t\t\t\t\t\tb.render_preview( el );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t/** @returns {boolean} */\r\n\t\t_is_typing_in_inspector() {\r\n\t\t\tconst ins = document.getElementById( 'wpbc_bfb__inspector' );\r\n\t\t\treturn !!(ins && document.activeElement && ins.contains( document.activeElement ));\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Minimal, standalone guard that enforces per-column min widths based on fields' data-min_width.\r\n\t *\r\n\t * @type {UI.WPBC_BFB_Min_Width_Guard}\r\n\t */\r\n\tUI.WPBC_BFB_Min_Width_Guard = class extends UI.WPBC_BFB_Module {\r\n\r\n\t\tconstructor(builder) {\r\n\t\t\tsuper( builder );\r\n\t\t\tthis._on_field_add        = this._on_field_add.bind( this );\r\n\t\t\tthis._on_field_remove     = this._on_field_remove.bind( this );\r\n\t\t\tthis._on_structure_loaded = this._on_structure_loaded.bind( this );\r\n\t\t\tthis._on_structure_change = this._on_structure_change.bind( this );\r\n\t\t\tthis._on_window_resize    = this._on_window_resize.bind( this );\r\n\r\n\t\t\tthis._pending_rows = new Set();\r\n\t\t\tthis._pending_all  = false;\r\n\t\t\tthis._raf_id       = 0;\r\n\t\t}\r\n\r\n\t\tinit() {\r\n\t\t\tconst EV = Core.WPBC_BFB_Events;\r\n\t\t\tthis.builder?.bus?.on?.( EV.FIELD_ADD, this._on_field_add );\r\n\t\t\tthis.builder?.bus?.on?.( EV.FIELD_REMOVE, this._on_field_remove );\r\n\t\t\tthis.builder?.bus?.on?.( EV.STRUCTURE_LOADED, this._on_structure_loaded );\r\n\t\t\t// Refresh selectively on structure change (NOT on every prop input).\r\n\t\t\tthis.builder?.bus?.on?.( EV.STRUCTURE_CHANGE, this._on_structure_change );\r\n\r\n\t\t\twindow.addEventListener( 'resize', this._on_window_resize, { passive: true } );\r\n\t\t\tthis._schedule_refresh_all();\r\n\t\t}\r\n\r\n\t\tdestroy() {\r\n\t\t\tconst EV = Core.WPBC_BFB_Events;\r\n\t\t\tthis.builder?.bus?.off?.( EV.FIELD_ADD, this._on_field_add );\r\n\t\t\tthis.builder?.bus?.off?.( EV.FIELD_REMOVE, this._on_field_remove );\r\n\t\t\tthis.builder?.bus?.off?.( EV.STRUCTURE_LOADED, this._on_structure_loaded );\r\n\t\t\tthis.builder?.bus?.off?.( EV.STRUCTURE_CHANGE, this._on_structure_change );\r\n\t\t\twindow.removeEventListener( 'resize', this._on_window_resize );\r\n\t\t}\r\n\r\n\t\t_on_field_add(e) {\r\n\t\t\tthis._schedule_refresh_all();\r\n\t\t\t// if you really want to be minimal work here, keep your row-only version.\r\n\t\t}\r\n\r\n\t\t_on_field_remove(e) {\r\n\t\t\tconst src_el = e?.detail?.el || null;\r\n\t\t\tconst row    = (src_el && src_el.closest) ? src_el.closest( '.wpbc_bfb__row' ) : null;\r\n\t\t\tif ( row ) {\r\n\t\t\t\tthis._schedule_refresh_row( row );\r\n\t\t\t} else {\r\n\t\t\t\tthis._schedule_refresh_all();\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t_on_structure_loaded() {\r\n\t\t\tthis._schedule_refresh_all();\r\n\t\t}\r\n\r\n\t\t_on_structure_change(e) {\r\n\t\t\tconst reason = e?.detail?.reason || '';\r\n\t\t\tconst key    = e?.detail?.key || '';\r\n\r\n\t\t\t// Ignore noisy prop changes that don't affect min widths.\r\n\t\t\tif ( reason === 'prop-change' && key !== 'min_width' ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst el  = e?.detail?.el || null;\r\n\t\t\tconst row = el?.closest?.( '.wpbc_bfb__row' ) || null;\r\n\t\t\tif ( row ) {\r\n\t\t\t\tthis._schedule_refresh_row( row );\r\n\t\t\t} else {\r\n\t\t\t\tthis._schedule_refresh_all();\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t_on_window_resize() {\r\n\t\t\tthis._schedule_refresh_all();\r\n\t\t}\r\n\r\n\t\t_schedule_refresh_row(row_el) {\r\n\t\t\tif ( !row_el ) return;\r\n\t\t\tthis._pending_rows.add( row_el );\r\n\t\t\tthis._kick_raf();\r\n\t\t}\r\n\r\n\t\t_schedule_refresh_all() {\r\n\t\t\tthis._pending_all = true;\r\n\t\t\tthis._pending_rows.clear();\r\n\t\t\tthis._kick_raf();\r\n\t\t}\r\n\r\n\t\t_kick_raf() {\r\n\t\t\tif ( this._raf_id ) return;\r\n\t\t\tthis._raf_id = (window.requestAnimationFrame || setTimeout)( () => {\r\n\t\t\t\tthis._raf_id = 0;\r\n\t\t\t\tif ( this._pending_all ) {\r\n\t\t\t\t\tthis._pending_all = false;\r\n\t\t\t\t\tthis.refresh_all();\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tconst rows = Array.from( this._pending_rows );\r\n\t\t\t\tthis._pending_rows.clear();\r\n\t\t\t\trows.forEach( (r) => this.refresh_row( r ) );\r\n\t\t\t}, 0 );\r\n\t\t}\r\n\r\n\r\n\t\trefresh_all() {\r\n\t\t\tthis.builder?.pages_container\r\n\t\t\t\t?.querySelectorAll?.( '.wpbc_bfb__row' )\r\n\t\t\t\t?.forEach?.( (row) => this.refresh_row( row ) );\r\n\t\t}\r\n\r\n\t\trefresh_row(row_el) {\r\n\t\t\tif ( !row_el ) return;\r\n\r\n\t\t\tconst cols = row_el.querySelectorAll( ':scope > .wpbc_bfb__column' );\r\n\r\n\t\t\t// 1) Recalculate each column’s required min px and write it to the CSS var.\r\n\t\t\tcols.forEach( (col) => this.apply_col_min( col ) );\r\n\r\n\t\t\t// 2) Enforce it at the CSS level right away so layout can’t render narrower.\r\n\t\t\tcols.forEach( (col) => {\r\n\t\t\t\tconst px           = parseFloat( getComputedStyle( col ).getPropertyValue( '--wpbc-col-min' ) || '0' ) || 0;\r\n\t\t\t\tcol.style.minWidth = px > 0 ? Math.round( px ) + 'px' : '';\r\n\t\t\t} );\r\n\r\n\t\t\t// 3) Normalize current bases so the row respects all mins without overflow.\r\n\t\t\ttry {\r\n\t\t\t\tconst b   = this.builder;\r\n\t\t\t\tconst gp  = b.col_gap_percent;\r\n\t\t\t\tconst eff = b.layout.compute_effective_bases_from_row( row_el, gp );  // { bases, available }\r\n\t\t\t\t// Re-fit *current* bases against mins (same algorithm layout chips use).\r\n\t\t\t\tconst fitted = UI.WPBC_BFB_Layout_Chips._fit_weights_respecting_min( b, row_el, eff.bases );\r\n\t\t\t\tif ( Array.isArray( fitted ) ) {\r\n\t\t\t\t\tconst changed = fitted.some( (v, i) => Math.abs( v - eff.bases[i] ) > 0.01 );\r\n\t\t\t\t\tif ( changed ) {\r\n\t\t\t\t\t\tb.layout.apply_bases_to_row( row_el, fitted );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} catch ( e ) {\r\n\t\t\t\tw._wpbc?.dev?.error?.( 'WPBC_BFB_Min_Width_Guard - refresh_row', e );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tapply_col_min(col_el) {\r\n\t\t\tif ( !col_el ) return;\r\n\t\t\tlet max_px    = 0;\r\n\t\t\tconst colRect = col_el.getBoundingClientRect();\r\n\t\t\tcol_el.querySelectorAll( ':scope > .wpbc_bfb__field' ).forEach( (field) => {\r\n\t\t\t\tconst raw = field.getAttribute( 'data-min_width' );\r\n\t\t\t\tlet px    = 0;\r\n\t\t\t\tif ( raw ) {\r\n\t\t\t\t\tconst s = String( raw ).trim().toLowerCase();\r\n\t\t\t\t\tif ( s.endsWith( '%' ) ) {\r\n\t\t\t\t\t\tconst n = parseFloat( s );\r\n\t\t\t\t\t\tif ( Number.isFinite( n ) && colRect.width > 0 ) {\r\n\t\t\t\t\t\t\tpx = (n / 100) * colRect.width;\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tpx = 0;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tpx = this.parse_len_px( s );\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tconst cs = getComputedStyle( field );\r\n\t\t\t\t\tpx       = parseFloat( cs.minWidth || '0' ) || 0;\r\n\t\t\t\t}\r\n\t\t\t\tif ( px > max_px ) max_px = px;\r\n\t\t\t} );\r\n\t\t\tcol_el.style.setProperty( '--wpbc-col-min', max_px > 0 ? Math.round( max_px ) + 'px' : '0px' );\r\n\t\t}\r\n\r\n\t\tparse_len_px(value) {\r\n\t\t\tif ( value == null ) return 0;\r\n\t\t\tconst s = String( value ).trim().toLowerCase();\r\n\t\t\tif ( s === '' ) return 0;\r\n\t\t\tif ( s.endsWith( 'px' ) ) {\r\n\t\t\t\tconst n = parseFloat( s );\r\n\t\t\t\treturn Number.isFinite( n ) ? n : 0;\r\n\t\t\t}\r\n\t\t\tif ( s.endsWith( 'rem' ) || s.endsWith( 'em' ) ) {\r\n\t\t\t\tconst n    = parseFloat( s );\r\n\t\t\t\tconst base = parseFloat( getComputedStyle( document.documentElement ).fontSize ) || 16;\r\n\t\t\t\treturn Number.isFinite( n ) ? n * base : 0;\r\n\t\t\t}\r\n\t\t\tconst n = parseFloat( s );\r\n\t\t\treturn Number.isFinite( n ) ? n : 0;\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * WPBC_BFB_Toggle_Normalizer\r\n\t *\r\n\t * Converts plain checkboxes into toggle UI:\r\n\t * <div class=\"inspector__control wpbc_ui__toggle\">\r\n\t *   <input type=\"checkbox\" id=\"{unique}\" data-inspector-key=\"...\" class=\"inspector__input\" role=\"switch\"\r\n\t * aria-checked=\"true|false\">\r\n\t *   <label class=\"wpbc_ui__toggle_icon\"  for=\"{unique}\"></label>\r\n\t *   <label class=\"wpbc_ui__toggle_label\" for=\"{unique}\">Label</label>\r\n\t * </div>\r\n\t *\r\n\t * - Skips inputs already inside `.wpbc_ui__toggle`.\r\n\t * - Reuses an existing <label for=\"...\"> text if present; otherwise falls back to nearby labels or attributes.\r\n\t * - Auto-generates a unique id when absent.\r\n\t */\r\n\tUI.WPBC_BFB_Toggle_Normalizer = class {\r\n\r\n\t\t/**\r\n\t\t * Upgrade all raw checkboxes in a container to toggles.\r\n\t\t * @param {HTMLElement} root_el\r\n\t\t */\r\n\t\tstatic upgrade_checkboxes_in(root_el) {\r\n\r\n\t\t\tif ( !root_el || !root_el.querySelectorAll ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tvar inputs = root_el.querySelectorAll( 'input[type=\"checkbox\"]' );\r\n\t\t\tif ( !inputs.length ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tArray.prototype.forEach.call( inputs, function (input) {\r\n\r\n\t\t\t\t// 1) Skip if already inside toggle wrapper.\r\n\t\t\t\tif ( input.closest( '.wpbc_ui__toggle' ) ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\t// Skip rows / where input checkbox explicitly marked with  attribute 'data-wpbc-ui-no-toggle'.\r\n\t\t\t\tif ( input.hasAttribute( 'data-wpbc-ui-no-toggle' ) ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// 2) Ensure unique id; prefer existing.\r\n\t\t\t\tvar input_id = input.getAttribute( 'id' );\r\n\t\t\t\tif ( !input_id ) {\r\n\t\t\t\t\tvar key  = (input.dataset && input.dataset.inspectorKey) ? String( input.dataset.inspectorKey ) : 'opt';\r\n\t\t\t\t\tinput_id = UI.WPBC_BFB_Toggle_Normalizer.generate_unique_id( 'wpbc_ins_auto_' + key + '_' );\r\n\t\t\t\t\tinput.setAttribute( 'id', input_id );\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// 3) Find best label text.\r\n\t\t\t\tvar label_text = UI.WPBC_BFB_Toggle_Normalizer.resolve_label_text( root_el, input, input_id );\r\n\r\n\t\t\t\t// 4) Build the toggle wrapper.\r\n\t\t\t\tvar wrapper       = document.createElement( 'div' );\r\n\t\t\t\twrapper.className = 'inspector__control wpbc_ui__toggle';\r\n\r\n\t\t\t\t// Keep original input; just move it into wrapper.\r\n\t\t\t\tinput.classList.add( 'inspector__input' );\r\n\t\t\t\tinput.setAttribute( 'role', 'switch' );\r\n\t\t\t\tinput.setAttribute( 'aria-checked', input.checked ? 'true' : 'false' );\r\n\r\n\t\t\t\tvar icon_label       = document.createElement( 'label' );\r\n\t\t\t\ticon_label.className = 'wpbc_ui__toggle_icon';\r\n\t\t\t\ticon_label.setAttribute( 'for', input_id );\r\n\r\n\t\t\t\tvar text_label       = document.createElement( 'label' );\r\n\t\t\t\ttext_label.className = 'wpbc_ui__toggle_label';\r\n\t\t\t\ttext_label.setAttribute( 'for', input_id );\r\n\t\t\t\ttext_label.appendChild( document.createTextNode( label_text ) );\r\n\r\n\t\t\t\t// 5) Insert wrapper into DOM near the input.\r\n\t\t\t\t//    Preferred: replace the original labeled row if it matches typical inspector layout.\r\n\t\t\t\tvar replaced = UI.WPBC_BFB_Toggle_Normalizer.try_replace_known_row( input, wrapper, label_text );\r\n\r\n\t\t\t\tif ( !replaced ) {\r\n\t\t\t\t\tif ( !input.parentNode ) return; // NEW guard\r\n\t\t\t\t\t// Fallback: just wrap the input in place and append labels.\r\n\t\t\t\t\tinput.parentNode.insertBefore( wrapper, input );\r\n\t\t\t\t\twrapper.appendChild( input );\r\n\t\t\t\t\twrapper.appendChild( icon_label );\r\n\t\t\t\t\twrapper.appendChild( text_label );\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// 6) ARIA sync on change.\r\n\t\t\t\tinput.addEventListener( 'change', function () {\r\n\t\t\t\t\tinput.setAttribute( 'aria-checked', input.checked ? 'true' : 'false' );\r\n\t\t\t\t} );\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Generate a unique id with a given prefix.\r\n\t\t * @param {string} prefix\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic generate_unique_id(prefix) {\r\n\t\t\tvar base = String( prefix || 'wpbc_ins_auto_' );\r\n\t\t\tvar uid  = Math.random().toString( 36 ).slice( 2, 8 );\r\n\t\t\tvar id   = base + uid;\r\n\t\t\t// Minimal collision guard in the current document scope.\r\n\t\t\twhile ( document.getElementById( id ) ) {\r\n\t\t\t\tuid = Math.random().toString( 36 ).slice( 2, 8 );\r\n\t\t\t\tid  = base + uid;\r\n\t\t\t}\r\n\t\t\treturn id;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Resolve the best human label for an input.\r\n\t\t * Priority:\r\n\t\t *  1) <label for=\"{id}\">text</label>\r\n\t\t *  2) nearest sibling/parent .inspector__label text\r\n\t\t *  3) input.getAttribute('aria-label') || data-label || data-inspector-key || name || 'Option'\r\n\t\t * @param {HTMLElement} root_el\r\n\t\t * @param {HTMLInputElement} input\r\n\t\t * @param {string} input_id\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic resolve_label_text(root_el, input, input_id) {\r\n\t\t\t// for= association\r\n\t\t\tif ( input_id ) {\r\n\t\t\t\tvar assoc = root_el.querySelector( 'label[for=\"' + UI.WPBC_BFB_Toggle_Normalizer.css_escape( input_id ) + '\"]' );\r\n\t\t\t\tif ( assoc && assoc.textContent ) {\r\n\t\t\t\t\tvar txt = assoc.textContent.trim();\r\n\t\t\t\t\t// Remove the old label from DOM; its text will be used by toggle.\r\n\t\t\t\t\tassoc.parentNode && assoc.parentNode.removeChild( assoc );\r\n\t\t\t\t\tif ( txt ) {\r\n\t\t\t\t\t\treturn txt;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// nearby inspector label\r\n\t\t\tvar near_label = input.closest( '.inspector__row' );\r\n\t\t\tif ( near_label ) {\r\n\t\t\t\tvar il = near_label.querySelector( '.inspector__label' );\r\n\t\t\t\tif ( il && il.textContent ) {\r\n\t\t\t\t\tvar t2 = il.textContent.trim();\r\n\t\t\t\t\t// If this row had the standard label+control, drop the old text label to avoid duplicates.\r\n\t\t\t\t\til.parentNode && il.parentNode.removeChild( il );\r\n\t\t\t\t\tif ( t2 ) {\r\n\t\t\t\t\t\treturn t2;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// fallbacks\r\n\t\t\tvar aria = input.getAttribute( 'aria-label' );\r\n\t\t\tif ( aria ) {\r\n\t\t\t\treturn aria;\r\n\t\t\t}\r\n\t\t\tif ( input.dataset && input.dataset.label ) {\r\n\t\t\t\treturn String( input.dataset.label );\r\n\t\t\t}\r\n\t\t\tif ( input.dataset && input.dataset.inspectorKey ) {\r\n\t\t\t\treturn String( input.dataset.inspectorKey );\r\n\t\t\t}\r\n\t\t\tif ( input.name ) {\r\n\t\t\t\treturn String( input.name );\r\n\t\t\t}\r\n\t\t\treturn 'Option';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Try to replace a known inspector row pattern with a toggle wrapper.\r\n\t\t * Patterns:\r\n\t\t *  <div.inspector__row>\r\n\t\t *    <label.inspector__label>Text</label>\r\n\t\t *    <div.inspector__control> [input[type=checkbox]] </div>\r\n\t\t *  </div>\r\n\t\t *\r\n\t\t * @param {HTMLInputElement} input\r\n\t\t * @param {HTMLElement} wrapper\r\n\t\t * @returns {boolean} replaced\r\n\t\t */\r\n\t\tstatic try_replace_known_row(input, wrapper, label_text) {\r\n\t\t\tvar row       = input.closest( '.inspector__row' );\r\n\t\t\tvar ctrl_wrap = input.parentElement;\r\n\r\n\t\t\tif ( row && ctrl_wrap && ctrl_wrap.classList.contains( 'inspector__control' ) ) {\r\n\t\t\t\t// Clear control wrap and reinsert toggle structure.\r\n\t\t\t\twhile ( ctrl_wrap.firstChild ) {\r\n\t\t\t\t\tctrl_wrap.removeChild( ctrl_wrap.firstChild );\r\n\t\t\t\t}\r\n\t\t\t\trow.classList.add( 'inspector__row--toggle' );\r\n\r\n\t\t\t\tctrl_wrap.classList.add( 'wpbc_ui__toggle' );\r\n\t\t\t\tctrl_wrap.appendChild( input );\r\n\r\n\t\t\t\tvar input_id       = input.getAttribute( 'id' );\r\n\t\t\t\tvar icon_lbl       = document.createElement( 'label' );\r\n\t\t\t\ticon_lbl.className = 'wpbc_ui__toggle_icon';\r\n\t\t\t\ticon_lbl.setAttribute( 'for', input_id );\r\n\r\n\t\t\t\tvar text_lbl       = document.createElement( 'label' );\r\n\t\t\t\ttext_lbl.className = 'wpbc_ui__toggle_label';\r\n\t\t\t\ttext_lbl.setAttribute( 'for', input_id );\r\n\t\t\t\tif ( label_text ) {\r\n\t\t\t\t\ttext_lbl.appendChild( document.createTextNode( label_text ) );\r\n\t\t\t\t}\r\n\t\t\t\t// If the row previously had a .inspector__label (we removed it in resolve_label_text),\r\n\t\t\t\t// we intentionally do NOT recreate it; the toggle text label becomes the visible one.\r\n\t\t\t\t// The text content is already resolved in resolve_label_text() and set below by caller.\r\n\r\n\t\t\t\tctrl_wrap.appendChild( icon_lbl );\r\n\t\t\t\tctrl_wrap.appendChild( text_lbl );\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\r\n\t\t\t// Not a known pattern; caller will wrap in place.\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * CSS.escape polyfill for selectors.\r\n\t\t * @param {string} s\r\n\t\t * @returns {string}\r\n\t\t */\r\n\t\tstatic css_escape(s) {\r\n\t\t\ts = String( s );\r\n\t\t\tif ( window.CSS && typeof window.CSS.escape === 'function' ) {\r\n\t\t\t\treturn window.CSS.escape( s );\r\n\t\t\t}\r\n\t\t\treturn s.replace( /([^\\w-])/g, '\\\\$1' );\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Apply all UI normalizers/enhancers to a container (post-render).\r\n\t * Keep this file small and add more normalizers later in one place.\r\n\t *\r\n\t * @param {HTMLElement} root\r\n\t */\r\n\tUI.apply_post_render = function (root) {\r\n\t\tif ( !root ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\ttry {\r\n\t\t\tUI.WPBC_BFB_ValueSlider?.init_on?.( root );\r\n\t\t} catch ( e ) { /* noop */\r\n\t\t}\r\n\t\ttry {\r\n\t\t\tvar T = UI.WPBC_BFB_Toggle_Normalizer;\r\n\t\t\tif ( T && typeof T.upgrade_checkboxes_in === 'function' ) {\r\n\t\t\t\tT.upgrade_checkboxes_in( root );\r\n\t\t\t}\r\n\t\t} catch ( e ) {\r\n\t\t\tw._wpbc?.dev?.error?.( 'apply_post_render.toggle', e );\r\n\t\t}\r\n\r\n\t\t// Accessibility: keep aria-checked in sync for all toggles inside root.\r\n\t\ttry {\r\n\t\t\troot.querySelectorAll( '.wpbc_ui__toggle input[type=\"checkbox\"]' ).forEach( function (cb) {\r\n\t\t\t\tif ( cb.__wpbc_aria_hooked ) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tcb.__wpbc_aria_hooked = true;\r\n\t\t\t\tcb.setAttribute( 'aria-checked', cb.checked ? 'true' : 'false' );\r\n\t\t\t\t// Delegate ‘change’ just once per render – native delegation still works fine for your logic.\r\n\t\t\t\tcb.addEventListener( 'change', () => {\r\n\t\t\t\t\tcb.setAttribute( 'aria-checked', cb.checked ? 'true' : 'false' );\r\n\t\t\t\t}, { passive: true } );\r\n\t\t\t} );\r\n\t\t} catch ( e ) {\r\n\t\t\tw._wpbc?.dev?.error?.( 'apply_post_render.aria', e );\r\n\t\t}\r\n\t};\r\n\r\n\tUI.InspectorEnhancers = UI.InspectorEnhancers || (function () {\r\n\t\tvar regs = [];\r\n\r\n\t\tfunction register(name, selector, init, destroy) {\r\n\t\t\tregs.push( { name, selector, init, destroy } );\r\n\t\t}\r\n\r\n\t\tfunction scan(root) {\r\n\t\t\tif ( !root ) return;\r\n\t\t\tregs.forEach( function (r) {\r\n\t\t\t\troot.querySelectorAll( r.selector ).forEach( function (node) {\r\n\t\t\t\t\tnode.__wpbc_eh = node.__wpbc_eh || {};\r\n\t\t\t\t\tif ( node.__wpbc_eh[r.name] ) return;\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tr.init && r.init( node, root );\r\n\t\t\t\t\t\tnode.__wpbc_eh[r.name] = true;\r\n\t\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t\t}\r\n\t\t\t\t} );\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\tfunction destroy(root) {\r\n\t\t\tif ( !root ) return;\r\n\t\t\tregs.forEach( function (r) {\r\n\t\t\t\troot.querySelectorAll( r.selector ).forEach( function (node) {\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tr.destroy && r.destroy( node, root );\r\n\t\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( node.__wpbc_eh ) delete node.__wpbc_eh[r.name];\r\n\t\t\t\t} );\r\n\t\t\t} );\r\n\t\t}\r\n\r\n\t\treturn { register, scan, destroy };\r\n\t})();\r\n\r\n\tUI.WPBC_BFB_ValueSlider = {\r\n\t\tinit_on(root) {\r\n\t\t\tvar groups = (root.nodeType === 1 ? [ root ] : []).concat( [].slice.call( root.querySelectorAll?.( '[data-len-group]' ) || [] ) );\r\n\t\t\tgroups.forEach( function (g) {\r\n\t\t\t\tif ( !g.matches || !g.matches( '[data-len-group]' ) ) return;\r\n\t\t\t\tif ( g.__wpbc_len_wired ) return;\r\n\r\n\t\t\t\tvar number = g.querySelector( '[data-len-value]' );\r\n\t\t\t\tvar range  = g.querySelector( '[data-len-range]' );\r\n\t\t\t\tvar unit   = g.querySelector( '[data-len-unit]' );\r\n\r\n\t\t\t\tif ( !number || !range ) return;\r\n\r\n\t\t\t\t// Mirror constraints if missing on the range.\r\n\t\t\t\t[ 'min', 'max', 'step' ].forEach( function (a) {\r\n\t\t\t\t\tif ( !range.hasAttribute( a ) && number.hasAttribute( a ) ) {\r\n\t\t\t\t\t\trange.setAttribute( a, number.getAttribute( a ) );\r\n\t\t\t\t\t}\r\n\t\t\t\t} );\r\n\r\n\r\n\t\t\t\tfunction sync_range_from_number() {\n\t\t\t\t\tif ( g.hasAttribute( 'data-len-allow-empty' ) && '' === number.value ) {\n\t\t\t\t\t\tvar empty_range_value = range.min || '0';\n\t\t\t\t\t\tif ( range.value !== empty_range_value ) {\n\t\t\t\t\t\t\trange.value = empty_range_value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tif ( range.value !== number.value ) {\n\t\t\t\t\t\trange.value = number.value;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tfunction dispatch_input(el) {\r\n\t\t\t\t\ttry { el.dispatchEvent( new Event( 'input', { bubbles: true } ) ); } catch ( _e ) {}\r\n\t\t\t\t}\r\n\t\t\t\tfunction dispatch_change(el) {\r\n\t\t\t\t\ttry { el.dispatchEvent( new Event( 'change', { bubbles: true } ) ); } catch ( _e ) {}\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Throttle range->number syncing (time-based).\r\n\t\t\t\tvar timer_id       = 0;\r\n\t\t\t\tvar pending_val    = null;\r\n\t\t\t\tvar pending_change = false;\r\n\t\t\t\tvar last_flush_ts  = 0;\r\n\r\n\t\t\t\t// Change this to tune speed: 50..120 ms is a good range.\r\n\t\t\t\tvar min_interval_ms = parseInt( g.dataset.lenThrottle || UI.VALUE_SLIDER_THROTTLE_MS, 10 );\r\n\t\t\t\tmin_interval_ms = Number.isFinite( min_interval_ms ) ? Math.max( 0, min_interval_ms ) : 120;\r\n\r\n\t\t\t\tfunction flush_range_to_number() {\r\n\t\t\t\t\ttimer_id = 0;\r\n\r\n\t\t\t\t\tif ( pending_val == null ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tvar next    = String( pending_val );\r\n\t\t\t\t\tpending_val = null;\r\n\r\n\t\t\t\t\tif ( number.value !== next ) {\r\n\t\t\t\t\t\tnumber.value = next;\r\n\t\t\t\t\t\t// IMPORTANT: only 'input' while dragging.\r\n\t\t\t\t\t\tdispatch_input( number );\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif ( pending_change ) {\r\n\t\t\t\t\t\tpending_change = false;\r\n\t\t\t\t\t\tdispatch_change( number );\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tlast_flush_ts = Date.now();\r\n\t\t\t\t}\r\n\r\n\t\t\t\tfunction schedule_range_to_number(val, emit_change) {\r\n\t\t\t\t\tpending_val = val;\r\n\t\t\t\t\tif ( emit_change ) {\r\n\t\t\t\t\t\tpending_change = true;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// If commit requested, flush immediately.\r\n\t\t\t\t\tif ( pending_change ) {\r\n\t\t\t\t\t\tif ( timer_id ) {\r\n\t\t\t\t\t\t\tclearTimeout( timer_id );\r\n\t\t\t\t\t\t\ttimer_id = 0;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tflush_range_to_number();\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tvar now   = Date.now();\r\n\t\t\t\t\tvar delta = now - last_flush_ts;\r\n\r\n\t\t\t\t\t// If enough time passed, flush immediately; else schedule.\r\n\t\t\t\t\tif ( delta >= min_interval_ms ) {\r\n\t\t\t\t\t\tflush_range_to_number();\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif ( timer_id ) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\ttimer_id = setTimeout( flush_range_to_number, Math.max( 0, min_interval_ms - delta ) );\r\n\t\t\t\t}\r\n\r\n\t\t\t\tfunction on_number_input() {\r\n\t\t\t\t\tsync_range_from_number();\r\n\t\t\t\t}\r\n\r\n\t\t\t\tfunction on_number_change() {\r\n\t\t\t\t\tsync_range_from_number();\r\n\t\t\t\t}\r\n\r\n\t\t\t\tfunction on_range_input() {\r\n\t\t\t\t\tschedule_range_to_number( range.value, false );\r\n\t\t\t\t}\r\n\r\n\t\t\t\tfunction on_range_change() {\r\n\t\t\t\t\tschedule_range_to_number( range.value, true );\r\n\t\t\t\t}\r\n\r\n\t\t\t\tnumber.addEventListener( 'input',  on_number_input );\r\n\t\t\t\tnumber.addEventListener( 'change', on_number_change );\r\n\t\t\t\trange.addEventListener( 'input',  on_range_input );\r\n\t\t\t\trange.addEventListener( 'change', on_range_change );\r\n\r\n\t\t\t\tif ( unit ) {\r\n\t\t\t\t\tunit.addEventListener( 'change', function () {\r\n\t\t\t\t\t\t// We just nudge the number so upstream handlers re-run.\r\n\t\t\t\t\t\ttry {\r\n\t\t\t\t\t\t\tnumber.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} );\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Initial sync\r\n\t\t\t\tsync_range_from_number();\r\n\r\n\t\t\t\tg.__wpbc_len_wired = {\r\n\t\t\t\t\tdestroy() {\r\n\t\t\t\t\t\tnumber.removeEventListener( 'input',  on_number_input );\r\n\t\t\t\t\t\tnumber.removeEventListener( 'change', on_number_change );\r\n\t\t\t\t\t\trange.removeEventListener( 'input',  on_range_input );\r\n\t\t\t\t\t\trange.removeEventListener( 'change', on_range_change );\r\n\t\t\t\t\t}\r\n\t\t\t\t};\r\n\t\t\t} );\r\n\t\t},\r\n\t\tdestroy_on(root) {\r\n\t\t\tvar groups = (root && root.nodeType === 1 ? [ root ] : []).concat(\r\n\t\t\t\t[].slice.call( root.querySelectorAll?.( '[data-len-group]' ) || [] )\r\n\t\t\t);\r\n\t\t\tgroups.forEach( function (g) {\r\n\t\t\t\tif ( !g.matches || !g.matches( '[data-len-group]' ) ) return;\r\n\t\t\t\ttry {\r\n\t\t\t\t\tg.__wpbc_len_wired && g.__wpbc_len_wired.destroy && g.__wpbc_len_wired.destroy();\r\n\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t}\r\n\t\t\t\tdelete g.__wpbc_len_wired;\r\n\t\t\t} );\r\n\t\t}\r\n\t};\r\n\r\n\t// Register with the global enhancers hub.\r\n\tUI.InspectorEnhancers && UI.InspectorEnhancers.register(\r\n\t\t'value-slider',\r\n\t\t'[data-len-group]',\r\n\t\tfunction (el, _root) {\r\n\t\t\tUI.WPBC_BFB_ValueSlider.init_on( el );\r\n\t\t},\r\n\t\tfunction (el, _root) {\r\n\t\t\tUI.WPBC_BFB_ValueSlider.destroy_on( el );\r\n\t\t}\r\n\t);\r\n\r\n\t// Single, load-order-safe patch so enhancers auto-run on every bind.\r\n\t(function patchInspectorEnhancers() {\r\n\t\tfunction applyPatch() {\r\n\t\t\tvar Inspector = w.WPBC_BFB_Inspector;\r\n\t\t\tif ( !Inspector || Inspector.__wpbc_enhancers_patched ) return false;\r\n\t\t\tInspector.__wpbc_enhancers_patched = true;\r\n\t\t\tvar orig                           = Inspector.prototype.bind_to_field;\r\n\t\t\tInspector.prototype.bind_to_field  = function (el) {\r\n\t\t\t\torig.call( this, el );\r\n\t\t\t\ttry {\r\n\t\t\t\t\tvar ins = this.panel\r\n\t\t\t\t\t\t|| document.getElementById( 'wpbc_bfb__inspector' )\r\n\t\t\t\t\t\t|| document.querySelector( '.wpbc_bfb__inspector' );\r\n\t\t\t\t\tUI.InspectorEnhancers && UI.InspectorEnhancers.scan( ins );\r\n\t\t\t\t} catch ( _e ) {\r\n\t\t\t\t}\r\n\t\t\t};\r\n\t\t\t// Initial scan if the DOM is already present.\r\n\t\t\ttry {\r\n\t\t\t\tvar insEl = document.getElementById( 'wpbc_bfb__inspector' )\r\n\t\t\t\t\t|| document.querySelector( '.wpbc_bfb__inspector' );\r\n\t\t\t\tUI.InspectorEnhancers && UI.InspectorEnhancers.scan( insEl );\r\n\t\t\t} catch ( _e ) {\r\n\t\t\t}\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\t// Try now; if Inspector isn’t defined yet, patch when it becomes ready.\r\n\t\tif ( !applyPatch() ) {\r\n\t\t\tdocument.addEventListener(\r\n\t\t\t\t'wpbc_bfb_inspector_ready',\r\n\t\t\t\tfunction () {\r\n\t\t\t\t\tapplyPatch();\r\n\t\t\t\t},\r\n\t\t\t\t{ once: true }\r\n\t\t\t);\r\n\t\t}\r\n\t})();\r\n\r\n}( window, document ));\r\n","// ---------------------------------------------------------------------------------------------------------------------\r\n// == File  /includes/page-form-builder/__js/core/bfb-sync-code-tools-tab.js   | 2026-04-06 | 16:38\r\n// ---------------------------------------------------------------------------------------------------------------------\r\n(function ( w, d ) {\r\n\t'use strict';\r\n\r\n\t/**\r\n\t * Dispatch request to show a right sidebar panel.\r\n\t *\r\n\t * @param {string} panel_id\r\n\t * @param {string} tab_id\r\n\t *\r\n\t * @return {void}\r\n\t */\r\n\tfunction wpbc_bfb__dispatch_show_panel( panel_id, tab_id ) {\r\n\r\n\t\tvar event_detail;\r\n\r\n\t\tif ( ! panel_id || ! tab_id ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tevent_detail = {\r\n\t\t\tpanel_id: panel_id,\r\n\t\t\ttab_id  : tab_id\r\n\t\t};\r\n\r\n\t\tif ( typeof w.wpbc_bfb__dispatch_event_safe === 'function' ) {\r\n\t\t\tw.wpbc_bfb__dispatch_event_safe( 'wpbc_bfb:show_panel', event_detail );\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\td.dispatchEvent(\r\n\t\t\tnew CustomEvent(\r\n\t\t\t\t'wpbc_bfb:show_panel',\r\n\t\t\t\t{\r\n\t\t\t\t\tdetail: event_detail\r\n\t\t\t\t}\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Sync right sidebar with top mode tabs.\r\n\t *\r\n\t * Uses top tabs nav attribute `data-active-tab` as the source of truth.\r\n\t * This avoids false detection on initial page load, because top panels are\r\n\t * hidden by inline style `display:none`, not by the `hidden` attribute.\r\n\t */\r\n\tclass WPBC_BFB_Mode_Rightbar_Sync {\r\n\r\n\t\tconstructor() {\r\n\t\t\tthis.top_tabs_nav      = null;\r\n\t\t\tthis.advanced_tab_wrap = null;\r\n\t\t\tthis.advanced_panel    = null;\r\n\t\t\tthis.mutation_observer = null;\r\n\t\t\tthis.last_mode         = '';\r\n\t\t\tthis.sync_rightbar_mode = this.sync_rightbar_mode.bind( this );\r\n\t\t\tthis.handle_click      = this.handle_click.bind( this );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Init controller.\r\n\t\t *\r\n\t\t * @return {void}\r\n\t\t */\r\n\t\tinit() {\r\n\t\t\tthis.top_tabs_nav      = d.getElementById( 'wpbc_bfb__top_horisontal_nav' );\r\n\t\t\tthis.advanced_tab_wrap = d.querySelector( '.wpbc_bfb__rightbar_tab_wrap--advanced_tools' );\r\n\t\t\tthis.advanced_panel    = d.getElementById( 'wpbc_bfb__inspector_advanced_tools' );\r\n\r\n\t\t\tif ( ! this.advanced_tab_wrap || ! this.advanced_panel ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\t// Observe active tab changes in the top tabs nav.\r\n\t\t\tif ( this.top_tabs_nav ) {\r\n\t\t\t\tthis.mutation_observer = new MutationObserver( this.sync_rightbar_mode );\r\n\t\t\t\tthis.mutation_observer.observe(\r\n\t\t\t\t\tthis.top_tabs_nav,\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tattributes     : true,\r\n\t\t\t\t\t\tattributeFilter: [ 'data-active-tab' ]\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\r\n\t\t\t// Fallback for click-driven switching.\r\n\t\t\td.addEventListener( 'click', this.handle_click, true );\r\n\r\n\t\t\t// Initial sync.\r\n\t\t\tthis.sync_rightbar_mode();\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Get active top tab id.\r\n\t\t *\r\n\t\t * Priority:\r\n\t\t * 1. data-active-tab from top tabs nav\r\n\t\t * 2. active CSS class in nav\r\n\t\t * 3. visible top panel fallback\r\n\t\t *\r\n\t\t * @return {string}\r\n\t\t */\r\n\t\tget_active_top_tab_id() {\r\n\t\t\tvar active_tab_id = '';\r\n\t\t\tvar active_link   = null;\r\n\t\t\tvar advanced_panel = null;\r\n\t\t\tvar builder_panel  = null;\r\n\r\n\t\t\tif ( this.top_tabs_nav ) {\r\n\t\t\t\tactive_tab_id = String( this.top_tabs_nav.getAttribute( 'data-active-tab' ) || '' ).trim();\r\n\t\t\t\tif ( '' !== active_tab_id ) {\r\n\t\t\t\t\treturn active_tab_id;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tactive_link = this.top_tabs_nav.querySelector( '.wpbc_ui_el__horis_nav_item.active [data-wpbc-bfb-tab]' );\r\n\t\t\t\tif ( active_link ) {\r\n\t\t\t\t\tactive_tab_id = String( active_link.getAttribute( 'data-wpbc-bfb-tab' ) || '' ).trim();\r\n\t\t\t\t\tif ( '' !== active_tab_id ) {\r\n\t\t\t\t\t\treturn active_tab_id;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// Final fallback: detect visible panel.\r\n\t\t\tadvanced_panel = d.querySelector( '.wpbc_bfb__top_tab_section__advanced_tab' );\r\n\t\t\tbuilder_panel  = d.querySelector( '.wpbc_bfb__top_tab_section__builder_tab' );\r\n\r\n\t\t\tif ( this.is_element_visible( advanced_panel ) ) {\r\n\t\t\t\treturn 'advanced_tab';\r\n\t\t\t}\r\n\t\t\tif ( this.is_element_visible( builder_panel ) ) {\r\n\t\t\t\treturn 'builder_tab';\r\n\t\t\t}\r\n\r\n\t\t\treturn '';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Check element visibility.\r\n\t\t *\r\n\t\t * @param {HTMLElement|null} el\r\n\t\t *\r\n\t\t * @return {boolean}\r\n\t\t */\r\n\t\tis_element_visible( el ) {\r\n\t\t\tvar style;\r\n\r\n\t\t\tif ( ! el ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\tstyle = w.getComputedStyle( el );\r\n\r\n\t\t\tif ( ! style ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\tif ( 'none' === style.display ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\tif ( 'hidden' === style.visibility ) {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Check if Advanced Mode is active.\r\n\t\t *\r\n\t\t * @return {boolean}\r\n\t\t */\r\n\t\tis_advanced_mode_active() {\r\n\t\t\treturn ( 'advanced_tab' === this.get_active_top_tab_id() );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Show Code Tools tab button.\r\n\t\t *\r\n\t\t * @return {void}\r\n\t\t */\r\n\t\tshow_advanced_tools_tab() {\r\n\t\t\tthis.advanced_tab_wrap.removeAttribute( 'hidden' );\r\n\t\t\tthis.advanced_tab_wrap.setAttribute( 'aria-hidden', 'false' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Hide Code Tools tab button.\r\n\t\t *\r\n\t\t * @return {void}\r\n\t\t */\r\n\t\thide_advanced_tools_tab() {\r\n\t\t\tthis.advanced_tab_wrap.setAttribute( 'hidden', 'true' );\r\n\t\t\tthis.advanced_tab_wrap.setAttribute( 'aria-hidden', 'true' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Check if Code Tools panel is currently active.\r\n\t\t *\r\n\t\t * @return {boolean}\r\n\t\t */\r\n\t\tis_advanced_tools_panel_active() {\r\n\t\t\treturn !! ( this.advanced_panel && ! this.advanced_panel.hasAttribute( 'hidden' ) );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Open Code Tools panel.\r\n\t\t *\r\n\t\t * @return {void}\r\n\t\t */\r\n\t\topen_advanced_tools_panel() {\r\n\t\t\twpbc_bfb__dispatch_show_panel( 'wpbc_bfb__inspector_advanced_tools', 'wpbc_tab_advanced_tools' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Open default builder rightbar panel.\r\n\t\t *\r\n\t\t * @return {void}\r\n\t\t */\r\n\t\topen_default_visual_panel() {\r\n\t\t\twpbc_bfb__dispatch_show_panel( 'wpbc_bfb__palette_add_new', 'wpbc_tab_library' );\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Sync rightbar mode with top tabs mode.\r\n\t\t *\r\n\t\t * @return {void}\r\n\t\t */\r\n\t\tsync_rightbar_mode() {\r\n\t\t\tvar is_advanced_mode = this.is_advanced_mode_active();\r\n\r\n\t\t\tif ( is_advanced_mode ) {\r\n\t\t\t\tthis.show_advanced_tools_tab();\r\n\r\n\t\t\t\tif ( 'advanced' !== this.last_mode ) {\r\n\t\t\t\t\tthis.open_advanced_tools_panel();\r\n\t\t\t\t}\r\n\r\n\t\t\t\tthis.last_mode = 'advanced';\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tif ( this.is_advanced_tools_panel_active() ) {\r\n\t\t\t\tthis.open_default_visual_panel();\r\n\t\t\t}\r\n\r\n\t\t\tthis.hide_advanced_tools_tab();\r\n\t\t\tthis.last_mode = 'builder';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Fallback click handler for top tabs.\r\n\t\t *\r\n\t\t * @param {Event} event\r\n\t\t *\r\n\t\t * @return {void}\r\n\t\t */\r\n\t\thandle_click( event ) {\r\n\t\t\tvar target = event.target.closest( '[data-wpbc-bfb-tab]' );\r\n\t\t\tvar this_obj = this;\r\n\r\n\t\t\tif ( ! target ) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tsetTimeout(\r\n\t\t\t\tfunction () {\r\n\t\t\t\t\tthis_obj.sync_rightbar_mode();\r\n\t\t\t\t},\r\n\t\t\t\t0\r\n\t\t\t);\r\n\t\t}\r\n\t}\r\n\r\n\tif ( d.readyState === 'loading' ) {\r\n\t\td.addEventListener(\r\n\t\t\t'DOMContentLoaded',\r\n\t\t\tfunction () {\r\n\t\t\t\t( new WPBC_BFB_Mode_Rightbar_Sync() ).init();\r\n\t\t\t}\r\n\t\t);\r\n\t} else {\r\n\t\t( new WPBC_BFB_Mode_Rightbar_Sync() ).init();\r\n\t}\r\n\r\n})( window, document );","// ---------------------------------------------------------------------------------------------------------------------\r\n// == File  /includes/page-form-builder/_out/core/bfb-inspector.js == Time point: 2025-09-06 14:08\r\n// ---------------------------------------------------------------------------------------------------------------------\r\n(function (w) {\r\n\t'use strict';\r\n\r\n\t// 1) Actions registry.\r\n\r\n\t/** @type {Record<string, (ctx: InspectorActionContext) => void>} */\r\n\tconst __INSPECTOR_ACTIONS_MAP__ = Object.create( null );\r\n\r\n\t// Built-ins.\r\n\t__INSPECTOR_ACTIONS_MAP__['deselect'] = ({ builder }) => {\r\n\t\tbuilder?.select_field?.( null );\r\n\t};\r\n\r\n\t__INSPECTOR_ACTIONS_MAP__['scrollto'] = ({ builder, el }) => {\r\n\t\tif ( !el || !document.body.contains( el ) ) return;\r\n\t\tbuilder?.select_field?.( el, { scrollIntoView: true } );\r\n\t\tel.classList.add( 'wpbc_bfb__scroll-pulse' );\r\n\t\tsetTimeout( () => el.classList.remove( 'wpbc_bfb__scroll-pulse' ), 700 );\r\n\t};\r\n\r\n\t__INSPECTOR_ACTIONS_MAP__['move-up'] = ({ builder, el }) => {\r\n\t\tif ( !el ) return;\r\n\t\tbuilder?.move_item?.( el, 'up' );\r\n\t\t// Scroll after the DOM has settled.\r\n\t\trequestAnimationFrame(() => __INSPECTOR_ACTIONS_MAP__['scrollto']({ builder, el }));\r\n\t};\r\n\r\n\t__INSPECTOR_ACTIONS_MAP__['move-down'] = ({ builder, el }) => {\r\n\t\tif ( !el ) return;\r\n\t\tbuilder?.move_item?.( el, 'down' );\r\n\t\t// Scroll after the DOM has settled.\r\n\t\trequestAnimationFrame(() => __INSPECTOR_ACTIONS_MAP__['scrollto']({ builder, el }));\r\n\t};\r\n\r\n\t__INSPECTOR_ACTIONS_MAP__['delete'] = ({ builder, el, confirm = w.confirm }) => {\r\n\t\tif ( !el ) return;\r\n\t\tconst is_field = el.classList.contains( 'wpbc_bfb__field' );\r\n\t\tconst label    = is_field\r\n\t\t\t? (el.querySelector( '.wpbc_bfb__field-label' )?.textContent || el.dataset?.id || 'field')\r\n\t\t\t: (el.dataset?.id || 'section');\r\n\r\n\t\tUI.Modal_Confirm_Delete.open( label, () => {\r\n\t\t\t// Central command will remove, emit events, and reselect neighbor (which re-binds Inspector).\r\n\t\t\tbuilder?.delete_item?.( el );\r\n\t\t} );\r\n\r\n\t};\r\n\r\n\t__INSPECTOR_ACTIONS_MAP__['duplicate'] = ({ builder, el }) => {\r\n\t\tif ( !el ) return;\r\n\t\tconst clone = builder?.duplicate_item?.( el );\r\n\t\tif ( clone ) builder?.select_field?.( clone, { scrollIntoView: true } );\r\n\t};\r\n\r\n\t// Public API.\r\n\tw.WPBC_BFB_Inspector_Actions = {\r\n\t\trun(name, ctx) {\r\n\t\t\tconst fn = __INSPECTOR_ACTIONS_MAP__[name];\r\n\t\t\tif ( typeof fn === 'function' ) fn( ctx );\r\n\t\t\telse console.warn( 'WPBC. Inspector action not found:', name );\r\n\t\t},\r\n\t\tregister(name, handler) {\r\n\t\t\tif ( !name || typeof handler !== 'function' ) {\r\n\t\t\t\tthrow new Error( 'register(name, handler): invalid arguments' );\r\n\t\t\t}\r\n\t\t\t__INSPECTOR_ACTIONS_MAP__[name] = handler;\r\n\t\t},\r\n\t\thas(name) {\r\n\t\t\treturn typeof __INSPECTOR_ACTIONS_MAP__[name] === 'function';\r\n\t\t}\r\n\t};\r\n\r\n\t// 2) Inspector Factory.\r\n\r\n\tvar UI = (w.WPBC_BFB_Core.UI = w.WPBC_BFB_Core.UI || {});\r\n\r\n\t// Global Hybrid++ registries (keep public).\r\n\tw.wpbc_bfb_inspector_factory_slots      = w.wpbc_bfb_inspector_factory_slots || {};\r\n\tw.wpbc_bfb_inspector_factory_value_from = w.wpbc_bfb_inspector_factory_value_from || {};\r\n\r\n\t// Define Factory only if missing (no early return for the whole bundle).\r\n\t// always define/replace Factory\r\n\t{\r\n\r\n\t\t/**\r\n\t\t * Utility: create element with attributes and children.\r\n\t\t *\r\n\t\t * @param {string} tag\r\n\t\t * @param {Object=} attrs\r\n\t\t * @param {(Node|string|Array<Node|string>)=} children\r\n\t\t * @returns {HTMLElement}\r\n\t\t */\r\n\t\tfunction el(tag, attrs, children) {\r\n\t\t\tvar node = document.createElement( tag );\r\n\t\t\tif ( attrs ) {\r\n\t\t\t\tObject.keys( attrs ).forEach( function (k) {\r\n\t\t\t\t\tvar v = attrs[k];\r\n\t\t\t\t\tif ( v == null ) return;\r\n\t\t\t\t\tif ( k === 'class' ) {\r\n\t\t\t\t\t\tnode.className = v;\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( k === 'dataset' ) {\r\n\t\t\t\t\t\tObject.keys( v ).forEach( function (dk) {\r\n\t\t\t\t\t\t\tnode.dataset[dk] = String( v[dk] );\r\n\t\t\t\t\t\t} );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( k === 'checked' && typeof v === 'boolean' ) {\r\n\t\t\t\t\t\tif ( v ) node.setAttribute( 'checked', 'checked' );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( k === 'disabled' && typeof v === 'boolean' ) {\r\n\t\t\t\t\t\tif ( v ) node.setAttribute( 'disabled', 'disabled' );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// normalize boolean attributes to strings.\r\n\t\t\t\t\tif ( typeof v === 'boolean' ) {\r\n\t\t\t\t\t\tnode.setAttribute( k, v ? 'true' : 'false' );\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tnode.setAttribute( k, String( v ) );\r\n\t\t\t\t} );\r\n\t\t\t}\r\n\t\t\tif ( children ) {\r\n\t\t\t\t(Array.isArray( children ) ? children : [ children ]).forEach( function (c) {\r\n\t\t\t\t\tif ( c == null ) return;\r\n\t\t\t\t\tnode.appendChild( (typeof c === 'string') ? document.createTextNode( c ) : c );\r\n\t\t\t\t} );\r\n\t\t\t}\r\n\t\t\treturn node;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Build a toggle control row (checkbox rendered as toggle).\r\n\t\t *\r\n\t\t * Structure:\r\n\t\t * <div class=\"inspector__row inspector__row--toggle\">\r\n\t\t *   <div class=\"inspector__control wpbc_ui__toggle\">\r\n\t\t *     <input type=\"checkbox\" id=\"ID\" data-inspector-key=\"KEY\" class=\"inspector__input\" checked>\r\n\t\t *     <label class=\"wpbc_ui__toggle_icon\"  for=\"ID\"></label>\r\n\t\t *     <label class=\"wpbc_ui__toggle_label\" for=\"ID\">Label text</label>\r\n\t\t *   </div>\r\n\t\t * </div>\r\n\t\t *\r\n\t\t * @param {string} input_id\r\n\t\t * @param {string} key\r\n\t\t * @param {boolean} checked\r\n\t\t * @param {string} label_text\r\n\t\t * @returns {HTMLElement}\r\n\t\t */\r\n\t\tfunction build_toggle_row( input_id, key, checked, label_text ) {\r\n\r\n\t\t\tvar row_el    = el( 'div', { 'class': 'inspector__row inspector__row--toggle' } );\r\n\t\t\tvar ctrl_wrap = el( 'div', { 'class': 'inspector__control wpbc_ui__toggle' } );\r\n\r\n\t\t\tvar input_el = el( 'input', {\r\n\t\t\t\tid                  : input_id,\r\n\t\t\t\ttype                : 'checkbox',\r\n\t\t\t\t'data-inspector-key': key,\r\n\t\t\t\t'class'             : 'inspector__input',\r\n\t\t\t\tchecked             : !!checked,\r\n\t\t\t\trole                : 'switch',\r\n\t\t\t\t'aria-checked'      : !!checked\r\n\t\t\t} );\r\n\t\t\tvar icon_lbl = el( 'label', { 'class': 'wpbc_ui__toggle_icon', 'for': input_id } );\r\n\t\t\tvar text_lbl = el( 'label', { 'class': 'wpbc_ui__toggle_label', 'for': input_id }, label_text || '' );\r\n\r\n\t\t\tctrl_wrap.appendChild( input_el );\r\n\t\t\tctrl_wrap.appendChild( icon_lbl );\r\n\t\t\tctrl_wrap.appendChild( text_lbl );\r\n\r\n\t\t\trow_el.appendChild( ctrl_wrap );\r\n\t\t\treturn row_el;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t * Utility: choose initial value from data or schema default.\r\n\t */\r\n\t\tfunction get_initial_value(key, data, props_schema) {\r\n\t\t\tif ( data && Object.prototype.hasOwnProperty.call( data, key ) ) return data[key];\r\n\t\t\tvar meta = props_schema && props_schema[key];\r\n\t\t\treturn (meta && Object.prototype.hasOwnProperty.call( meta, 'default' )) ? meta.default : '';\r\n\t\t}\r\n\r\n\t\t/**\r\n\t * Utility: coerce value by schema type.\r\n\t */\r\n\r\n\r\n\t\tfunction coerce_by_type(value, type) {\r\n\t\t\tswitch ( type ) {\r\n\t\t\t\tcase 'number':\r\n\t\t\t\tcase 'int':\r\n\t\t\t\tcase 'float':\r\n\t\t\t\t\tif ( value === '' || value == null ) {\r\n\t\t\t\t\t\treturn '';\r\n\t\t\t\t\t}\r\n\t\t\t\t\tvar n = Number( value );\r\n\t\t\t\t\treturn isNaN( n ) ? '' : n;\r\n\t\t\t\tcase 'boolean':\r\n\t\t\t\t\treturn !!value;\r\n\t\t\t\tcase 'array':\r\n\t\t\t\t\treturn Array.isArray( value ) ? value : [];\r\n\t\t\t\tdefault:\r\n\t\t\t\t\treturn (value == null) ? '' : String( value );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/**\r\n\t * Normalize <select> options (array of {value,label} or map {value:label}).\r\n\t */\r\n\t\tfunction normalize_select_options(options) {\r\n\t\t\tif ( Array.isArray( options ) ) {\r\n\t\t\t\treturn options.map( function (o) {\r\n\t\t\t\t\tif ( typeof o === 'object' && o && 'value' in o ) {\r\n\t\t\t\t\t\treturn { value: String( o.value ), label: String( o.label || o.value ) };\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn { value: String( o ), label: String( o ) };\r\n\t\t\t\t} );\r\n\t\t\t}\r\n\t\t\tif ( options && typeof options === 'object' ) {\r\n\t\t\t\treturn Object.keys( options ).map( function (k) {\r\n\t\t\t\t\treturn { value: String( k ), label: String( options[k] ) };\r\n\t\t\t\t} );\r\n\t\t\t}\r\n\t\t\treturn [];\r\n\t\t}\r\n\r\n\t\t/** Parse a CSS length like \"120px\" or \"80%\" into { value:number, unit:string }. */\r\n\t\tfunction parse_len(value, fallback_unit) {\r\n\t\t\tvalue = (value == null) ? '' : String( value ).trim();\r\n\t\t\tvar m = value.match( /^(-?\\d+(?:\\.\\d+)?)(px|%|rem|em)$/i );\r\n\t\t\tif ( m ) {\r\n\t\t\t\treturn { value: parseFloat( m[1] ), unit: m[2].toLowerCase() };\r\n\t\t\t}\r\n\t\t\t// plain number -> assume fallback unit\r\n\t\t\tif ( value !== '' && !isNaN( Number( value ) ) ) {\r\n\t\t\t\treturn { value: Number( value ), unit: (fallback_unit || 'px') };\r\n\t\t\t}\r\n\t\t\treturn { value: 0, unit: (fallback_unit || 'px') };\r\n\t\t}\r\n\r\n\t\t/** Clamp helper. */\r\n\t\tfunction clamp_num(v, min, max) {\r\n\t\t\tif ( typeof v !== 'number' || isNaN( v ) ) return (min != null ? min : 0);\r\n\t\t\tif ( min != null && v < min ) v = min;\r\n\t\t\tif ( max != null && v > max ) v = max;\r\n\t\t\treturn v;\r\n\t\t}\r\n\r\n\t\t// Initialize Coloris pickers in a given root.\r\n\t\t// Relies on Coloris being enqueued (see bfb-bootstrap.php).\r\n\t\tfunction init_coloris_pickers(root) {\r\n\t\t\tif ( !root || !w.Coloris ) return;\r\n\t\t\t// Mark inputs we want Coloris to handle.\r\n\t\t\tvar inputs = root.querySelectorAll( 'input[data-inspector-type=\"color\"]' );\r\n\t\t\tif ( !inputs.length ) return;\r\n\r\n\t\t\t// Add a stable class for Coloris targeting; avoid double-initializing.\r\n\t\t\tinputs.forEach( function (input) {\r\n\t\t\t\tif ( input.classList.contains( 'wpbc_bfb_coloris' ) ) return;\r\n\t\t\t\tinput.classList.add( 'wpbc_bfb_coloris' );\r\n\t\t\t} );\r\n\r\n\t\t\t// Create/refresh a Coloris instance bound to these inputs.\r\n\t\t\t// Keep HEX output to match schema defaults (e.g., \"#e0e0e0\").\r\n\t\t\ttry {\r\n\t\t\t\tw.Coloris( {\r\n\t\t\t\t\tel       : '.wpbc_bfb_coloris',\r\n\t\t\t\t\talpha    : false,\r\n\t\t\t\t\tformat   : 'hex',\r\n\t\t\t\t\tthemeMode: 'auto'\r\n\t\t\t\t} );\r\n\t\t\t\t// Coloris already dispatches 'input' events on value changes.\r\n\t\t\t} catch ( e ) {\r\n\t\t\t\t// Non-fatal: if Coloris throws (rare), the text input still works.\r\n\t\t\t\tconsole.warn( 'WPBC Inspector: Coloris init failed:', e );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Build: slider + number in one row (writes to a single data key).\r\n\t\t * Control meta: { type:'range_number', key, label, min, max, step }\r\n\t\t */\r\n\t\tfunction build_range_number_row(input_id, key, label_text, value, meta) {\r\n\t\t\tvar row_el   = el('div', { 'class': 'inspector__row' });\r\n\t\t\tvar label_el = el('label', { 'for': input_id, 'class': 'inspector__label' }, label_text || key || '');\r\n\t\t\tvar ctrl     = el('div', { 'class': 'inspector__control' });\r\n\r\n\t\t\tvar min  = (meta && meta.min != null)  ? meta.min  : 0;\r\n\t\t\tvar max  = (meta && meta.max != null)  ? meta.max  : 100;\r\n\t\t\tvar step = (meta && meta.step != null) ? meta.step : 1;\r\n\r\n\t\t\tvar group = el('div', { 'class': 'wpbc_len_group wpbc_inline_inputs', 'data-len-group': key });\r\n\r\n\t\t\tvar range = el('input', {\r\n\t\t\t\ttype : 'range',\r\n\t\t\t\t'class': 'inspector__input',\r\n\t\t\t\t'data-len-range': '',\r\n\t\t\t\tmin  : String(min),\r\n\t\t\t\tmax  : String(max),\r\n\t\t\t\tstep : String(step),\r\n\t\t\t\tvalue: String(value == null || value === '' ? min : value)\r\n\t\t\t});\r\n\r\n\t\t\tvar num = el('input', {\r\n\t\t\t\tid   : input_id,\r\n\t\t\t\ttype : 'number',\r\n\t\t\t\t'class': 'inspector__input inspector__w_30',\r\n\t\t\t\t'data-len-value': '',\r\n\t\t\t\t'data-inspector-key': key,\r\n\t\t\t\tmin  : String(min),\r\n\t\t\t\tmax  : String(max),\r\n\t\t\t\tstep : String(step),\r\n\t\t\t\tvalue: (value == null || value === '') ? String(min) : String(value)\r\n\t\t\t});\r\n\r\n\t\t\tgroup.appendChild(range);\r\n\t\t\tgroup.appendChild(num);\r\n\t\t\tctrl.appendChild(group);\r\n\t\t\trow_el.appendChild(label_el);\r\n\t\t\trow_el.appendChild(ctrl);\r\n\t\t\treturn row_el;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Build: (number + unit) + slider, writing a *single* combined string to `key`.\r\n\t\t * Control meta:\r\n\t\t * {\r\n\t\t *   type:'len', key, label, units:['px','%','rem','em'],\r\n\t\t *   slider: { px:{min:0,max:512,step:1}, '%':{min:0,max:100,step:1}, rem:{min:0,max:10,step:0.1}, em:{...} },\r\n\t\t *   fallback_unit:'px'\r\n\t\t * }\r\n\t\t */\r\n\t\tfunction build_len_compound_row(control, props_schema, data, uid) {\r\n\t\t\tvar key        = control.key;\r\n\t\t\tvar label_text = control.label || key || '';\r\n\t\t\tvar def_str    = get_initial_value( key, data, props_schema );\r\n\t\t\tvar fallback_u = control.fallback_unit || 'px';\r\n\t\t\tvar parsed     = parse_len( def_str, fallback_u );\r\n\r\n\t\t\tvar row   = el( 'div', { 'class': 'inspector__row' } );\r\n\t\t\tvar label = el( 'label', { 'class': 'inspector__label' }, label_text );\r\n\t\t\tvar ctrl  = el( 'div', { 'class': 'inspector__control' } );\r\n\r\n\t\t\tvar units      = Array.isArray( control.units ) && control.units.length ? control.units : [ 'px', '%', 'rem', 'em' ];\r\n\t\t\tvar slider_map = control.slider || {\r\n\t\t\t\t'px' : { min: 0, max: 512, step: 1 },\r\n\t\t\t\t'%'  : { min: 0, max: 100, step: 1 },\r\n\t\t\t\t'rem': { min: 0, max: 10, step: 0.1 },\r\n\t\t\t\t'em' : { min: 0, max: 10, step: 0.1 }\r\n\t\t\t};\r\n\r\n\t\t\t// Host with a hidden input that carries data-inspector-key to reuse the standard handler.\r\n\t\t\tvar group = el( 'div', { 'class': 'wpbc_len_group', 'data-len-group': key } );\r\n\r\n\t\t\tvar inline = el( 'div', { 'class': 'wpbc_inline_inputs' } );\r\n\r\n\t\t\tvar num = el( 'input', {\r\n\t\t\t\ttype            : 'number',\r\n\t\t\t\t'class'         : 'inspector__input',\r\n\t\t\t\t'data-len-value': '',\r\n\t\t\t\tmin             : '0',\r\n\t\t\t\tstep            : 'any',\r\n\t\t\t\tvalue           : String( parsed.value )\r\n\t\t\t} );\r\n\r\n\t\t\tvar sel = el( 'select', { 'class': 'inspector__input', 'data-len-unit': '' } );\r\n\t\t\tunits.forEach( function (u) {\r\n\t\t\t\tvar opt = el( 'option', { value: u }, u );\r\n\t\t\t\tif ( u === parsed.unit ) opt.setAttribute( 'selected', 'selected' );\r\n\t\t\t\tsel.appendChild( opt );\r\n\t\t\t} );\r\n\r\n\t\t\tinline.appendChild( num );\r\n\t\t\tinline.appendChild( sel );\r\n\r\n\t\t\t// Slider (unit-aware)\r\n\t\t\tvar current = slider_map[parsed.unit] || slider_map[units[0]];\r\n\t\t\tvar range   = el( 'input', {\r\n\t\t\t\ttype            : 'range',\r\n\t\t\t\t'class'         : 'inspector__input',\r\n\t\t\t\t'data-len-range': '',\r\n\t\t\t\tmin             : String( current.min ),\r\n\t\t\t\tmax             : String( current.max ),\r\n\t\t\t\tstep            : String( current.step ),\r\n\t\t\t\tvalue           : String( clamp_num( parsed.value, current.min, current.max ) )\r\n\t\t\t} );\r\n\r\n\t\t\t// Hidden writer input that the default Inspector handler will catch.\r\n\t\t\tvar hidden = el( 'input', {\r\n\t\t\t\ttype                : 'text',\r\n\t\t\t\t'class'             : 'inspector__input',\r\n\t\t\t\tstyle               : 'display:none',\r\n\t\t\t\t'aria-hidden'       : 'true',\r\n\t\t\t\ttabindex            : '-1',\r\n\t\t\t\tid                  : 'wpbc_ins_' + key + '_' + uid + '_len_hidden',\r\n\t\t\t\t'data-inspector-key': key,\r\n\t\t\t\tvalue               : (String( parsed.value ) + parsed.unit)\r\n\t\t\t} );\r\n\r\n\t\t\tgroup.appendChild( inline );\r\n\t\t\tgroup.appendChild( range );\r\n\t\t\tgroup.appendChild( hidden );\r\n\r\n\t\t\tctrl.appendChild( group );\r\n\t\t\trow.appendChild( label );\r\n\t\t\trow.appendChild( ctrl );\r\n\t\t\treturn row;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Wire syncing for any .wpbc_len_group inside a given root (panel).\r\n\t\t * - range ⇄ number sync\r\n\t\t * - unit switches update slider bounds\r\n\t\t * - hidden writer (if present) gets updated and emits 'input'\r\n\t\t */\r\n\t\tfunction wire_len_group(root) {\r\n\t\t\tif ( !root ) return;\r\n\r\n\t\t\tfunction find_group(el) {\r\n\t\t\t\treturn el && el.closest && el.closest( '.wpbc_len_group' );\r\n\t\t\t}\r\n\r\n\t\t\troot.addEventListener( 'input', function (e) {\r\n\t\t\t\tvar t = e.target;\r\n\t\t\t\t// Slider moved -> update number (and writer/hidden)\r\n\t\t\t\tif ( t && t.hasAttribute( 'data-len-range' ) ) {\r\n\t\t\t\t\tvar g = find_group( t );\r\n\t\t\t\t\tif ( !g ) return;\r\n\t\t\t\t\tvar num = g.querySelector( '[data-len-value]' );\r\n\t\t\t\t\tif ( num ) {\r\n\t\t\t\t\t\tnum.value = t.value;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tvar writer = g.querySelector( '[data-inspector-key]' );\r\n\t\t\t\t\tif ( writer && writer.type === 'text' ) {\r\n\t\t\t\t\t\tvar unit     = g.querySelector( '[data-len-unit]' );\r\n\t\t\t\t\t\tunit         = unit ? unit.value : 'px';\r\n\t\t\t\t\t\twriter.value = String( t.value ) + String( unit );\r\n\t\t\t\t\t\t// trigger standard inspector handler:\r\n\t\t\t\t\t\twriter.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t// Plain range_number case (number has data-inspector-key) -> fire input on number\r\n\t\t\t\t\t\tif ( num && num.hasAttribute( 'data-inspector-key' ) ) {\r\n\t\t\t\t\t\t\tnum.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Number typed -> update slider and writer/hidden\r\n\t\t\t\tif ( t && t.hasAttribute( 'data-len-value' ) ) {\r\n\t\t\t\t\tvar g = find_group( t );\r\n\t\t\t\t\tif ( !g ) return;\r\n\t\t\t\t\tvar r = g.querySelector( '[data-len-range]' );\r\n\t\t\t\t\tif ( r ) {\r\n\t\t\t\t\t\t// clamp within slider bounds if present\r\n\t\t\t\t\t\tvar min = Number( r.min );\r\n\t\t\t\t\t\tvar max = Number( r.max );\r\n\t\t\t\t\t\tvar v   = Number( t.value );\r\n\t\t\t\t\t\tif ( !isNaN( v ) ) {\r\n\t\t\t\t\t\t\tv       = clamp_num( v, isNaN( min ) ? undefined : min, isNaN( max ) ? undefined : max );\r\n\t\t\t\t\t\t\tr.value = String( v );\r\n\t\t\t\t\t\t\tif ( String( v ) !== t.value ) t.value = String( v );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tvar writer = g.querySelector( '[data-inspector-key]' );\r\n\t\t\t\t\tif ( writer && writer.type === 'text' ) {\r\n\t\t\t\t\t\tvar unit     = g.querySelector( '[data-len-unit]' );\r\n\t\t\t\t\t\tunit         = unit ? unit.value : 'px';\r\n\t\t\t\t\t\twriter.value = String( t.value || 0 ) + String( unit );\r\n\t\t\t\t\t\twriter.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// else: number itself likely carries data-inspector-key (range_number); default handler will run.\r\n\t\t\t\t}\r\n\t\t\t}, true );\r\n\r\n\t\t\troot.addEventListener( 'change', function (e) {\r\n\t\t\t\tvar t = e.target;\r\n\t\t\t\t// Unit changed -> update slider limits and writer/hidden\r\n\t\t\t\tif ( t && t.hasAttribute( 'data-len-unit' ) ) {\r\n\t\t\t\t\tvar g = find_group( t );\r\n\t\t\t\t\tif ( !g ) return;\r\n\r\n\t\t\t\t\t// Find the control meta via a data attribute on group if provided\r\n\t\t\t\t\t// (Factory path sets nothing here; we re-derive from current slider bounds.)\r\n\t\t\t\t\tvar r      = g.querySelector( '[data-len-range]' );\r\n\t\t\t\t\tvar num    = g.querySelector( '[data-len-value]' );\r\n\t\t\t\t\tvar writer = g.querySelector( '[data-inspector-key]' );\r\n\t\t\t\t\tvar unit   = t.value || 'px';\r\n\r\n\t\t\t\t\t// Adjust slider bounds heuristically (match Factory defaults)\r\n\t\t\t\t\tvar bounds_by_unit = {\r\n\t\t\t\t\t\t'px' : { min: 0, max: 512, step: 1 },\r\n\t\t\t\t\t\t'%'  : { min: 0, max: 100, step: 1 },\r\n\t\t\t\t\t\t'rem': { min: 0, max: 10, step: 0.1 },\r\n\t\t\t\t\t\t'em' : { min: 0, max: 10, step: 0.1 }\r\n\t\t\t\t\t};\r\n\t\t\t\t\tif ( r ) {\r\n\t\t\t\t\t\tvar b  = bounds_by_unit[unit] || bounds_by_unit['px'];\r\n\t\t\t\t\t\tr.min  = String( b.min );\r\n\t\t\t\t\t\tr.max  = String( b.max );\r\n\t\t\t\t\t\tr.step = String( b.step );\r\n\t\t\t\t\t\t// clamp to new bounds\r\n\t\t\t\t\t\tvar v  = Number( num && num.value ? num.value : r.value );\r\n\t\t\t\t\t\tif ( !isNaN( v ) ) {\r\n\t\t\t\t\t\t\tv       = clamp_num( v, b.min, b.max );\r\n\t\t\t\t\t\t\tr.value = String( v );\r\n\t\t\t\t\t\t\tif ( num ) num.value = String( v );\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif ( writer && writer.type === 'text' ) {\r\n\t\t\t\t\t\tvar v        = num && num.value ? num.value : (r ? r.value : '0');\r\n\t\t\t\t\t\twriter.value = String( v ) + String( unit );\r\n\t\t\t\t\t\twriter.dispatchEvent( new Event( 'input', { bubbles: true } ) );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}, true );\r\n\t\t}\r\n\r\n\t\t// =============================================================================================================\r\n\t\t// ==  C O N T R O L  ==\r\n\t\t// =============================================================================================================\r\n\r\n\t\t/**\r\n\t * Schema > Inspector > Control Element, e.g. Input!  Build a single control row:\r\n\t * <div class=\"inspector__row\">\r\n\t *   <label class=\"inspector__label\" for=\"...\">Label</label>\r\n\t *   <div class=\"inspector__control\"><input|textarea|select class=\"inspector__input\" ...></div>\r\n\t * </div>\r\n\t *\r\n\t * @param {Object} control           - schema control meta ({type,key,label,...})\r\n\t * @param {Object} props_schema      - schema.props\r\n\t * @param {Object} data              - current element data-* map\r\n\t * @param {string} uid               - unique suffix for input ids\r\n\t * @param {Object} ctx               - { el, builder, type, data }\r\n\t * @returns {HTMLElement}\r\n\t */\r\n\t\tfunction build_control(control, props_schema, data, uid, ctx) {\r\n\t\t\tvar type = control.type;\r\n\t\t\tvar key  = control.key;\r\n\r\n\t\t\tvar label_text = control.label || key || '';\r\n\t\t\tvar prop_meta  = (key ? (props_schema[key] || { type: 'string' }) : { type: 'string' });\r\n\t\t\tvar value      = coerce_by_type( get_initial_value( key, data, props_schema ), prop_meta.type );\r\n\t\t// Allow value_from override (computed at render-time).\r\n\t\tif ( control && control.value_from && w.wpbc_bfb_inspector_factory_value_from[control.value_from] ) {\r\n\t\t\t\ttry {\r\n\t\t\t\t\tvar computed = w.wpbc_bfb_inspector_factory_value_from[control.value_from]( ctx || {} );\r\n\t\t\t\t\tvalue        = coerce_by_type( computed, prop_meta.type );\r\n\t\t\t\t} catch ( e ) {\r\n\t\t\t\t\tconsole.warn( 'value_from failed for', control.value_from, e );\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tvar input_id = 'wpbc_ins_' + key + '_' + uid;\r\n\r\n\t\t\tvar row_el    = el( 'div', { 'class': 'inspector__row' } );\r\n\t\t\tvar label_el  = el( 'label', { 'for': input_id, 'class': 'inspector__label' }, label_text );\r\n\t\t\tvar ctrl_wrap = el( 'div', { 'class': 'inspector__control' } );\r\n\r\n\t\t\tvar field_el;\r\n\r\n\t\t// --- slot host (named UI injection) -----------------------------------\r\n\t\tif ( type === 'slot' && control.slot ) {\r\n\t\t\t// add a marker class for the layout chips row\r\n\t\t\tvar classes = 'inspector__row inspector__row--slot';\r\n\t\t\tif ( control.slot === 'layout_chips' ) classes += ' inspector__row--layout-chips';\r\n\r\n\t\t\tvar slot_row = el( 'div', { 'class': classes } );\r\n\r\n\t\t\tif ( label_text ) slot_row.appendChild( el( 'label', { 'class': 'inspector__label' }, label_text ) );\r\n\r\n\t\t\t// add a data attribute on the host so both CSS and the safety-net can target it\r\n\t\t\tvar host_attrs = { 'class': 'inspector__control' };\r\n\t\t\tif ( control.slot === 'layout_chips' ) host_attrs['data-bfb-slot'] = 'layout_chips';\r\n\r\n\t\t\tvar slot_host = el( 'div', host_attrs );\r\n\t\t\tslot_row.appendChild( slot_host );\r\n\r\n\t\t\tvar slot_fn = w.wpbc_bfb_inspector_factory_slots[control.slot];\r\n\t\t\tif ( typeof slot_fn === 'function' ) {\r\n\t\t\t\tsetTimeout( function () {\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tslot_fn( slot_host, ctx || {} );\r\n\t\t\t\t\t} catch ( e ) {\r\n\t\t\t\t\t\tconsole.warn( 'slot \"' + control.slot + '\" failed:', e );\r\n\t\t\t\t\t}\r\n\t\t\t\t}, 0 );\r\n\t\t\t} else {\r\n\t\t\t\tslot_host.appendChild( el( 'div', { 'class': 'wpbc_bfb__slot__missing' }, '[slot: ' + control.slot + ']' ) );\r\n\t\t\t}\r\n\t\t\treturn slot_row;\r\n\t\t}\r\n\r\n\r\n\t\t\tif ( type === 'textarea' ) {\r\n\t\t\t\tfield_el = el( 'textarea', {\r\n\t\t\t\t\tid                  : input_id,\r\n\t\t\t\t\t'data-inspector-key': key,\r\n\t\t\t\t\trows                : control.rows || 3,\r\n\t\t\t\t\t'class'             : 'inspector__input'\r\n\t\t\t\t}, (value == null ? '' : String( value )) );\r\n\t\t\t} else if ( type === 'select' ) {\r\n\t\t\t\tfield_el = el( 'select', {\r\n\t\t\t\t\tid                  : input_id,\r\n\t\t\t\t\t'data-inspector-key': key,\r\n\t\t\t\t\t'class'             : 'inspector__input'\r\n\t\t\t\t} );\r\n\t\t\t\tnormalize_select_options( control.options || [] ).forEach( function (opt) {\r\n\t\t\t\t\tvar opt_el = el( 'option', { value: opt.value }, opt.label );\r\n\t\t\t\t\tif ( String( value ) === opt.value ) opt_el.setAttribute( 'selected', 'selected' );\r\n\t\t\t\t\tfield_el.appendChild( opt_el );\r\n\t\t\t\t} );\r\n\t\t\t} else if ( type === 'checkbox' ) {\r\n\t\t\t\t// field_el = el( 'input', { id: input_id, type: 'checkbox', 'data-inspector-key': key, checked: !!value, 'class': 'inspector__input' } ); //.\r\n\r\n\t\t\t\t// Render as toggle UI instead of label-left + checkbox.  Note: we return the full toggle row here and skip the default row/label flow below.\r\n\t\t\t\treturn build_toggle_row( input_id, key, !!value, label_text );\r\n\r\n\t\t\t} else if ( type === 'range_number' ) {\r\n\t\t\t\t// --- new: slider + number (single key).\r\n\t\t\t\tvar rn_id  = 'wpbc_ins_' + key + '_' + uid;\r\n\t\t\t\tvar rn_val = value; // from get_initial_value/prop_meta already.\r\n\t\t\t\treturn build_range_number_row( rn_id, key, label_text, rn_val, control );\r\n\r\n\t\t\t} else if ( type === 'len' ) {\r\n\t\t\t\t// --- new: length compound (value+unit+slider -> writes a single string key).\r\n\t\t\t\treturn build_len_compound_row( control, props_schema, data, uid );\r\n\r\n\t\t\t} else if ( type === 'color' ) {\r\n\t\t\t\t// Color picker (Coloris). Store as string (e.g., \"#e0e0e0\").\r\n\t\t\t\tfield_el = el( 'input', {\r\n\t\t\t\t\tid                   : input_id,\r\n\t\t\t\t\ttype                 : 'text',\r\n\t\t\t\t\t'data-inspector-key' : key,\r\n\t\t\t\t\t'data-inspector-type': 'color',\r\n\t\t\t\t\t'data-coloris'       : '',\r\n\t\t\t\t\t'class'              : 'inspector__input',\r\n\t\t\t\t\t'data-default-color' : ( value != null && value !== '' ? String(value) : (control.placeholder || '') )\r\n\t\t\t\t} );\r\n\t\t\t\tif ( value !== '' ) {\r\n\t\t\t\t\tfield_el.value = String( value );\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\t// text/number default.\r\n\t\t\t\tvar attrs = {\r\n\t\t\t\t\tid                  : input_id,\r\n\t\t\t\t\ttype                : (type === 'number') ? 'number' : 'text',\r\n\t\t\t\t\t'data-inspector-key': key,\r\n\t\t\t\t\t'class'             : 'inspector__input'\r\n\t\t\t\t};\r\n\t\t\t// number constraints (schema or control)\r\n\t\t\t\tif ( type === 'number' ) {\r\n\t\t\t\t\tif ( Object.prototype.hasOwnProperty.call( prop_meta, 'min' ) ) attrs.min = prop_meta.min;\r\n\t\t\t\t\tif ( Object.prototype.hasOwnProperty.call( prop_meta, 'max' ) ) attrs.max = prop_meta.max;\r\n\t\t\t\t\tif ( Object.prototype.hasOwnProperty.call( prop_meta, 'step' ) ) attrs.step = prop_meta.step;\r\n\t\t\t\t\tif ( Object.prototype.hasOwnProperty.call( control, 'min' ) ) attrs.min = control.min;\r\n\t\t\t\t\tif ( Object.prototype.hasOwnProperty.call( control, 'max' ) ) attrs.max = control.max;\r\n\t\t\t\t\tif ( Object.prototype.hasOwnProperty.call( control, 'step' ) ) attrs.step = control.step;\r\n\t\t\t\t}\r\n\t\t\t\tfield_el = el( 'input', attrs );\r\n\t\t\t\tif ( value !== '' ) field_el.value = String( value );\r\n\t\t\t}\r\n\r\n\t\t\tctrl_wrap.appendChild( field_el );\r\n\t\t\trow_el.appendChild( label_el );\r\n\t\t\trow_el.appendChild( ctrl_wrap );\r\n\t\t\treturn row_el;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Schema > Inspector > Groups! Build an inspector group (collapsible).\r\n\t\t * Structure:\r\n\t\t * <section class=\"wpbc_bfb__inspector__group wpbc_ui__collapsible_group is-open\" data-group=\"...\">\r\n\t\t *   <button type=\"button\" class=\"group__header\" role=\"button\" aria-expanded=\"true\" aria-controls=\"wpbc_collapsible_panel_X\">\r\n\t\t *     <h3>Group Title</h3>\r\n\t\t *     <i class=\"wpbc_ui_el__vert_menu_root_section_icon menu_icon icon-1x wpbc-bi-chevron-right\"></i>\r\n\t\t *   </button>\r\n\t\t *   <div class=\"group__fields\" id=\"wpbc_collapsible_panel_X\" aria-hidden=\"false\"> …rows… </div>\r\n\t\t * </section>\r\n\t\t *\r\n\t\t * @param {Object} group\r\n\t\t * @param {Object} props_schema\r\n\t\t * @param {Object} data\r\n\t\t * @param {string} uid\r\n\t\t * @param {Object} ctx\r\n\t\t * @returns {HTMLElement}\r\n\t\t */\r\n\t\tfunction build_group(group, props_schema, data, uid, ctx) {\r\n\t\t\tvar is_open  = !!group.open;\r\n\t\t\tvar panel_id = 'wpbc_collapsible_panel_' + uid + '_' + (group.key || 'g');\r\n\r\n\t\t\tvar section = el( 'section', {\r\n\t\t\t\t'class'     : 'wpbc_bfb__inspector__group wpbc_ui__collapsible_group' + (is_open ? ' is-open' : ''),\r\n\t\t\t\t'data-group': group.key || ''\r\n\t\t\t} );\r\n\r\n\t\t\tvar header_btn = el( 'button', {\r\n\t\t\t\ttype           : 'button',\r\n\t\t\t\t'class'        : 'group__header',\r\n\t\t\t\trole           : 'button',\r\n\t\t\t\t'aria-expanded': is_open ? 'true' : 'false',\r\n\t\t\t\t'aria-controls': panel_id\r\n\t\t\t}, [\r\n\t\t\t\tel( 'h3', null, group.title || group.label || group.key || '' ),\r\n\t\t\t\tel( 'i', { 'class': 'wpbc_ui_el__vert_menu_root_section_icon menu_icon icon-1x wpbc-bi-chevron-right' } )\r\n\t\t\t] );\r\n\r\n\t\t\tvar fields = el( 'div', {\r\n\t\t\t\t'class'      : 'group__fields',\r\n\t\t\t\tid           : panel_id,\r\n\t\t\t\t'aria-hidden': is_open ? 'false' : 'true'\r\n\t\t\t} );\r\n\r\n\t\t\tfunction asArray(x) {\r\n\t\t\t\tif ( Array.isArray( x ) ) return x;\r\n\t\t\t\tif ( x && typeof x === 'object' ) return Object.values( x );\r\n\t\t\t\treturn x != null ? [ x ] : [];\r\n\t\t\t}\r\n\r\n\t\t\tasArray( group.controls ).forEach( function (control) {\r\n\t\t\t\tfields.appendChild( build_control( control, props_schema, data, uid, ctx ) );\r\n\t\t\t} );\r\n\r\n\t\t\tsection.appendChild( header_btn );\r\n\t\t\tsection.appendChild( fields );\r\n\t\t\treturn section;\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Schema > Inspector > Header! Build inspector header with action buttons wired to existing data-action handlers.\r\n\t\t *\r\n\t\t * @param {Array<string>} header_actions\r\n\t\t * @param {string}        title_text\r\n\t\t * @returns {HTMLElement}\r\n\t\t */\r\n\t\tfunction build_header(inspector_ui, title_fallback, schema_for_type) {\r\n\r\n\t\t\tinspector_ui      = inspector_ui || {};\r\n\t\t\tschema_for_type   = schema_for_type || {};\r\n\t\t\tvar variant       = inspector_ui.header_variant || 'minimal';\r\n\t\t\tvar headerActions = inspector_ui.header_actions\r\n\t\t\t\t|| schema_for_type.header_actions\r\n\t\t\t\t|| [ 'deselect', 'scrollto', 'move-up', 'move-down', 'duplicate', 'delete' ];\r\n\r\n\t\t\tvar title       = inspector_ui.title || title_fallback || '';\r\n\t\t\tvar description = inspector_ui.description || '';\r\n\r\n\t\t\t// helper to create a button for either header style\r\n\t\t\tfunction actionBtn(act, minimal) {\r\n\t\t\t\tif ( minimal ) {\r\n\t\t\t\t\treturn el( 'button', { type: 'button', 'class': 'button-link', 'data-action': act }, '' );\r\n\t\t\t\t}\r\n\t\t\t\t// toolbar variant (rich)\r\n\t\t\t\tvar iconMap = {\r\n\t\t\t\t\t'deselect' : 'wpbc_icn_near_me_disabled',\r\n\t\t\t\t\t'scrollto' : 'wpbc_icn_ads_click filter_center_focus',\r\n\t\t\t\t\t'move-up'  : 'wpbc_icn_arrow_upward',\r\n\t\t\t\t\t'move-down': 'wpbc_icn_arrow_downward',\r\n\t\t\t\t\t'duplicate': 'wpbc_icn_content_copy',\r\n\t\t\t\t\t'delete'   : 'wpbc_icn_delete_outline'\r\n\t\t\t\t};\r\n\t\t\t\tvar classes = 'button button-secondary wpbc_ui_control wpbc_ui_button';\r\n\t\t\t\tif ( act === 'delete' ) classes += ' wpbc_ui_button_danger button-link-delete';\r\n\r\n\t\t\t\tvar btn = el( 'button', {\r\n\t\t\t\t\ttype         : 'button',\r\n\t\t\t\t\t'class'      : classes,\r\n\t\t\t\t\t'data-action': act,\r\n\t\t\t\t\t'aria-label' : act.replace( /-/g, ' ' )\r\n\t\t\t\t} );\r\n\r\n\t\t\t\tif ( act === 'delete' ) {\r\n\t\t\t\t\tbtn.appendChild( el( 'span', { 'class': 'in-button-text' }, 'Delete' ) );\r\n\t\t\t\t\tbtn.appendChild( document.createTextNode( ' ' ) ); // minor spacing before icon\r\n\t\t\t\t}\r\n\t\t\t\tbtn.appendChild( el( 'i', { 'class': 'menu_icon icon-1x ' + (iconMap[act] || '') } ) );\r\n\t\t\t\treturn btn;\r\n\t\t\t}\r\n\r\n\t\t\t// === minimal header (existing look; default) ===\r\n\t\t\tif ( variant !== 'toolbar' ) {\r\n\t\t\t\tvar header = el( 'header', { 'class': 'wpbc_bfb__inspector__header' } );\r\n\t\t\t\theader.appendChild( el( 'h3', null, title || '' ) );\r\n\r\n\t\t\t\tvar actions = el( 'div', { 'class': 'wpbc_bfb__inspector__header_actions' } );\r\n\t\t\t\theaderActions.forEach( function (act) {\r\n\t\t\t\t\tactions.appendChild( actionBtn( act, /*minimal*/true ) );\r\n\t\t\t\t} );\r\n\t\t\t\theader.appendChild( actions );\r\n\t\t\t\treturn header;\r\n\t\t\t}\r\n\r\n\t\t\t// === toolbar header (rich title/desc + grouped buttons) ===\r\n\t\t\tvar root = el( 'div', { 'class': 'wpbc_bfb__inspector__head' } );\r\n\t\t\tvar wrap = el( 'div', { 'class': 'header_container' } );\r\n\t\t\tvar left = el( 'div', { 'class': 'header_title_content' } );\r\n\t\t\tvar h3   = el( 'h3', { 'class': 'title' }, title || '' );\r\n\t\t\tleft.appendChild( h3 );\r\n\t\t\tif ( description ) {\r\n\t\t\t\tleft.appendChild( el( 'div', { 'class': 'desc' }, description ) );\r\n\t\t\t}\r\n\r\n\t\t\tvar right = el( 'div', { 'class': 'actions wpbc_ajx_toolbar wpbc_no_borders' } );\r\n\t\t\tvar uiC   = el( 'div', { 'class': 'ui_container ui_container_small' } );\r\n\t\t\tvar uiG   = el( 'div', { 'class': 'ui_group' } );\r\n\r\n\t\t\t// Split into visual groups: first 2, next 2, then the rest.\r\n\t\t\tvar g1 = el( 'div', { 'class': 'ui_element' } );\r\n\t\t\tvar g2 = el( 'div', { 'class': 'ui_element' } );\r\n\t\t\tvar g3 = el( 'div', { 'class': 'ui_element' } );\r\n\r\n\t\t\theaderActions.slice( 0, 2 ).forEach( function (act) {\r\n\t\t\t\tg1.appendChild( actionBtn( act, false ) );\r\n\t\t\t} );\r\n\t\t\theaderActions.slice( 2, 4 ).forEach( function (act) {\r\n\t\t\t\tg2.appendChild( actionBtn( act, false ) );\r\n\t\t\t} );\r\n\t\t\theaderActions.slice( 4 ).forEach( function (act) {\r\n\t\t\t\tg3.appendChild( actionBtn( act, false ) );\r\n\t\t\t} );\r\n\r\n\t\t\tuiG.appendChild( g1 );\r\n\t\t\tuiG.appendChild( g2 );\r\n\t\t\tuiG.appendChild( g3 );\r\n\t\t\tuiC.appendChild( uiG );\r\n\t\t\tright.appendChild( uiC );\r\n\r\n\t\t\twrap.appendChild( left );\r\n\t\t\twrap.appendChild( right );\r\n\t\t\troot.appendChild( wrap );\r\n\r\n\t\t\treturn root;\r\n\t\t}\r\n\r\n\r\n\t\tfunction factory_render(panel_el, schema_for_type, data, opts) {\r\n\t\t\tif ( !panel_el ) return panel_el;\r\n\r\n\t\t\tschema_for_type  = schema_for_type || {};\r\n\t\t\tvar props_schema = (schema_for_type.schema && schema_for_type.schema.props) ? schema_for_type.schema.props : {};\r\n\t\t\tvar inspector_ui = (schema_for_type.inspector_ui || {});\r\n\t\t\tvar groups       = inspector_ui.groups || [];\r\n\r\n\t\t\tvar header_actions = inspector_ui.header_actions || schema_for_type.header_actions || [];\r\n\t\t\tvar title_text     = (opts && opts.title) || inspector_ui.title || schema_for_type.label || (data && data.label) || '';\r\n\r\n\t\t// Prepare rendering context for slots/value_from, etc.\r\n\t\t\tvar ctx = {\r\n\t\t\t\tel     : opts && opts.el || null,\r\n\t\t\t\tbuilder: opts && opts.builder || null,\r\n\t\t\t\ttype   : opts && opts.type || null,\r\n\t\t\t\tdata   : data || {}\r\n\t\t\t};\r\n\r\n\t\t\t// clear panel.\r\n\t\t\twhile ( panel_el.firstChild ) panel_el.removeChild( panel_el.firstChild );\r\n\r\n\t\t\tvar uid = Math.random().toString( 36 ).slice( 2, 8 );\r\n\r\n\t\t\t// header.\r\n\t\t\tpanel_el.appendChild( build_header( inspector_ui, title_text, schema_for_type ) );\r\n\r\n\r\n\t\t\t// groups.\r\n\t\t\tgroups.forEach( function (g) {\r\n\t\t\t\tpanel_el.appendChild( build_group( g, props_schema, data || {}, uid, ctx ) );\r\n\t\t\t} );\r\n\r\n\t\t\t// ARIA sync for toggles created here (ensure aria-checked matches state).\r\n\t\t\ttry {\r\n\t\t\t\t// Centralized UI normalizers (toggles + A11y): handled in Core.\r\n\t\t\t\tUI.apply_post_render( panel_el );\r\n\t\t\t\ttry {\r\n\t\t\t\t\twire_len_group( panel_el );\r\n\t\t\t\t\t// Initialize Coloris on color inputs rendered in this panel.\r\n\t\t\t\t\tinit_coloris_pickers( panel_el );\r\n\t\t\t\t} catch ( _ ) { }\r\n\t\t\t} catch ( _ ) { }\r\n\r\n\t\t\treturn panel_el;\r\n\t\t}\r\n\r\n\t\tUI.WPBC_BFB_Inspector_Factory = { render: factory_render };   // overwrite/refresh\r\n\r\n\t\t// ---- Built-in slot + value_from for Sections ----\r\n\r\n\t\tfunction slot_layout_chips(host, ctx) {\r\n\t\t\ttry {\r\n\t\t\t\tvar L = w.WPBC_BFB_Core &&  w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Layout_Chips;\r\n\t\t\t\tif ( L && typeof L.render_for_section === 'function' ) {\r\n\t\t\t\t\tL.render_for_section( ctx.builder, ctx.el, host );\r\n\t\t\t\t} else {\r\n\t\t\t\t\thost.appendChild( document.createTextNode( '[layout_chips not available]' ) );\r\n\t\t\t\t}\r\n\t\t\t} catch ( e ) {\r\n\t\t\t\tconsole.warn( 'wpbc_bfb_slot_layout_chips failed:', e );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tw.wpbc_bfb_inspector_factory_slots.layout_chips = slot_layout_chips;\r\n\r\n\t\tfunction value_from_compute_section_columns(ctx) {\r\n\t\t\ttry {\r\n\t\t\t\tvar row = ctx && ctx.el && ctx.el.querySelector && ctx.el.querySelector( ':scope > .wpbc_bfb__row' );\r\n\t\t\t\tif ( !row ) return 1;\r\n\t\t\t\tvar n = row.querySelectorAll( ':scope > .wpbc_bfb__column' ).length || 1;\r\n\t\t\t\tif ( n < 1 ) n = 1;\r\n\t\t\t\tif ( n > 4 ) n = 4;\r\n\t\t\t\treturn n;\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t\treturn 1;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tw.wpbc_bfb_inspector_factory_value_from.compute_section_columns = value_from_compute_section_columns;\r\n\t}\r\n\r\n\t// 3) Inspector class.\r\n\r\n\tclass WPBC_BFB_Inspector {\r\n\r\n\t\tconstructor(panel_el, builder) {\r\n\t\t\tthis.panel         = panel_el || this._create_fallback_panel();\r\n\t\t\tthis.builder       = builder;\r\n\t\t\tthis.selected_el   = null;\r\n\t\t\tthis._render_timer = null;\r\n\r\n\t\t\tthis._on_delegated_input  = (e) => this._apply_control_from_event( e );\r\n\t\t\tthis._on_delegated_change = (e) => this._apply_control_from_event( e );\r\n\t\t\tthis.panel.addEventListener( 'input', this._on_delegated_input, true );\r\n\t\t\tthis.panel.addEventListener( 'change', this._on_delegated_change, true );\r\n\r\n\t\t\tthis._on_delegated_click = (e) => {\r\n\t\t\t\tconst btn = e.target.closest( '[data-action]' );\r\n\t\t\t\tif ( !btn || !this.panel.contains( btn ) ) return;\r\n\t\t\t\te.preventDefault();\r\n\t\t\t\te.stopPropagation();\r\n\r\n\t\t\t\tconst action = btn.getAttribute( 'data-action' );\r\n\t\t\t\tconst el     = this.selected_el;\r\n\t\t\t\tif ( !el ) return;\r\n\r\n\t\t\t\tw.WPBC_BFB_Inspector_Actions?.run( action, {\r\n\t\t\t\t\tbuilder: this.builder,\r\n\t\t\t\t\tel,\r\n\t\t\t\t\tpanel  : this.panel,\r\n\t\t\t\t\tevent  : e\r\n\t\t\t\t} );\r\n\r\n\t\t\t\tif ( action === 'delete' ) this.clear();\r\n\t\t\t};\r\n\t\t\tthis.panel.addEventListener( 'click', this._on_delegated_click );\r\n\t\t}\r\n\r\n\t\t_post_render_ui() {\r\n\t\t\ttry {\r\n\t\t\t\tvar UI = w.WPBC_BFB_Core && w.WPBC_BFB_Core.UI;\r\n\t\t\t\tif ( UI && typeof UI.apply_post_render === 'function' ) {\r\n\t\t\t\t\tUI.apply_post_render( this.panel );\r\n\t\t\t\t}\r\n\t\t\t\t// NEW: wire slider/number/unit syncing for length & range_number groups.\r\n\t\t\t\ttry {\r\n\t\t\t\t\twire_len_group( this.panel );\r\n\t\t\t\t\tinit_coloris_pickers( this.panel );\r\n\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t}\r\n\t\t\t} catch ( e ) {\r\n\t\t\t\t_wpbc?.dev?.error?.( 'inspector._post_render_ui', e );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\t_apply_control_from_event(e) {\r\n\t\t\tif ( !this.panel.contains( e.target ) ) return;\r\n\r\n\t\t\tconst t   = /** @type {HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement} */ (e.target);\r\n\t\t\tconst key = t?.dataset?.inspectorKey;\r\n\t\t\tif ( !key ) return;\r\n\r\n\t\t\tconst el = this.selected_el;\r\n\t\t\tif ( !el || !document.body.contains( el ) ) return;\r\n\r\n\t\t\tlet v;\r\n\t\t\tif ( t instanceof HTMLInputElement && t.type === 'checkbox' ) {\r\n\t\t\t\tv = !!t.checked;\r\n\t\t\t\tt.setAttribute( 'aria-checked', v ? 'true' : 'false' );         // Keep ARIA state in sync for toggles (schema and template paths).\r\n\t\t\t} else if ( t instanceof HTMLInputElement && t.type === 'number' ) {\r\n\t\t\t\tv = (t.value === '' ? '' : Number( t.value ));\r\n\t\t\t} else {\r\n\t\t\t\tv = t.value;\r\n\t\t\t}\r\n\r\n\t\t\tif ( key === 'id' ) {\r\n\t\t\t\tconst unique = this.builder?.id?.set_field_id?.( el, v );\r\n\t\t\t\tif ( unique != null && t.value !== unique ) t.value = unique;\r\n\r\n\t\t\t} else if ( key === 'name' ) {\r\n\t\t\t\tconst unique = this.builder?.id?.set_field_name?.( el, v );\r\n\t\t\t\tif ( unique != null && t.value !== unique ) t.value = unique;\r\n\r\n\t\t\t} else if ( key === 'html_id' ) {\r\n\t\t\t\tconst applied = this.builder?.id?.set_field_html_id?.( el, v );\r\n\t\t\t\tif ( applied != null && t.value !== applied ) t.value = applied;\r\n\r\n\t\t\t} else if ( key === 'columns' && el.classList.contains( 'wpbc_bfb__section' ) ) {\r\n\t\t\t\tconst v_int = parseInt( String( v ), 10 );\r\n\t\t\t\tif ( Number.isFinite( v_int ) ) {\r\n\t\t\t\t\tconst clamped = w.WPBC_BFB_Core.WPBC_BFB_Sanitize.clamp( v_int, 1, 4 );\r\n\t\t\t\t\tthis.builder?.set_section_columns?.( el, clamped );\r\n\t\t\t\t\tif ( String( clamped ) !== t.value ) t.value = String( clamped );\r\n\t\t\t\t}\r\n\r\n\t\t\t} else {\r\n\t\t\t\tif ( t instanceof HTMLInputElement && t.type === 'checkbox' ) {\r\n\t\t\t\t\tel.setAttribute( 'data-' + key, String( !!v ) );\r\n\t\t\t\t} else if ( t instanceof HTMLInputElement && t.type === 'number' ) {\r\n\t\t\t\t\tif ( t.value === '' || !Number.isFinite( v ) ) {\r\n\t\t\t\t\t\tel.removeAttribute( 'data-' + key );\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tel.setAttribute( 'data-' + key, String( v ) );\r\n\t\t\t\t\t}\r\n\t\t\t\t} else if ( v == null ) {\r\n\t\t\t\t\tel.removeAttribute( 'data-' + key );\r\n\t\t\t\t} else {\r\n\t\t\t\t\tel.setAttribute( 'data-' + key, (typeof v === 'object') ? JSON.stringify( v ) : String( v ) );\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// Update preview/overlay\r\n\t\t\tif ( el.classList.contains( 'wpbc_bfb__field' ) ) {\r\n\t\t\t\tif ( this.builder?.preview_mode ) this.builder.render_preview( el );\r\n\t\t\t\telse this.builder.add_overlay_toolbar( el );\r\n\t\t\t} else {\r\n\t\t\t\tthis.builder.add_overlay_toolbar( el );\r\n\t\t\t}\r\n\r\n\t\t\tif ( this._needs_rerender( el, key, e ) ) {\r\n\t\t\t\tthis._schedule_render_preserving_focus( 0 );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t_needs_rerender(el, key, _e) {\r\n\t\t\tif ( el.classList.contains( 'wpbc_bfb__section' ) && key === 'columns' ) return true;\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tbind_to_field(field_el) {\r\n\t\t\tthis.selected_el = field_el;\r\n\t\t\tthis.render();\r\n\t\t}\r\n\r\n\t\tclear() {\r\n\t\t\tthis.selected_el = null;\r\n\t\t\tif ( this._render_timer ) {\r\n\t\t\t\tclearTimeout( this._render_timer );\r\n\t\t\t\tthis._render_timer = null;\r\n\t\t\t}\r\n\t\t\t// Also clear the section-cols hint on empty state.\r\n\t\t\tthis.panel.removeAttribute('data-bfb-section-cols');\r\n\t\t\tthis.panel.innerHTML = '<div class=\"wpbc_bfb__inspector__empty\">Select a field to edit its options.</div>';\r\n\t\t}\r\n\r\n\t\t_schedule_render_preserving_focus(delay = 200) {\r\n\t\t\tconst active    = /** @type {HTMLInputElement|HTMLTextAreaElement|HTMLElement|null} */ (document.activeElement);\r\n\t\t\tconst activeKey = active?.dataset?.inspectorKey || null;\r\n\t\t\tlet selStart    = null, selEnd = null;\r\n\r\n\t\t\tif ( active && 'selectionStart' in active && 'selectionEnd' in active ) {\r\n\t\t\t\t// @ts-ignore\r\n\t\t\t\tselStart = active.selectionStart;\r\n\t\t\t\t// @ts-ignore\r\n\t\t\t\tselEnd   = active.selectionEnd;\r\n\t\t\t}\r\n\r\n\t\t\tif ( this._render_timer ) clearTimeout( this._render_timer );\r\n\t\t\tthis._render_timer = /** @type {unknown} */ (setTimeout( () => {\r\n\t\t\t\tthis.render();\r\n\t\t\t\tif ( activeKey ) {\r\n\t\t\t\t\tconst next = /** @type {HTMLInputElement|HTMLTextAreaElement|HTMLElement|null} */ (\r\n\t\t\t\t\t\tthis.panel.querySelector( `[data-inspector-key=\"${activeKey}\"]` )\r\n\t\t\t\t\t);\r\n\t\t\t\t\tif ( next ) {\r\n\t\t\t\t\t\tnext.focus();\r\n\t\t\t\t\t\ttry {\r\n\t\t\t\t\t\t\tif ( selStart != null && selEnd != null && typeof next.setSelectionRange === 'function' ) {\r\n\t\t\t\t\t\t\t\t// @ts-ignore\r\n\t\t\t\t\t\t\t\tnext.setSelectionRange( selStart, selEnd );\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} catch( e ){ _wpbc?.dev?.error( '_render_timer', e ); }\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}, delay ));\r\n\t\t}\r\n\r\n\t\trender() {\r\n\r\n\t\t\tconst el = this.selected_el;\r\n\t\t\tif ( !el || !document.body.contains( el ) ) return this.clear();\r\n\r\n\t\t\t// Reset section-cols hint unless we set it later for a section.\r\n\t\t\tthis.panel.removeAttribute( 'data-bfb-section-cols' );\r\n\r\n\t\t\tconst prev_scroll = this.panel.scrollTop;\r\n\r\n\t\t\t// Section\r\n\t\t\tif ( el.classList.contains( 'wpbc_bfb__section' ) ) {\r\n\t\t\t\tlet tpl = null;\r\n\t\t\t\ttry {\r\n\t\t\t\t\ttpl = (w.wp && wp.template && document.getElementById( 'tmpl-wpbc-bfb-inspector-section' )) ? wp.template( 'wpbc-bfb-inspector-section' ) : null;\r\n\t\t\t\t} catch ( _ ) {\r\n\t\t\t\t\ttpl = null;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif ( tpl ) {\r\n\t\t\t\t\tthis.panel.innerHTML = tpl( {} );\r\n\t\t\t\t\tthis._enforce_default_group_open();\r\n\t\t\t\t\tthis._set_panel_section_cols( el );\r\n\t\t\t\t\tthis._post_render_ui();\r\n\t\t\t\t\tthis.panel.scrollTop = prev_scroll;\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst Factory = w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Inspector_Factory;\r\n\t\t\t\tconst schemas = w.WPBC_BFB_Schemas || {};\r\n\t\t\t\tconst entry   = schemas['section'] || null;\r\n\t\t\t\tif ( entry && Factory ) {\r\n\t\t\t\t\tthis.panel.innerHTML = '';\r\n\t\t\t\t\tFactory.render(\r\n\t\t\t\t\t\tthis.panel,\r\n\t\t\t\t\t\tentry,\r\n\t\t\t\t\t\t{},\r\n\t\t\t\t\t\t{ el, builder: this.builder, type: 'section', title: entry.label || 'Section' }\r\n\t\t\t\t\t);\r\n\t\t\t\t\tthis._enforce_default_group_open();\r\n\r\n\t\t\t\t\t// --- Safety net: if for any reason the slot didn’t render chips, inject them now.\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tconst hasSlotHost =\r\n\t\t\t\t\t\t\t\t  this.panel.querySelector( '[data-bfb-slot=\"layout_chips\"]' ) ||\r\n\t\t\t\t\t\t\t\t  this.panel.querySelector( '.inspector__row--layout-chips .wpbc_bfb__layout_chips' ) ||\r\n\t\t\t\t\t\t\t\t  this.panel.querySelector( '#wpbc_bfb__layout_chips_host' );\r\n\r\n\t\t\t\t\t\tconst hasChips =\r\n\t\t\t\t\t\t\t\t  !!this.panel.querySelector( '.wpbc_bfb__layout_chip' );\r\n\r\n\t\t\t\t\t\tif ( !hasChips ) {\r\n\t\t\t\t\t\t\t// Create a host if missing and render chips into it.\r\n\t\t\t\t\t\t\tconst host = (function ensureHost(root) {\r\n\t\t\t\t\t\t\t\tlet h =\r\n\t\t\t\t\t\t\t\t\t\troot.querySelector( '[data-bfb-slot=\"layout_chips\"]' ) ||\r\n\t\t\t\t\t\t\t\t\t\troot.querySelector( '.inspector__row--layout-chips .wpbc_bfb__layout_chips' ) ||\r\n\t\t\t\t\t\t\t\t\t\troot.querySelector( '#wpbc_bfb__layout_chips_host' );\r\n\t\t\t\t\t\t\t\tif ( h ) return h;\r\n\t\t\t\t\t\t\t\t// Fallback host inside (or after) the “layout” group\r\n\t\t\t\t\t\t\t\tconst fields    =\r\n\t\t\t\t\t\t\t\t\t\t  root.querySelector( '.wpbc_bfb__inspector__group[data-group=\"layout\"] .group__fields' ) ||\r\n\t\t\t\t\t\t\t\t\t\t  root.querySelector( '.group__fields' ) || root;\r\n\t\t\t\t\t\t\t\tconst row       = document.createElement( 'div' );\r\n\t\t\t\t\t\t\t\trow.className   = 'inspector__row inspector__row--layout-chips';\r\n\t\t\t\t\t\t\t\tconst lab       = document.createElement( 'label' );\r\n\t\t\t\t\t\t\t\tlab.className   = 'inspector__label';\r\n\t\t\t\t\t\t\t\tlab.textContent = 'Layout';\r\n\t\t\t\t\t\t\t\tconst ctl       = document.createElement( 'div' );\r\n\t\t\t\t\t\t\t\tctl.className   = 'inspector__control';\r\n\t\t\t\t\t\t\t\th               = document.createElement( 'div' );\r\n\t\t\t\t\t\t\t\th.className     = 'wpbc_bfb__layout_chips';\r\n\t\t\t\t\t\t\t\th.setAttribute( 'data-bfb-slot', 'layout_chips' );\r\n\t\t\t\t\t\t\t\tctl.appendChild( h );\r\n\t\t\t\t\t\t\t\trow.appendChild( lab );\r\n\t\t\t\t\t\t\t\trow.appendChild( ctl );\r\n\t\t\t\t\t\t\t\tfields.appendChild( row );\r\n\t\t\t\t\t\t\t\treturn h;\r\n\t\t\t\t\t\t\t})( this.panel );\r\n\r\n\t\t\t\t\t\t\tconst L = (w.WPBC_BFB_Core && w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Layout_Chips) ;\r\n\t\t\t\t\t\t\tif ( L && typeof L.render_for_section === 'function' ) {\r\n\t\t\t\t\t\t\t\thost.innerHTML = '';\r\n\t\t\t\t\t\t\t\tL.render_for_section( this.builder, el, host );\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} catch( e ){ _wpbc?.dev?.error( 'WPBC_BFB_Inspector - render', e ); }\r\n\r\n\t\t\t\t\tthis._set_panel_section_cols( el );\r\n\t\t\t\t\tthis.panel.scrollTop = prev_scroll;\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tthis.panel.innerHTML = '<div class=\"wpbc_bfb__inspector__empty\">Select a field to edit its options.</div>';\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\t// Field\r\n\t\t\tif ( !el.classList.contains( 'wpbc_bfb__field' ) ) return this.clear();\r\n\r\n\t\t\tconst data = w.WPBC_BFB_Core.WPBC_Form_Builder_Helper.get_all_data_attributes( el );\r\n\t\t\tconst type = data.type || 'text';\r\n\r\n\t\t\tfunction _get_tpl(id) {\r\n\t\t\t\tif ( !w.wp || !wp.template ) return null;\r\n\t\t\t\tif ( !document.getElementById( 'tmpl-' + id ) ) return null;\r\n\t\t\t\ttry {\r\n\t\t\t\t\treturn wp.template( id );\r\n\t\t\t\t} catch ( e ) {\r\n\t\t\t\t\treturn null;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tconst tpl_id      = `wpbc-bfb-inspector-${type}`;\r\n\t\t\tconst tpl         = _get_tpl( tpl_id );\r\n\t\t\tconst generic_tpl = _get_tpl( 'wpbc-bfb-inspector-generic' );\r\n\r\n\t\t\tconst schemas         = w.WPBC_BFB_Schemas || {};\r\n\t\t\tconst schema_for_type = schemas[type] || null;\r\n\t\t\tconst Factory         = w.WPBC_BFB_Core.UI && w.WPBC_BFB_Core.UI.WPBC_BFB_Inspector_Factory;\r\n\r\n\t\t\tif ( tpl ) {\r\n\t\t\t\t// NEW: merge schema defaults so missing keys (esp. booleans) honor defaults on first paint\r\n\t\t\t\tconst hasOwn = Function.call.bind( Object.prototype.hasOwnProperty );\r\n\t\t\t\tconst props  = (schema_for_type && schema_for_type.schema && schema_for_type.schema.props) ? schema_for_type.schema.props : {};\r\n\t\t\t\tconst merged = { ...data };\r\n\t\t\t\tif ( props ) {\r\n\t\t\t\t\tObject.keys( props ).forEach( (k) => {\r\n\t\t\t\t\t\tconst meta = props[k] || {};\r\n\t\t\t\t\t\tif ( !hasOwn( data, k ) ) {\r\n\t\t\t\t\t\t\tif ( hasOwn( meta, 'default' ) ) {\r\n\t\t\t\t\t\t\t\t// Coerce booleans to a real boolean; leave others as-is\r\n\t\t\t\t\t\t\t\tmerged[k] = (meta.type === 'boolean') ? !!meta.default : meta.default;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} else if ( meta.type === 'boolean' ) {\r\n\t\t\t\t\t\t\t// Explicit empty values are legacy unchecked booleans, not missing defaults.\r\n\t\t\t\t\t\t\tmerged[k] = w.WPBC_BFB_Core.WPBC_BFB_Sanitize.coerce_boolean( data[k], false );\r\n\t\t\t\t\t\t} else if ( data[k] === '' && hasOwn( meta, 'default' ) ) {\r\n\t\t\t\t\t\t\tmerged[k] = meta.default;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} );\r\n\t\t\t\t}\r\n\t\t\t\tthis.panel.innerHTML = tpl( merged );\r\n\r\n\t\t\t\tthis._post_render_ui();\r\n\t\t\t} else if ( schema_for_type && Factory ) {\r\n\t\t\t\tthis.panel.innerHTML = '';\r\n\t\t\t\tFactory.render(\r\n\t\t\t\t\tthis.panel,\r\n\t\t\t\t\tschema_for_type,\r\n\t\t\t\t\t{ ...data },\r\n\t\t\t\t\t{ el, builder: this.builder, type, title: data.label || '' }\r\n\t\t\t\t);\r\n\t\t\t\t// Ensure toggle normalizers and slider/number/unit wiring are attached.\r\n\t\t\t\tthis._post_render_ui();\r\n\t\t\t} else if ( generic_tpl ) {\r\n\t\t\t\tthis.panel.innerHTML = generic_tpl( { ...data } );\r\n\t\t\t\tthis._post_render_ui();\r\n\t\t\t} else {\r\n\r\n\t\t\t\tconst msg            = `There are no Inspector wp.template \"${tpl_id}\" or Schema for this \"${String( type || '' )}\" element.`;\r\n\t\t\t\tthis.panel.innerHTML = '';\r\n\t\t\t\tconst div            = document.createElement( 'div' );\r\n\t\t\t\tdiv.className        = 'wpbc_bfb__inspector__empty';\r\n\t\t\t\tdiv.textContent      = msg; // safe.\r\n\t\t\t\tthis.panel.appendChild( div );\r\n\t\t\t}\r\n\r\n\t\t\tthis._enforce_default_group_open();\r\n\t\t\tthis.panel.scrollTop = prev_scroll;\r\n\t\t}\r\n\r\n\t\t_enforce_default_group_open() {\r\n\t\t\tconst groups = Array.from( this.panel.querySelectorAll( '.wpbc_bfb__inspector__group' ) );\r\n\t\t\tif ( !groups.length ) return;\r\n\r\n\t\t\tlet found = false;\r\n\t\t\tgroups.forEach( (g) => {\r\n\t\t\t\tif ( !found && g.classList.contains( 'is-open' ) ) {\r\n\t\t\t\t\tfound = true;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tif ( g.classList.contains( 'is-open' ) ) {\r\n\t\t\t\t\t\tg.classList.remove( 'is-open' );\r\n\t\t\t\t\t\tg.dispatchEvent( new Event( 'wpbc:collapsible:close', { bubbles: true } ) );\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tg.classList.remove( 'is-open' );\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} );\r\n\r\n\t\t\tif ( !found ) {\r\n\t\t\t\tgroups[0].classList.add( 'is-open' );\r\n\t\t\t\tgroups[0].dispatchEvent( new Event( 'wpbc:collapsible:open', { bubbles: true } ) );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Set data-bfb-section-cols on the inspector panel based on the current section.\r\n\t\t * Uses the registered compute fn if available; falls back to direct DOM.\r\n\t\t * @param {HTMLElement} sectionEl\r\n\t\t */\r\n\t\t_set_panel_section_cols(sectionEl) {\r\n\t\t\ttry {\r\n\t\t\t\t// Prefer the already-registered value_from helper if present.\r\n\t\t\t\tvar compute = w.wpbc_bfb_inspector_factory_value_from && w.wpbc_bfb_inspector_factory_value_from.compute_section_columns;\r\n\r\n\t\t\t\tvar cols = 1;\r\n\t\t\t\tif ( typeof compute === 'function' ) {\r\n\t\t\t\t\tcols = compute( { el: sectionEl } ) || 1;\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// Fallback: compute directly from the DOM.\r\n\t\t\t\t\tvar row = sectionEl && sectionEl.querySelector( ':scope > .wpbc_bfb__row' );\r\n\t\t\t\t\tcols    = row ? (row.querySelectorAll( ':scope > .wpbc_bfb__column' ).length || 1) : 1;\r\n\t\t\t\t\tif ( cols < 1 ) cols = 1;\r\n\t\t\t\t\tif ( cols > 4 ) cols = 4;\r\n\t\t\t\t}\r\n\t\t\t\tthis.panel.setAttribute( 'data-bfb-section-cols', String( cols ) );\r\n\t\t\t} catch ( _ ) {\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\t_create_fallback_panel() {\r\n\t\t\tconst p     = document.createElement( 'div' );\r\n\t\t\tp.id        = 'wpbc_bfb__inspector';\r\n\t\t\tp.className = 'wpbc_bfb__inspector';\r\n\t\t\tdocument.body.appendChild( p );\r\n\t\t\treturn /** @type {HTMLDivElement} */ (p);\r\n\t\t}\r\n\t}\r\n\r\n\t// Export class + ready signal.\r\n\tw.WPBC_BFB_Inspector = WPBC_BFB_Inspector;\r\n\tdocument.dispatchEvent( new Event( 'wpbc_bfb_inspector_ready' ) );\r\n\r\n})( window );\r\n"]}
|
| 7498 |
|
