@seatsyoo/vue 0.0.0-stage → 1.1.0

package/dist/SeatsyooChart.js

@@ -0,0 +1,226 @@
+// SeatsyooChart: el visor de Seatsyoo como componente de Vue 3 (3.3 o posterior), sin SFC (defineComponent y una
+// función render), para que se use sin compilar plantillas.
+//
+// - Se monta en onMounted: en el servidor (SSR) solo se pinta el <div> vacío.
+// - Antes de desmontar, destroy().
+// - Si cambia una opción de identidad (OPCIONES_DE_IDENTIDAD, por valor), se destruye y se monta otro. Si el nuevo
+//   no va a recuperar lo que el comprador tenía retenido (otro evento…), antes se suelta (sueltaAlCambiar).
+// - theme y colorBy se aplican al visor montado (setTheme, setColorBy); statusStyles y marks (modo «manager»),
+//   también, comparadas por valor (setStatusStyles, setMarks), aunque se cambien en el sitio.
+// - Los avisos del visor salen como eventos de Vue (ready, change, select…): llegan siempre a los oyentes de
+//   ese momento, sin volver a montar.
+import { render, } from "@seatsyoo/visor";
+import { defineComponent, getCurrentInstance, h, onBeforeUnmount, onMounted, shallowRef, toRaw, watch, } from "vue";
+import { SeatsyooDesigner } from "./SeatsyooDesigner.js";
+import { aplicarEnVivo, avisarEnConsola, copiaDeDatos, enVivoDe, errorDeOpciones, identidadDe, igual, opcionesEnVivo, sinIndefinidos, sueltaAlCambiar, } from "./opciones.js";
+// Los booleanos con `default: undefined`: sin él, Vue los pone a false si no se pasan, y el visor los quiere
+// sin indicar (su valor por defecto es «sí»).
+const props = {
+    /** URL base del servidor de Seatsyoo, p. ej. https://seatsyoo.example */
+    server: { type: String, required: true },
+    /** Clave pública del espacio (obligatoria salvo con `link` o `document`). */
+    publicKey: String,
+    /** Clave del evento. */
+    event: String,
+    /** O la clave de un enlace público del plano: solo para ver. */
+    link: String,
+    /** O el plano ya cargado: solo para ver. */
+    document: Object,
+    /** O la clave de una temporada (abono). */
+    season: String,
+    /** Abono parcial: los eventos de la temporada elegidos. */
+    seasonEvents: Array,
+    /** Canales de venta desde los que se compra. */
+    channels: Array,
+    /**
+     * Los precios que pone tu web, por clave de categoría (`{ platea: 30 }`): el visor los enseña en la ficha, la leyenda
+     * y el total, y salen en `price` de lo elegido. Seatsyoo no guarda precios.
+     */
+    pricing: Object,
+    /** Moneda de `pricing` (código ISO; si no, euros). */
+    currency: String,
+    locale: String,
+    language: String,
+    /** Máximo de plazas seleccionables (por defecto 10). */
+    maxSelected: Number,
+    /** «continue» (por defecto) recupera la selección al recargar; «start» empieza de cero. */
+    session: String,
+    /** Token de retención creado por tu servidor. */
+    holdToken: String,
+    /** «buyer» (por defecto) o «manager». */
+    mode: String,
+    /** Color base de los objetos (se aplica sin volver a montar). */
+    colorBy: String,
+    /** Tema (se aplica sin volver a montar). */
+    theme: String,
+    /**
+     * Solo en el modo «manager»: nombre, color e icono de los estados, por su clave (los propios y los de base que se
+     * quieran cambiar). Se aplica sin volver a montar (setStatusStyles).
+     */
+    statusStyles: Object,
+    /**
+     * Solo en el modo «manager»: marcas sobre plazas que siguen libres, objeto → estado (su aspecto, en `statusStyles`).
+     * Se aplica sin volver a montar (setMarks).
+     */
+    marks: Object,
+    showLegend: { type: Boolean, default: undefined },
+    showSelectionBar: { type: Boolean, default: undefined },
+    /** Planta que se muestra al abrir (id). */
+    floor: String,
+    sectors: { type: Boolean, default: undefined },
+    /** Botón de vista 3D (por defecto sí). */
+    view3d: { type: Boolean, default: undefined },
+    /** Entrada animada al abrirse: el plano se descubre desde el escenario (por defecto, no). */
+    entrance: { type: Boolean, default: undefined },
+    /**
+     * Textos del plano que se enseñan cambiados (por ejemplo, traducidos), por el texto tal como está en el plano:
+     * `{ Platea: "Stalls" }`. Solo cambia lo que se ve: claves, selección y eventos siguen siendo los del plano.
+     */
+    texts: Object,
+    /** Cómo cargar el módulo 3D (por defecto se pide al servidor). */
+    load3d: Function,
+};
+// Los parámetros solo dan el tipo de cada evento (Vue valida con lo que devuelven: siempre sí).
+const emits = {
+    /** El visor ha cargado el plano y los estados. */
+    ready: (chart) => true,
+    /** La selección ha cambiado. */
+    change: (selection) => true,
+    select: (object) => true,
+    deselect: (object) => true,
+    /** Algo ha fallado: `{ code, message }`. Sin oyente, se escribe en la consola. */
+    error: (error) => true,
+    /** Se acabó el tiempo de la retención (`@hold-expired`). */
+    holdExpired: () => true,
+    /** El token de retención ha cambiado (`@hold-token-change`). */
+    holdTokenChange: (token) => true,
+    /** Se muestra otra planta (`@floor-change`). */
+    floorChange: (floor) => true,
+};
+// El componente; su tipo público es SeatsyooChartComponent (abajo).
+const componente = defineComponent({
+    name: "SeatsyooChart",
+    props,
+    emits,
+    expose: ["chart"],
+    setup(props, { emit }) {
+        /** El visor montado, o null (en el servidor, antes de montar, tras desmontar o si las opciones no valen). */
+        const chart = shallowRef(null);
+        /** El <div> donde se monta (ref de plantilla «el»). */
+        const el = shallowRef(null);
+        const instancia = getCurrentInstance();
+        let vivo = false;
+        /** La identidad con que se montó el visor actual (o con que falló el último intento). */
+        let montada = null;
+        /** Las opciones en vivo (tema, color, estilos y marcas) que tiene el visor actual. */
+        let aplicadas = enVivoDe({});
+        /** ¿Hay alguien escuchando @error ahora mismo? (Si no, el error va a la consola, como hace el visor.) */
+        function escuchanError() {
+            const p = instancia?.vnode.props;
+            return !!p && (typeof p.onError === "function" || Array.isArray(p.onError) || typeof p.onErrorOnce === "function");
+        }
+        /** La identidad de las props: lee solo esas props (así el watch solo depende de ellas). */
+        function identidad() {
+            const id = identidadDe(props);
+            // El plano no se copia ni se recorre: si llega reactivo, el visor lo recibe sin proxy.
+            id.document = id.document && toRaw(id.document);
+            return id;
+        }
+        function desmontar() {
+            const anterior = chart.value;
+            chart.value = null;
+            montada = null;
+            anterior?.destroy();
+        }
+        function montar(nueva) {
+            // Al cambiar de evento (o de lo que sea que el visor nuevo no recupere), se suelta lo que tenía retenido el
+            // que se va, con sus avisos (deselect y change con la selección vacía). Al desmontar el componente, no.
+            if (chart.value && montada && sueltaAlCambiar(montada, nueva))
+                void chart.value.clearSelection();
+            desmontar();
+            const div = el.value;
+            if (!div)
+                return;
+            montada = nueva;
+            const { load3d: hayLoad3d, ...opciones } = nueva;
+            const load3d = props.load3d;
+            // Copias sin proxy de statusStyles y marks: lo que se compara después y lo que recibe el visor.
+            const enVivo = enVivoDe(props);
+            try {
+                chart.value = render({
+                    ...sinIndefinidos(opciones),
+                    ...opcionesEnVivo(props, enVivo),
+                    container: div,
+                    onReady: (c) => emit("ready", c),
+                    onChange: (s) => emit("change", s),
+                    onSelect: (o) => emit("select", o),
+                    onDeselect: (o) => emit("deselect", o),
+                    onHoldExpired: () => emit("holdExpired"),
+                    onHoldTokenChange: (t) => emit("holdTokenChange", t),
+                    onFloorChange: (f) => emit("floorChange", f),
+                    onError: (e) => (escuchanError() ? emit("error", e) : avisarEnConsola(e)),
+                    // Solo si hay load3d (si no, el visor pide la 3D al servidor); ponerlo o quitarlo cambia la identidad.
+                    ...(hayLoad3d && load3d ? { load3d: () => (props.load3d ?? load3d)() } : {}),
+                });
+            }
+            catch (err) {
+                const error = errorDeOpciones(err);
+                if (escuchanError())
+                    emit("error", error);
+                else
+                    console.error("[seatsyoo]", error.message);
+                return;
+            }
+            aplicadas = enVivo;
+        }
+        onMounted(() => {
+            vivo = true;
+            montar(identidad());
+        });
+        onBeforeUnmount(() => {
+            vivo = false;
+            desmontar();
+        });
+        // Antes del de las opciones en vivo: si en el mismo cambio se monta otro visor, ya lleva el tema nuevo.
+        watch(identidad, (nueva) => {
+            if (vivo && !(montada && igual(nueva, montada)))
+                montar(nueva);
+        });
+        // Copiar statusStyles y marks lee todo lo que tienen: así también avisa si se cambian en el sitio (reactivos).
+        watch(() => ({ theme: props.theme, colorBy: props.colorBy, statusStyles: copiaDeDatos(props.statusStyles), marks: copiaDeDatos(props.marks) }), (vivas) => {
+            const c = chart.value;
+            if (c)
+                aplicarEnVivo(c, aplicadas, vivas);
+        });
+        return { chart, el };
+    },
+    render() {
+        // class, style, id y demás atributos pasan solos a este <div> (inheritAttrs).
+        return h("div", { ref: "el" });
+    },
+});
+/**
+ * El visor de mapas de asientos de Seatsyoo.
+ *
+ * ```vue
+ * <SeatsyooChart
+ *   ref="plano"
+ *   server="https://seatsyoo.example"
+ *   public-key="pk_tu_clave_publica"
+ *   event="hamlet-2026-11-20"
+ *   style="height: 600px"
+ *   @change="(seleccion) => (elegidas = seleccion)"
+ * />
+ * ```
+ *
+ * Con una ref de plantilla, `plano.value.chart` es el visor montado (`getSelection()`, `holdToken`…), o `null`
+ * mientras no hay ninguno.
+ */
+export const SeatsyooChart = componente;
+/** Plugin que registra <SeatsyooChart> y <SeatsyooDesigner> en toda la aplicación: `app.use(SeatsyooPlugin)`. */
+export const SeatsyooPlugin = {
+    install(app) {
+        app.component("SeatsyooChart", SeatsyooChart);
+        app.component("SeatsyooDesigner", SeatsyooDesigner);
+    },
+};

