@ac-base/ac-demo-content 0.1.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -52,14 +52,57 @@ Siempre presentes, sin atributo que los active:
52
52
 
53
53
  ## Eventos
54
54
 
55
- | Evento | Cuándo | `detail` |
56
- | ---------------------- | ------------------------------------------ | ------------------ |
57
- | `ac-demo-content-copy` | El usuario copió un comando de instalación | `{ text: string }` |
55
+ | Evento | Cuándo | `detail` |
56
+ | ------------------------------ | -------------------------------------------------------------------------------------- | ------------------------------------------- |
57
+ | `ac-demo-content-copy` | El usuario copió un comando de instalación (solo si el copiado tuvo éxito) | `{ text: string }` |
58
+ | `ac-demo-content-state-change` | Cambió el caso, idioma, tema, dispositivo, vista, el log de eventos o el modo embebido | El mismo objeto que `demoState` (ver abajo) |
58
59
 
59
- Es `bubbles` y `composed`. Solo se dispara si el copiado tuvo éxito.
60
+ Ambos son `bubbles` y `composed`.
60
61
 
61
62
  Todos los controles de 2+ opciones (idioma, tema, tamaño de dispositivo, vista) comparten el mismo patrón visual: un contenedor con borde redondeado, opciones separadas por un divisor vertical, y la opción activa resaltada — nunca un switch deslizante ni texto plano de estado ("Modo claro"/"Modo oscuro").
62
63
 
64
+ ## Modo embebido
65
+
66
+ Para incrustar una demo dentro de otra página que dibuja sus propios controles (por ejemplo el catálogo visual, que carga cada demo en un `<iframe>` del mismo origen), activa `embedded`:
67
+
68
+ ```js
69
+ const demo = iframe.contentDocument.querySelector('ac-demo-content');
70
+ demo.embedded = true; // o el atributo `embedded` en el HTML
71
+ ```
72
+
73
+ Con `embedded`, `ac-demo-content` **no dibuja la cabecera ni el toolbar** — solo el escenario (marco de dispositivo o vista de código) y el panel de eventos cuando está abierto. Quien lo incrusta maneja el mismo estado desde afuera:
74
+
75
+ | Método | Efecto |
76
+ | ------------------------------------------ | ---------------------------------------------------------------------------------------------------------- |
77
+ | `selectCase(index)` | Activa el caso de ese índice. Ignora índices fuera de rango. |
78
+ | `selectLanguage(index)` | Activa el idioma `0` o `1` de `language`. Se ignora si no hay exactamente 2 idiomas o el índice no existe. |
79
+ | `selectAmbient(value)` | Setea `ambient` en los elementos del caso activo que tengan esa propiedad. |
80
+ | `selectTheme(theme)` | `'light'` o `'dark'` — togglea `data-theme` en el `<html>` de la demo. Otros valores se ignoran. |
81
+ | `selectDevice(key)` | `'mobile'`, `'tablet'` o `'desktop'`. Otros valores se ignoran. |
82
+ | `selectViewMode(mode)` | `'visual'` o `'code'`. Otros valores se ignoran. |
83
+ | `openEventsPanel()` / `closeEventsPanel()` | Abre/cierra el panel lateral de eventos (se dibuja dentro de la propia demo). |
84
+
85
+ El getter `demoState` devuelve una foto del estado actual, con todo lo necesario para dibujar los controles afuera:
86
+
87
+ ```js
88
+ {
89
+ cases: [{ index: 0, header: 'Básico' }], // `header` cae a "Caso N" si el caso no lo define
90
+ activeCase: 0,
91
+ languages: ['es-PE', 'en-EN'],
92
+ activeLanguage: 0,
93
+ ambients: ['primary', 'secondary'],
94
+ darkMode: true, // si la demo declara `dark-mode`
95
+ theme: 'light',
96
+ devices: [{ key: 'mobile', label: 'Móvil' } /* tablet, desktop */],
97
+ device: 'mobile',
98
+ viewMode: 'visual',
99
+ eventNames: ['ac-mi-componente-click'],
100
+ eventCount: 0,
101
+ }
102
+ ```
103
+
104
+ Para mantenerse sincronizado (por ejemplo el contador de eventos), escucha `ac-demo-content-state-change`: su `detail` es ese mismo objeto. Los métodos y `demoState` funcionan también sin `embedded` — los controles propios del toolbar usan exactamente los mismos métodos.
105
+
63
106
  ## `<ac-demo-case>`
