@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 +47 -4
- package/package.json +12 -6
- package/src/case-event-bridge.js +39 -0
- package/src/demo-case.js +83 -7
- package/src/demo-content.js +187 -22
- package/src/demo-content.styles.scss +6 -0
package/README.md
CHANGED
|
@@ -52,14 +52,57 @@ Siempre presentes, sin atributo que los active:
|
|
|
52
52
|
|
|
53
53
|
## Eventos
|
|
54
54
|
|
|
55
|
-
| Evento
|
|
56
|
-
|
|
|
57
|
-
| `ac-demo-content-copy`
|
|
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
|
-
|
|
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.
|
|
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`).
|
|
4
|
-
*
|
|
5
|
-
*
|
|
6
|
-
*
|
|
7
|
-
*
|
|
8
|
-
*
|
|
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.
|
|
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
|
}
|
package/src/demo-content.js
CHANGED
|
@@ -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
|
-
|
|
222
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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.
|
|
269
|
-
document.documentElement.setAttribute('data-theme', theme);
|
|
431
|
+
this.selectTheme(theme);
|
|
270
432
|
}
|
|
271
433
|
|
|
272
434
|
_onDeviceSelect(key) {
|
|
273
|
-
this.
|
|
435
|
+
this.selectDevice(key);
|
|
274
436
|
}
|
|
275
437
|
|
|
276
438
|
_onViewModeSelect(mode) {
|
|
277
|
-
this.
|
|
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.
|
|
300
|
-
document.addEventListener('keydown', this._onPanelKeydown);
|
|
461
|
+
this.openEventsPanel();
|
|
301
462
|
}
|
|
302
463
|
|
|
303
464
|
_onEventsPanelClose() {
|
|
304
|
-
this.
|
|
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.
|
|
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. */
|