package/dist/SeatsyooDesigner.d.ts

@@ -0,0 +1,71 @@
+import { type EmbeddedDesigner, type Language } from "@seatsyoo/visor";
+import { type ComponentOptionsMixin, type DefineComponent, type ExtractPublicPropTypes, type PropType } from "vue";
+type Estado = "draft" | "published" | "published-with-draft";
+declare const props: {
+    /** URL base del servidor de Seatsyoo, p. ej. https://seatsyoo.example */
+    server: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** El token de la sesión del diseñador (dsg_…), que abre tu servidor con su clave secreta. */
+    token: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** Idioma del diseñador: «es» (por defecto) o «en». */
+    language: PropType<Language>;
+    /** Pide a tu servidor otro token del mismo plano antes de que caduque (sin ella, al caducar deja de guardar). */
+    refreshToken: PropType<() => Promise<string>>;
+};
+declare const emits: {
+    /** El diseñador está abierto con el plano. */
+    ready: (info: {
+        chart: string;
+        status: Estado;
+        publishedVersion: number | null;
+        canPublish: boolean;
+    }) => boolean;
+    /** Se han guardado los cambios en el borrador. */
+    save: (info: {
+        chart: string;
+        status: Estado;
+    }) => boolean;
+    /** Se ha publicado una versión nueva. */
+    publish: (info: {
+        chart: string;
+        version: number;
+    }) => boolean;
+    /** Se ha pulsado «←» (sale solo si hay quien escuche @close al montarse). */
+    close: () => boolean;
+    /** Algo ha fallado: `{ code, message }`. Sin oyente, se escribe en la consola. */
+    error: (error: {
+        code: string;
+        message: string;
+    }) => boolean;
+};
+/** Props de SeatsyooDesigner: las opciones del diseñador, sin `container` ni los avisos (que son eventos). */
+export type SeatsyooDesignerProps = ExtractPublicPropTypes<typeof props>;
+/** Lo que expone el componente a una ref de plantilla. */
+export interface SeatsyooDesignerExposed {
+    /** El diseñador abierto (`setToken()`, `iframe`), o null mientras no hay ninguno. */
+    designer: EmbeddedDesigner | null;
+}
+/** Su tipo público, escrito a mano como el de SeatsyooChart (con los parámetros que no han cambiado desde Vue 3.3). */
+export type SeatsyooDesignerComponent = DefineComponent<typeof props, SeatsyooDesignerExposed, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, typeof emits>;
+/**
+ * El diseñador de planos de Seatsyoo en tu web, con el token de una sesión que abre tu servidor con su clave secreta
+ * (`POST /api/v1/charts/{plano}/designer-sessions`, o `charts.designerSession` de `@seatsyoo/node`).
+ *
+ * ```vue
+ * <SeatsyooDesigner
+ *   server="https://seatsyoo.example"
+ *   :token="token"
+ *   :refresh-token="pedirToken"
+ *   style="height: 80vh"
+ *   @publish="({ version }) => console.log(version)"
+ *   @close="abierto = false"
+ * />
+ * ```
+ */
+export declare const SeatsyooDesigner: SeatsyooDesignerComponent;
+export {};