64
107
 
65
108
  | Atributo | Descripción |
package/package.json CHANGED
@@ -1,12 +1,18 @@
1
1
  {
2
2
  "name": "@ac-base/ac-demo-content",
3
- "version": "0.1.1",
3
+ "version": "0.3.0",
4
+ "repository": {
5
+ "type": "git",
6
+ "url": "https://github.com/RenzoCordovaDev/ac-lit.git",
7
+ "directory": "packages/base/ac-demo-content"
8
+ },
4
9
  "description": "Contenedor centralizado para demos de componentes ac-lit (casos, idioma, ambient, modo oscuro, tamaños, panel de eventos)",
5
10
  "license": "MIT",
6
11
  "type": "module",
7
12
  "main": "index.js",
8
13
  "exports": {
9
- ".": "./index.js"
14
+ ".": "./index.js",
15
+ "./case-event-bridge.js": "./src/case-event-bridge.js"
10
16
  },
11
17
  "files": [
12
18
  "/src/",
@@ -23,15 +29,15 @@
23
29
  "lit": "^3.0.0"
24
30
  },
25
31
  "devDependencies": {
26
- "@ac-base/ac-core": "^0.1.0",
27
- "@ac-base/ac-e2e-testing": "^0.1.0",
28
- "@ac-base/cli": "^0.2.0",
29
32
  "@open-wc/testing": "^4.0.0",
30
33
  "@web/test-runner": "^0.18.0",
31
34
  "concurrently": "^9.1.0",
32
35
  "lit": "^3.0.0",
33
36
  "sass": "^1.79.4",
34
- "vite": "^5.4.8"
37
+ "vite": "^5.4.8",
38
+ "@ac-base/ac-core": "^0.1.0",
39
+ "@ac-base/cli": "^0.5.0",
40
+ "@ac-base/ac-e2e-testing": "^0.1.0"
35
41
  },
36
42
  "scripts": {
37
43
  "component:lint": "eslint .",
@@ -0,0 +1,39 @@
1
+ // Puente padre↔iframe para un caso de demo cargado en un <iframe> (ver
2
+ // demo-case.js: camino "documento completo"). Lo importa el <script> del
3
+ // propio caso (junto al resto de imports que ya registra sus componentes).
4
+ // Un iframe es su propio realm de JS: ninguna variable ni estado de módulo
5
+ // del documento padre llega adentro por su cuenta, con lo cual necesita este
6
+ // puente para 2 cosas:
7
+ //
8
+ // 1. Reenviar al padre los eventos que `ac-demo-content` necesita loguear en
9
+ // su panel de eventos (`events="..."`) — un CustomEvent con
10
+ // `composed: true` atraviesa shadow DOM pero NUNCA el límite de un
11
+ // iframe. `ac-demo-content`, al detectar el iframe (`_onCaseLoad` en
12
+ // demo-content.js), le hace un postMessage con los nombres de evento que
13
+ // le interesan; desde ahí este puente escucha exactamente esos nombres en
14
+ // el documento del iframe y reenvía cada uno, también por postMessage.
15
+ // 2. Replicar el idioma global hacia ESTE realm: `setGlobalLocale()` (de
16
+ // `@ac-base/ac-intl-mixin`) solo cambia la variable de módulo de quien la
17
+ // llama — el documento padre tiene su propia copia del módulo, separada
18
+ // de la del iframe, así que cambiar el idioma en el padre no traduce nada
19
+ // acá adentro sin este puente.
20
+ import { setGlobalLocale } from '@ac-base/ac-intl-mixin';
21
+
22
+ if (window.parent !== window) {
23
+ window.addEventListener('message', initEvent => {
24
+ if (!initEvent.data) return;
25
+ if (initEvent.data.__acDemoBridgeInit === true) {
26
+ const eventNames = Array.isArray(initEvent.data.eventNames) ? initEvent.data.eventNames : [];
27
+ for (const name of eventNames) {
28
+ document.addEventListener(name, event => {
29
+ window.parent.postMessage(
30
+ { __acDemoBridgeEvent: true, name: event.type, detail: event.detail },
31
+ '*',
32
+ );
33
+ });
34
+ }
35
+ } else if (initEvent.data.__acDemoBridgeSetLocale === true) {
36
+ setGlobalLocale(initEvent.data.locale);
37
+ }
38
+ });
39
+ }
package/src/demo-case.js CHANGED
@@ -1,11 +1,35 @@
1
+ // Un documento completo (<!doctype html>/<html>) en `href` se carga en un
2
+ // <iframe> en vez de por innerHTML — ver el comentario largo más abajo, junto
3
+ // a `_isFullDocument`, sobre por qué existen los dos caminos.
4
+ const FULL_DOCUMENT_RE = /^\s*(<!doctype html|<html[\s>])/i;
5
+
1
6
  /**
2
7
  * ac-demo-case: contenedor de un caso de demo cargado desde un archivo HTML
3
- * externo (`href`). Deliberadamente NO usa Shadow DOM ni Lit: el HTML que
4
- * carga está pensado para comportarse como si fuera parte directa de la
5
- * página (participa del CSS global del demo, ej. `.row`/`.controls` de
6
- * demo-base.css), y evita el problema de tener que atravesar dos shadow
7
- * roots anidados (ac-demo-content -> ac-demo-case -> los componentes reales)
8
- * para que ac-demo-content pueda controlarlos (ej. cambiar su `ambient`).
8
+ * externo (`href`). Soporta dos formatos de archivo:
9
+ *
10
+ * 1. Fragmento (lo que había hasta ahora): un trozo de HTML suelto, sin
11
+ * `<html>` propio. Se inyecta con `innerHTML` directo en el documento de
12
+ * la página — participa del CSS global del demo (ej. `.row`/`.controls`
13
+ * de demo-base.css) y evita atravesar dos shadow roots anidados
14
+ * (ac-demo-content -> ac-demo-case -> los componentes reales) para que
15
+ * ac-demo-content pueda controlarlos (ej. cambiar su `ambient`). Límite
16
+ * conocido: un `<script>` insertado por `innerHTML` nunca se ejecuta, así
17
+ * que un caso así no puede traer su propia lógica — tiene que vivir en el
18
+ * `demo.js` compartido de todo el demo.
19
+ * 2. Documento completo (`<!doctype html>...<html>...</html>`): se carga en
20
+ * un `<iframe>` con `src` apuntando a `href`, así SÍ puede traer su propio
21
+ * `<script type="module">` (lógica propia por caso, sin acumular todo en
22
+ * el `demo.js` compartido). Efecto colateral deseado: un `<dialog>` nativo
23
+ * (`showModal()`) abierto dentro de ese documento queda acotado al propio
24
+ * iframe (es un browsing context aparte, con su propia capa superior) —
25
+ * sin necesitar `contained`/`getBoundary` ni medir nada por JS, sin
26
+ * importar cuántos niveles de shadow DOM tenga el componente por dentro.
27
+ * Costo: el documento del iframe es un documento aparte, así que
28
+ * ac-demo-content necesita un puente explícito para alcanzarlo (tema
29
+ * claro/oscuro, panel de eventos — ver `_onCaseLoad`/`case-event-bridge.js`
30
+ * en demo-content.js). El archivo debe vivir fuera de `demo/public/` (no
31
+ * como asset estático) para que Vite resuelva sus imports `@ac-base/...`
32
+ * tanto en dev como en build — ver vite.config.js de cada componente.
9
33
  *
10
34
  * El contenido de `href` se asume de confianza — lo escribe quien desarrolla
11
35
  * el componente, igual que el propio demo/index.html. No se sanitiza.
@@ -23,6 +47,7 @@ export class DemoCase extends HTMLElement {
23
47
  super();
24
48
  this._loaded = false;
25
49
  this._source = '';
50
+ this._iframe = null;
26
51
  }
27
52
 
28
53
  /** HTML crudo cargado desde `href` — usado por el toggle Visual/Código. */
@@ -30,6 +55,11 @@ export class DemoCase extends HTMLElement {
30
55
  return this._source;
31
56
  }
32
57
 
58
+ /** El `<iframe>` del caso, si `href` apuntó a un documento completo (si no, `null`). */
59
+ get iframe() {
60
+ return this._iframe;
61
+ }
62
+
33
63
  get header() {
34
64
  return this.getAttribute('header') ?? '';
35
65
  }
@@ -51,14 +81,30 @@ export class DemoCase extends HTMLElement {
51
81
  }
52
82
 
53
83
  connectedCallback() {
84
+ this._syncDisplay();
85
+ }
86
+
87
+ /** Elemento indefinido sin shadow DOM: el CSS con scope del shadow root de
88
+ * ac-demo-content (que lo proyecta por <slot>) nunca lo alcanza, ni
89
+ * siquiera vía `::slotted()` para un descendiente como el iframe de abajo
90
+ * — tiene que ser en línea. Pero un `display` en línea fijo le ganaría
91
+ * SIEMPRE a la regla `[hidden] { display: none }` del navegador (una regla
92
+ * de atributo pierde contra un estilo en línea) — así que el propio
93
+ * `display` en línea tiene que reflejar `active`, no ser un valor fijo
94
+ * (si no, el caso inactivo queda renderizado y apilado igual, duplicando
95
+ * el alto real de `.ac-demo-content__viewport` — encontrado vía una
96
+ * violación real de accesibilidad, `scrollable-region-focusable`, en el
97
+ * caso con contenido largo). */
98
+ _syncDisplay() {
54
99
  this.hidden = !this.active;
100
+ this.style.display = this.active ? 'block' : 'none';
55
101
  }
56
102
 
57
103
  attributeChangedCallback(name, _oldValue, newValue) {
58
104
  if (name !== 'active') return;
59
105
 
60
106
  const isActive = newValue !== null;
61
- this.hidden = !isActive;
107
+ this._syncDisplay();
62
108
 
63
109
  if (isActive && !this._loaded) {
64
110
  this._loadContent();
@@ -73,12 +119,42 @@ export class DemoCase extends HTMLElement {
73
119
  throw new Error(`HTTP ${response.status}`);
74
120
  }
75
121
  this._source = await response.text();
122
+ if (FULL_DOCUMENT_RE.test(this._source)) {
123
+ this._loadAsIframe();
124
+ return;
125
+ }
76
126
  this.innerHTML = this._source;
77
127
  } catch (error) {
78
128
  this.textContent = `Error cargando "${this.href}": ${error.message}`;
129
+ return;
79
130
  }
80
131
  // ac-demo-content escucha esto para aplicar `contained`/`getBoundary` a los
81
132
  // componentes recién insertados (ver "Superposiciones" en CONVENTIONS.md).
82
133
  this.dispatchEvent(new CustomEvent('ac-demo-case-load', { bubbles: true }));
83
134
  }
135
+
136
+ /** Camino "documento completo" — ver el comentario largo de la clase. */
137
+ _loadAsIframe() {
138
+ this.style.height = '100%';
139
+ const iframe = document.createElement('iframe');
140
+ iframe.className = 'ac-demo-case__iframe';
141
+ iframe.setAttribute('title', this.header || 'Caso de demo');
142
+ // Mismo motivo que `this.style.display` en connectedCallback: en línea,
143
+ // nunca con CSS con scope de shadow DOM.
144
+ iframe.style.cssText = 'display:block;width:100%;height:100%;border:0;background:transparent;';
145
+ // Sin `{ once: true }` a propósito: en dev, el HMR de Vite puede recargar
146
+ // el documento del iframe (ej. al tocar un `.styles.scss`) sin que
147
+ // ac-demo-case se entere — cada recarga real dispara `load` de nuevo, así
148
+ // que re-disparamos `ac-demo-case-load` cada vez para que
149
+ // ac-demo-content vuelva a sincronizar tema/eventos.
150
+ iframe.addEventListener('load', () => {
151
+ this._iframe = iframe;
152
+ // ac-demo-content escucha esto para sincronizar tema y puentear el
153
+ // panel de eventos a través del iframe — ver `_onCaseLoad` en
154
+ // demo-content.js.
155
+ this.dispatchEvent(new CustomEvent('ac-demo-case-load', { bubbles: true }));
156
+ });
157
+ this.replaceChildren(iframe);
158
+ iframe.src = this.href;
159
+ }
84
160
  }
@@ -14,6 +14,17 @@ const DEVICE_PRESETS = [
14
14
  { key: 'desktop', label: 'Desktop', width: 1280, height: 800 },
15
15
  ];
16
16
  const MAX_EVENT_LOG_ENTRIES = 50;
17
+ const THEMES = ['light', 'dark'];
18
+ const VIEW_MODES = ['visual', 'code'];
19
+ const STATE_PROPERTIES = [
20
+ '_activeCaseIndex',
21
+ '_activeDevice',
22
+ '_viewMode',
23
+ '_langIndex',
24
+ '_theme',
25
+ '_eventLog',
26
+ 'embedded',
27
+ ];
17
28
  const COPIED_FEEDBACK_MS = 1600;
18
29
 
19
30
  const COPY_ICON = html`<svg
@@ -108,6 +119,9 @@ function renderToken(token) {
108
119
  * y ALTURA fijos por preset — el contenido scrollea adentro, no empuja el
109
120
  * marco), vista visual/código (código muestra el HTML fuente del caso
110
121
  * activo) y un panel lateral de eventos con el detalle de cada uno.
122
+ *
123
+ * Con `embedded` no dibuja cabecera ni toolbar: quien lo incrusta maneja los
124
+ * mismos controles desde afuera con los métodos `select*()` y lee `demoState`.
111
125
  */
112
126
  export class DemoContent extends ComponentMixin(LitElement) {
113
127
  static get is() {
@@ -128,6 +142,7 @@ export class DemoContent extends ComponentMixin(LitElement) {
128
142
  ambients: { type: String },
129
143
  events: { type: String },
130
144
  darkMode: { type: Boolean, reflect: true, attribute: 'dark-mode' },
145
+ embedded: { type: Boolean, reflect: true },
131
146
  _activeCaseIndex: { state: true },
132
147
  _activeDevice: { state: true },
133
148
  _viewMode: { state: true },
@@ -149,6 +164,7 @@ export class DemoContent extends ComponentMixin(LitElement) {
149
164
  this.ambients = '';
150
165
  this.events = '';
151
166
  this.darkMode = false;
167
+ this.embedded = false;
152
168
  this._activeCaseIndex = 0;
153
169
  this._activeDevice = 'mobile';
154
170
  this._viewMode = 'visual';
@@ -161,6 +177,7 @@ export class DemoContent extends ComponentMixin(LitElement) {
161
177
  this._onEvent = this._onEvent.bind(this);
162
178
  this._onPanelKeydown = this._onPanelKeydown.bind(this);
163
179
  this._onCaseLoad = this._onCaseLoad.bind(this);
180
+ this._onBridgeMessage = this._onBridgeMessage.bind(this);
164
181
  }
165
182
 
166
183
  get _languages() {
@@ -179,12 +196,33 @@ export class DemoContent extends ComponentMixin(LitElement) {
179
196
  return Array.from(this.querySelectorAll(':scope > ac-demo-case'));
180
197
  }
181
198
 
199
+ get demoState() {
200
+ return {
201
+ cases: this._cases.map((caseEl, index) => ({
202
+ index,
203
+ header: caseEl.header || `Caso ${index + 1}`,
204
+ })),
205
+ activeCase: this._activeCaseIndex,
206
+ languages: this._languages,
207
+ activeLanguage: this._langIndex,
208
+ ambients: this._ambientOptions,
209
+ darkMode: this.darkMode,
210
+ theme: this._theme,
211
+ devices: DEVICE_PRESETS.map(({ key, label }) => ({ key, label })),
212
+ device: this._activeDevice,
213
+ viewMode: this._viewMode,
214
+ eventNames: this._eventNames,
215
+ eventCount: this._eventLog.length,
216
+ };
217
+ }
218
+
182
219
  connectedCallback() {
183
220
  super.connectedCallback();
184
221
  for (const name of this._eventNames) {
185
222
  document.addEventListener(name, this._onEvent);
186
223
  }
187
224
  this.addEventListener('ac-demo-case-load', this._onCaseLoad);
225
+ window.addEventListener('message', this._onBridgeMessage);
188
226
  }
189
227
 
190
228
  disconnectedCallback() {
@@ -192,6 +230,7 @@ export class DemoContent extends ComponentMixin(LitElement) {
192
230
  document.removeEventListener(name, this._onEvent);
193
231
  }
194
232
  this.removeEventListener('ac-demo-case-load', this._onCaseLoad);
233
+ window.removeEventListener('message', this._onBridgeMessage);
195
234
  document.removeEventListener('keydown', this._onPanelKeydown);
196
235
  clearTimeout(this._copiedTimer);
197
236
  super.disconnectedCallback();
@@ -205,6 +244,18 @@ export class DemoContent extends ComponentMixin(LitElement) {
205
244
  }
206
245
  }
207
246
 
247
+ updated(changedProperties) {
248
+ if (STATE_PROPERTIES.some(property => changedProperties.has(property))) {
249
+ this.dispatchEvent(
250
+ new CustomEvent('ac-demo-content-state-change', {
251
+ detail: this.demoState,
252
+ bubbles: true,
253
+ composed: true,
254
+ }),
255
+ );
256
+ }
257
+ }
258
+
208
259
  _onEvent(event) {
209
260
  const entry = { time: new Date().toLocaleTimeString(), name: event.type, detail: event.detail };
210
261
  this._eventLog = [entry, ...this._eventLog].slice(0, MAX_EVENT_LOG_ENTRIES);
@@ -216,19 +267,59 @@ export class DemoContent extends ComponentMixin(LitElement) {
216
267
  caseEl.active = i === index;
217
268
  });
218
269
  this._activeCaseIndex = index;
270
+ this._syncThemeToActiveCase();
271
+ this._syncLanguageToActiveCase();
272
+ this._syncViewportPadding();
219
273
  }
220
274
 
221
- _onCaseChange(event) {
222
- this._activateCase(Number(event.target.value));
275
+ /** Un caso cargado en iframe (ver demo-case.js) tiene su propio documento:
276
+ * no hereda el `data-theme` del documento padre, hay que replicarlo. */
277
+ _syncThemeToActiveCase() {
278
+ const iframe = this._cases[this._activeCaseIndex]?.iframe;
279
+ iframe?.contentDocument?.documentElement.setAttribute('data-theme', this._theme);
223
280
  }
224
281
 
225
- _onLanguageSelect(index) {
282
+ /** `.ac-demo-content__viewport` trae 1rem de padding pensado para contenido
283
+ * suelto (fragmento) que necesita respirar sobre el fondo del marco. Un
284
+ * caso "documento completo" (iframe) suele ser una pantalla real de punta a
285
+ * punta (ej. `ac-transition-container` a pantalla completa) — con ese
286
+ * padding de por medio nunca puede llegar a los bordes del marco simulado,
287
+ * aunque internamente esté midiendo/llenando el 100% de su propio iframe.
288
+ * Se anula a mano en línea (mismo motivo que el resto de estilos en línea
289
+ * de demo-case.js: CSS con scope de shadow DOM no alcanza el DOM liviano). */
290
+ _syncViewportPadding() {
291
+ const viewport = this.renderRoot.querySelector('.ac-demo-content__viewport');
292
+ if (!viewport) return;
293
+ const isIframeCase = Boolean(this._cases[this._activeCaseIndex]?.iframe);
294
+ viewport.style.padding = isIframeCase ? '0' : '';
295
+ }
296
+
297
+ selectCase(index) {
298
+ if (!Number.isInteger(index) || index < 0 || index >= this._cases.length) return;
299
+ this._activateCase(index);
300
+ }
301
+
302
+ selectLanguage(index) {
303
+ if (this._languages.length !== 2 || (index !== 0 && index !== 1)) return;
226
304
  this._langIndex = index;
227
305
  setGlobalLocale(this._languages[index]);
306
+ this._syncLanguageToActiveCase();
307
+ }
308
+
309
+ /** Mismo motivo que `_syncThemeToActiveCase`: un caso en iframe tiene su
310
+ * propia copia del módulo de `@ac-base/ac-intl-mixin` — `setGlobalLocale()`
311
+ * de arriba solo cambió la del documento padre. Se replica vía
312
+ * case-event-bridge.js (import de cada caso en documento completo). */
313
+ _syncLanguageToActiveCase() {
314
+ if (this._languages.length !== 2) return;
315
+ const iframe = this._cases[this._activeCaseIndex]?.iframe;
316
+ iframe?.contentWindow?.postMessage(
317
+ { __acDemoBridgeSetLocale: true, locale: this._languages[this._langIndex] },
318
+ '*',
319
+ );
228
320
  }
229
321
 
230
- _onAmbientChange(event) {
231
- const value = event.target.value;
322
+ selectAmbient(value) {
232
323
  const activeCase = this._cases[this._activeCaseIndex];
233
324
  if (!activeCase) return;
234
325
 
@@ -239,6 +330,45 @@ export class DemoContent extends ComponentMixin(LitElement) {
239
330
  }
240
331
  }
241
332
 
333
+ selectTheme(theme) {
334
+ if (!THEMES.includes(theme)) return;
335
+ this._theme = theme;
336
+ document.documentElement.setAttribute('data-theme', theme);
337
+ this._syncThemeToActiveCase();
338
+ }
339
+
340
+ selectDevice(key) {
341
+ if (!DEVICE_PRESETS.some(preset => preset.key === key)) return;
342
+ this._activeDevice = key;
343
+ }
344
+
345
+ selectViewMode(mode) {
346
+ if (!VIEW_MODES.includes(mode)) return;
347
+ this._viewMode = mode;
348
+ }
349
+
350
+ openEventsPanel() {
351
+ this._eventsPanelOpen = true;
352
+ document.addEventListener('keydown', this._onPanelKeydown);
353
+ }
354
+
355
+ closeEventsPanel() {
356
+ this._eventsPanelOpen = false;
357
+ document.removeEventListener('keydown', this._onPanelKeydown);
358
+ }
359
+
360
+ _onCaseChange(event) {
361
+ this.selectCase(Number(event.target.value));
362
+ }
363
+
364
+ _onLanguageSelect(index) {
365
+ this.selectLanguage(index);
366
+ }
367
+
368
+ _onAmbientChange(event) {
369
+ this.selectAmbient(event.target.value);
370
+ }
371
+
242
372
  // Un modal/toast/transition "contenido" de un caso renuncia a la capa
243
373
  // superior nativa (`showModal()`/`popover` SIEMPRE bloquean toda la página
244
374
  // real e ignoran cualquier ancestro para medirse — ver "Superposiciones" en
@@ -251,7 +381,29 @@ export class DemoContent extends ComponentMixin(LitElement) {
251
381
  // viewport simulado por JS. `getBoundary` es una función (no el elemento)
252
382
  // porque ese div se reconstruye al alternar Visual/Código.
253
383
  _onCaseLoad(event) {
254
- this._applyContainment(event.target);
384
+ const caseEl = event.target;
385
+ const iframe = caseEl.iframe;
386
+ if (iframe) {
387
+ // Camino "documento completo" (demo-case.js): el iframe es su propio
388
+ // browsing context, con su propia capa superior — un <dialog> nativo
389
+ // ya queda acotado a sus límites sin contained/getBoundary. Lo único
390
+ // que hay que cruzar a mano es lo que de verdad depende del documento
391
+ // (tema) y lo que no cruza el límite del iframe por su cuenta (eventos
392
+ // compuestos para el panel de eventos — ver case-event-bridge.js).
393
+ this._syncThemeToActiveCase();
394
+ this._syncLanguageToActiveCase();
395
+ this._syncViewportPadding();
396
+ if (this._eventNames.length) {
397
+ iframe.contentWindow?.postMessage(
398
+ { __acDemoBridgeInit: true, eventNames: this._eventNames },
399
+ '*',
400
+ );
401
+ }
402
+ return;
403
+ }
404
+ // Camino "fragmento" (innerHTML): mismo documento, se puede aplicar
405
+ // contained/getBoundary a mano a lo que esté en el DOM liviano del caso.
406
+ this._applyContainment(caseEl);
255
407
  }
256
408
 
257
409
  _applyContainment(caseEl) {
@@ -264,17 +416,27 @@ export class DemoContent extends ComponentMixin(LitElement) {
264
416
  }
265
417
  }
266
418
 
419
+ /** Recibe los eventos que `case-event-bridge.js` reenvía desde el iframe de
420
+ * un caso "documento completo" — el equivalente a `_onEvent` para el
421
+ * camino fragmento, que escucha directo en `document`. */
422
+ _onBridgeMessage(event) {
423
+ if (!event.data || event.data.__acDemoBridgeEvent !== true) return;
424
+ const iframe = this._cases[this._activeCaseIndex]?.iframe;
425
+ if (!iframe || event.source !== iframe.contentWindow) return;
426
+ if (!this._eventNames.includes(event.data.name)) return;
427
+ this._onEvent({ type: event.data.name, detail: event.data.detail });
428
+ }
429
+
267
430
  _onThemeSelect(theme) {
268
- this._theme = theme;
269
- document.documentElement.setAttribute('data-theme', theme);
431
+ this.selectTheme(theme);
270
432
  }
271
433
 
272
434
  _onDeviceSelect(key) {
273
- this._activeDevice = key;
435
+ this.selectDevice(key);
274
436
  }
275
437
 
276
438
  _onViewModeSelect(mode) {
277
- this._viewMode = mode;
439
+ this.selectViewMode(mode);
278
440
  }
279
441
 
280
442
  async _onInstallCommandClick(command) {
@@ -296,18 +458,16 @@ export class DemoContent extends ComponentMixin(LitElement) {
296
458
  }
297
459
 
298
460
  _onEventsButtonClick() {
299
- this._eventsPanelOpen = true;
300
- document.addEventListener('keydown', this._onPanelKeydown);
461
+ this.openEventsPanel();
301
462
  }
302
463
 
303
464
  _onEventsPanelClose() {
304
- this._eventsPanelOpen = false;
305
- document.removeEventListener('keydown', this._onPanelKeydown);
465
+ this.closeEventsPanel();
306
466
  }
307
467
 
308
468
  _onPanelKeydown(event) {
309
469
  if (event.key === 'Escape') {
310
- this._onEventsPanelClose();
470
+ this.closeEventsPanel();
311
471
  }
312
472
  }
313
473
 
@@ -316,8 +476,19 @@ export class DemoContent extends ComponentMixin(LitElement) {
316
476
  const devicePreset = DEVICE_PRESETS.find(preset => preset.key === this._activeDevice);
317
477
 
318
478
  return html`
319
- ${hasHeader ? this._renderHeader() : ''}
479
+ ${hasHeader && !this.embedded ? this._renderHeader() : ''}
480
+ ${this.embedded ? '' : this._renderToolbar()}
320
481
 
482
+ <div class="ac-demo-content__stage">
483
+ ${this._viewMode === 'code' ? this._renderCodeView() : this._renderDeviceStage(devicePreset)}
484
+ </div>
485
+
486
+ ${this._eventsPanelOpen ? this._renderEventsPanel() : ''}
487
+ `;
488
+ }
489
+
490
+ _renderToolbar() {
491
+ return html`
321
492
  <div part="toolbar" class="ac-demo-content__toolbar">
322
493
  <div class="ac-demo-content__toolbar-cases">${this._renderCaseSwitcher(this._cases)}</div>
323
494
  <div class="ac-demo-content__toolbar-controls">
@@ -328,12 +499,6 @@ export class DemoContent extends ComponentMixin(LitElement) {
328
499
  ${this._eventNames.length ? this._renderEventsButton() : ''}
329
500
  </div>
330
501
  </div>
331
-
332
- <div class="ac-demo-content__stage">
333
- ${this._viewMode === 'code' ? this._renderCodeView() : this._renderDeviceStage(devicePreset)}
334
- </div>
335
-
336
- ${this._eventsPanelOpen ? this._renderEventsPanel() : ''}
337
502
  `;
338
503
  }
339
504
 
@@ -431,6 +431,12 @@
431
431
  border-radius: 0 0 0.5rem 0.5rem;
432
432
  }
433
433
 
434
+ // NOTA: `ac-demo-case`/`.ac-demo-case__iframe` (demo-case.js) son DOM liviano
435
+ // proyectado por <slot> — el CSS con scope de shadow DOM de este componente
436
+ // NUNCA los alcanza (ni siquiera `::slotted()` llega a un descendiente como
437
+ // el <iframe>, solo al propio elemento slotteado). Por eso ese tamaño se fija
438
+ // con estilos en línea desde el propio demo-case.js, no acá.
439
+
434
440
  /* Vista de código: editor con barra de título, líneas numeradas y resaltado de
435
441
  sintaxis. Paleta FIJA (oscura en ambos temas, como un editor real) — los
436
442
  colores no dependen de --color-bg/--color-text, que cambian con el tema. */