package/dist/SeatsyooDesigner.js

@@ -0,0 +1,138 @@
+// SeatsyooDesigner: el diseñador de planos de Seatsyoo, incrustado en tu web, como componente de Vue 3 (3.3 o posterior),
+// sin SFC (defineComponent y una función render), como SeatsyooChart.
+//
+// - Se monta en onMounted: en el servidor (SSR) solo se pinta el <div> vacío. Antes de desmontar, destroy().
+// - Vuelve a montarse si cambia `server` o `language`, o si se pasa o se quita `refreshToken`: la página del diseñador
+//   sabe al abrirse si puede pedir tokens nuevos. «←» sale si al montarse hay quien escuche @close.
+// - Un `token` nuevo con el diseñador abierto no lo vuelve a montar: se le manda (setToken), como al renovarlo.
+// - Los avisos salen como eventos de Vue (ready, save, publish, close, error); refreshToken es una prop (devuelve el
+//   token) y se llama siempre la última recibida.
+import { designer } from "@seatsyoo/visor";
+import { defineComponent, getCurrentInstance, h, onBeforeUnmount, onMounted, shallowRef, watch, } from "vue";
+import { avisarEnConsola, errorDeOpciones } from "./opciones.js";
+const props = {
+    /** URL base del servidor de Seatsyoo, p. ej. https://seatsyoo.example */
+    server: { type: String, required: true },
+    /** El token de la sesión del diseñador (dsg_…), que abre tu servidor con su clave secreta. */
+    token: { type: String, required: true },
+    /** Idioma del diseñador: «es» (por defecto) o «en». */
+    language: String,
+    /** Pide a tu servidor otro token del mismo plano antes de que caduque (sin ella, al caducar deja de guardar). */
+    refreshToken: Function,
+};
+// Los parámetros solo dan el tipo de cada evento (Vue valida con lo que devuelven: siempre sí).
+const emits = {
+    /** El diseñador está abierto con el plano. */
+    ready: (info) => true,
+    /** Se han guardado los cambios en el borrador. */
+    save: (info) => true,
+    /** Se ha publicado una versión nueva. */
+    publish: (info) => true,
+    /** Se ha pulsado «←» (sale solo si hay quien escuche @close al montarse). */
+    close: () => true,
+    /** Algo ha fallado: `{ code, message }`. Sin oyente, se escribe en la consola. */
+    error: (error) => true,
+};
+const componente = defineComponent({
+    name: "SeatsyooDesigner",
+    props,
+    emits,
+    expose: ["designer"],
+    setup(props, { emit }) {
+        const abierto = shallowRef(null);
+        const el = shallowRef(null);
+        const instancia = getCurrentInstance();
+        let vivo = false;
+        /** El último token que se le dio al diseñador abierto. */
+        let token = "";
+        /** ¿Hay alguien escuchando ese evento ahora mismo? */
+        function escuchan(evento) {
+            const p = instancia?.vnode.props;
+            const f = p?.[evento] ?? p?.[`${evento}Once`];
+            return typeof f === "function" || Array.isArray(f);
+        }
+        function desmontar() {
+            const anterior = abierto.value;
+            abierto.value = null;
+            anterior?.destroy();
+        }
+        function montar() {
+            desmontar();
+            const div = el.value;
+            if (!div)
+                return;
+            const refresh = props.refreshToken;
+            try {
+                abierto.value = designer({
+                    container: div,
+                    server: props.server,
+                    token: props.token,
+                    ...(props.language ? { language: props.language } : {}),
+                    ...(refresh ? { refreshToken: () => (props.refreshToken ?? refresh)() } : {}),
+                    ...(escuchan("onClose") ? { onClose: () => emit("close") } : {}),
+                    onReady: (i) => emit("ready", i),
+                    onSave: (i) => emit("save", i),
+                    onPublish: (i) => emit("publish", i),
+                    onError: (e) => (escuchan("onError") ? emit("error", e) : avisarEnConsola(e)),
+                });
+                token = props.token;
+            }
+            catch (err) {
+                const error = errorDeOpciones(err);
+                if (escuchan("onError"))
+                    emit("error", error);
+                else
+                    console.error("[seatsyoo]", error.message);
+            }
+        }
+        onMounted(() => {
+            vivo = true;
+            montar();
+        });
+        onBeforeUnmount(() => {
+            vivo = false;
+            desmontar();
+        });
+        watch(() => [props.server, props.language, !!props.refreshToken], () => {
+            if (vivo)
+                montar();
+        });
+        watch(() => props.token, (nuevo) => {
+            const d = abierto.value;
+            if (!vivo || !d || nuevo === token)
+                return;
+            try {
+                d.setToken(nuevo);
+                token = nuevo;
+            }
+            catch (err) {
+                const error = errorDeOpciones(err);
+                if (escuchan("onError"))
+                    emit("error", error);
+                else
+                    avisarEnConsola(error);
+            }
+        });
+        return { designer: abierto, el };
+    },
+    render() {
+        // class, style, id y demás atributos pasan solos a este <div> (inheritAttrs).
+        return h("div", { ref: "el" });
+    },
+});
+/**
+ * El diseñador de planos de Seatsyoo en tu web, con el token de una sesión que abre tu servidor con su clave secreta
+ * (`POST /api/v1/charts/{plano}/designer-sessions`, o `charts.designerSession` de `@seatsyoo/node`).
+ *
+ * ```vue
+ * <SeatsyooDesigner
+ *   server="https://seatsyoo.example"
+ *   :token="token"
+ *   :refresh-token="pedirToken"
+ *   style="height: 80vh"
+ *   @publish="({ version }) => console.log(version)"
+ *   @close="abierto = false"
+ * />
+ * ```
+ */
+export const SeatsyooDesigner = componente;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SeatsyooChart, type SeatsyooChartExposed, type SeatsyooChartProps, SeatsyooPlugin } from "./SeatsyooChart.js";
+export { SeatsyooDesigner, type SeatsyooDesignerExposed, type SeatsyooDesignerProps } from "./SeatsyooDesigner.js";
+export type { ChartDocument, EmbeddedDesigner, EmbeddedDesignerOptions, Language, RenderOptions, SeatingChart, SelectedObject, StatusStyle, } from "@seatsyoo/visor";

package/dist/index.js

@@ -0,0 +1,3 @@
+// @seatsyoo/vue: el visor de mapas de asientos de Seatsyoo y su diseñador de planos como componentes de Vue 3.
+export { SeatsyooChart, SeatsyooPlugin } from "./SeatsyooChart.js";
+export { SeatsyooDesigner } from "./SeatsyooDesigner.js";

package/dist/opciones.d.ts

@@ -0,0 +1,99 @@
+import type { RenderOptions, SeatingChart } from "@seatsyoo/visor";
+/**
+ * Opciones que, si cambian, vuelven a montar el visor: deciden qué se carga y cómo se vende. Los arrays y los
+ * objetos se comparan por su valor, no por la referencia: `:channels="['web']"` en cada render no remonta.
+ */
+export declare const OPCIONES_DE_IDENTIDAD: readonly ["server", "publicKey", "event", "link", "document", "season", "seasonEvents", "channels", "pricing", "currency", "locale", "language", "maxSelected", "session", "holdToken", "mode", "showLegend", "showSelectionBar", "floor", "sectors", "view3d", "entrance", "texts"];
+/**
+ * Opciones que se aplican al visor ya montado, sin volver a montarlo: theme y colorBy (setTheme y setColorBy) y, para
+ * el modo «manager», los estilos de los estados y las marcas sobre plazas libres (setStatusStyles y setMarks). Se
+ * comparan por valor, como las de identidad: un objeto nuevo con lo mismo no llama a nada.
+ */
+export declare const OPCIONES_EN_VIVO: readonly ["theme", "colorBy", "statusStyles", "marks"];
+/** Avisos del visor: siempre llaman a la última función recibida, sin volver a montar. */
+export declare const AVISOS: readonly ["onReady", "onChange", "onSelect", "onDeselect", "onError", "onHoldExpired", "onHoldTokenChange", "onFloorChange"];
+type ClaveDeIdentidad = (typeof OPCIONES_DE_IDENTIDAD)[number];
+/**
+ * Cada opción del visor tiene aquí su regla (vuelve a montar, se aplica en vivo o es un aviso). Si el visor gana una
+ * opción nueva, esto deja de compilar hasta decidir qué hace el componente con ella: pasó con `entrance` y `texts`,
+ * que llegaron al visor sin que el componente las pasara, y con `statusStyles` y `marks` (en vivo: el visor tiene
+ * setStatusStyles y setMarks).
+ */
+type SinRegla = Exclude<keyof RenderOptions, ClaveDeIdentidad | (typeof OPCIONES_EN_VIVO)[number] | (typeof AVISOS)[number] | "container" | "load3d">;
+type DebeSerNever<T extends never> = T;
+export type TodasLasOpcionesTienenRegla = DebeSerNever<SinRegla>;
+/**
+ * Lo que identifica a un visor montado: las opciones de identidad (copiando arrays y objetos pequeños, para que
+ * cambiarlos en el sitio también cuente) y si hay `load3d` (la función en sí puede cambiar sin remontar: se
+ * llama siempre a la última).
+ */
+export type Identidad = {
+    [K in ClaveDeIdentidad]: RenderOptions[K];
+} & {
+    load3d: boolean;
+};
+export declare function identidadDe(opciones: Partial<RenderOptions>): Identidad;
+/** Igualdad por valor de datos tipo JSON (cadenas, números, booleanos, null, undefined, arrays y objetos). */
+export declare function igual(a: unknown, b: unknown): boolean;
+/**
+ * Copia normalizada de datos tipo JSON (listas y objetos, a cualquier profundidad): los objetos salen con
+ * Object.prototype (también un diccionario hecho con `Object.create(null)`) y sin las claves que valen `undefined`
+ * (`{ color, icon: undefined }` es lo mismo que `{ color }`: el visor no pinta icono en los dos casos).
+ *
+ * Es la regla de statusStyles y marks, la misma en React, Vue y Angular: lo aplicado en vivo se guarda así copiado, lo
+ * que llega se copia igual antes de compararlo, y el visor recibe esa copia. Así cambiarlo en el sitio también cuenta y
+ * el visor no comparte el objeto de la página (setMarks repinta lo que difiere de lo que tenía, y si fuera el mismo
+ * objeto ya cambiado no vería nada).
+ */
+export declare function copiaDeDatos<T>(valor: T): T;
+/** Con qué valor de cada opción en vivo se montó el visor o se le cambió después (sin indicar, el de por defecto). */
+export interface EnVivo {
+    theme: NonNullable<RenderOptions["theme"]>;
+    colorBy: NonNullable<RenderOptions["colorBy"]>;
+    statusStyles: NonNullable<RenderOptions["statusStyles"]>;
+    marks: NonNullable<RenderOptions["marks"]>;
+}
+/**
+ * Las opciones en vivo con que se monta un visor. Sin theme ni colorBy, los del visor por defecto; sin statusStyles ni
+ * marks, ninguno (`{}`, que para el visor es lo mismo que no pasarlas).
+ */
+export declare function enVivoDe(opciones: Partial<RenderOptions>): EnVivo;
+/** Lo que hay que añadir a las opciones de `render` para montar con estas opciones en vivo (las copias guardadas). */
+export declare function opcionesEnVivo(opciones: Partial<RenderOptions>, enVivo: EnVivo): Partial<RenderOptions>;
+/** Los métodos del visor con que se aplican las opciones en vivo. */
+export type VisorEnVivo = Pick<SeatingChart, "setTheme" | "setColorBy" | "setStatusStyles" | "setMarks">;
+/**
+ * Lleva al visor montado las opciones en vivo que han cambiado (por valor) desde `aplicadas`, y las apunta en
+ * `aplicadas`. Quitar una es volver a la de por defecto: el tema claro, el color por categoría, sin estilos ni marcas.
+ */
+export declare function aplicarEnVivo(visor: VisorEnVivo, aplicadas: EnVivo, opciones: Partial<RenderOptions>): void;
+/** Las opciones sin las que valen `undefined` (el visor usa entonces su valor por defecto). */
+export declare function sinIndefinidos<T extends object>(opciones: T): T;
+/** Lo que hace el visor con un error si nadie escucha `onError`: escribirlo en la consola. */
+export declare function avisarEnConsola(error: {
+    code: string;
+    message: string;
+}): void;
+/**
+ * `render` lanza si faltan opciones (qué enseñar, la clave pública…). En un componente no hay quien lo
+ * recoja, así que se convierte en un error con el código `invalid-options`.
+ */
+export declare function errorDeOpciones(err: unknown): {
+    code: string;
+    message: string;
+};
+/**
+ * Al volver a montar (cambia una opción de identidad), ¿hay que soltar lo que el comprador tiene retenido en el
+ * visor que se va?
+ *
+ * destroy() no suelta lo retenido: así el visor que se monte después en el mismo evento lo recupera (con
+ * `session: "continue"`, guarda su token en sessionStorage). Pero si el nuevo no lo va a recuperar (otro evento u
+ * otra temporada, otro servidor o clave pública, `session: "start"`, un `holdToken` nuevo, modo «manager»), esas
+ * plazas se quedarían bloqueadas para los demás hasta que caduque la retención, sin que la página pueda venderlas
+ * ni soltarlas: el comprador ya no las ve y el token del visor nuevo es otro. Entonces se sueltan.
+ *
+ * Lo retenido con un `holdToken` de la página no se suelta nunca: es de su token y lo lleva su servidor (por
+ * ejemplo, un carrito con varias funciones). Tampoco hay nada que soltar en el modo «manager» ni al solo ver.
+ */
+export declare function sueltaAlCambiar(antes: Identidad, despues: Identidad): boolean;
+export {};