@seatsyoo/vue 0.0.0-stage → 1.1.0

package/dist/opciones.js

@@ -0,0 +1,210 @@
+/**
+ * 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 const OPCIONES_DE_IDENTIDAD = [
+    "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 const OPCIONES_EN_VIVO = ["theme", "colorBy", "statusStyles", "marks"];
+/** Avisos del visor: siempre llaman a la última función recibida, sin volver a montar. */
+export const AVISOS = [
+    "onReady",
+    "onChange",
+    "onSelect",
+    "onDeselect",
+    "onError",
+    "onHoldExpired",
+    "onHoldTokenChange",
+    "onFloorChange",
+];
+export function identidadDe(opciones) {
+    const identidad = { load3d: typeof opciones.load3d === "function" };
+    for (const clave of OPCIONES_DE_IDENTIDAD) {
+        const valor = opciones[clave];
+        // El plano puede ser muy grande: no se copia (se compara por valor solo si llega otro objeto).
+        identidad[clave] = clave === "document" ? valor : copiaSuperficial(valor);
+    }
+    return identidad;
+}
+function copiaSuperficial(valor) {
+    if (Array.isArray(valor))
+        return [...valor];
+    if (valor !== null && typeof valor === "object")
+        return { ...valor };
+    return valor;
+}
+/** Igualdad por valor de datos tipo JSON (cadenas, números, booleanos, null, undefined, arrays y objetos). */
+export function igual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (!igual(a[i], b[i]))
+                return false;
+        return true;
+    }
+    if (Array.isArray(b))
+        return false;
+    const x = a;
+    const y = b;
+    const claves = Object.keys(x);
+    if (claves.length !== Object.keys(y).length)
+        return false;
+    for (const k of claves) {
+        if (!Object.prototype.hasOwnProperty.call(y, k) || !igual(x[k], y[k]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 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 function copiaDeDatos(valor) {
+    if (Array.isArray(valor))
+        return valor.map((v) => copiaDeDatos(v));
+    if (valor !== null && typeof valor === "object") {
+        const entradas = Object.entries(valor).filter(([, v]) => v !== undefined);
+        return Object.fromEntries(entradas.map(([k, v]) => [k, copiaDeDatos(v)]));
+    }
+    return valor;
+}
+/**
+ * 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 function enVivoDe(opciones) {
+    return {
+        theme: opciones.theme ?? "light",
+        colorBy: opciones.colorBy ?? "category",
+        statusStyles: copiaDeDatos(opciones.statusStyles ?? {}),
+        marks: copiaDeDatos(opciones.marks ?? {}),
+    };
+}
+/** Lo que hay que añadir a las opciones de `render` para montar con estas opciones en vivo (las copias guardadas). */
+export function opcionesEnVivo(opciones, enVivo) {
+    return sinIndefinidos({
+        theme: opciones.theme,
+        colorBy: opciones.colorBy,
+        statusStyles: opciones.statusStyles && enVivo.statusStyles,
+        marks: opciones.marks && enVivo.marks,
+    });
+}
+/**
+ * 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 function aplicarEnVivo(visor, aplicadas, opciones) {
+    const tema = opciones.theme ?? "light";
+    if (tema !== aplicadas.theme) {
+        visor.setTheme(tema);
+        aplicadas.theme = tema;
+    }
+    const color = opciones.colorBy ?? "category";
+    if (color !== aplicadas.colorBy) {
+        visor.setColorBy(color);
+        aplicadas.colorBy = color;
+    }
+    // statusStyles y marks: la copia normalizada de lo que llega (copiaDeDatos) contra la de lo aplicado. Un
+    // diccionario sin prototipo o con claves que valen undefined, con lo mismo, no llama a nada (como en Angular).
+    const estilos = copiaDeDatos(opciones.statusStyles ?? {});
+    if (!igual(estilos, aplicadas.statusStyles)) {
+        aplicadas.statusStyles = estilos;
+        visor.setStatusStyles(estilos);
+    }
+    const marcas = copiaDeDatos(opciones.marks ?? {});
+    if (!igual(marcas, aplicadas.marks)) {
+        aplicadas.marks = marcas;
+        visor.setMarks(marcas);
+    }
+}
+/** Las opciones sin las que valen `undefined` (el visor usa entonces su valor por defecto). */
+export function sinIndefinidos(opciones) {
+    return Object.fromEntries(Object.entries(opciones).filter(([, v]) => v !== undefined));
+}
+/** Lo que hace el visor con un error si nadie escucha `onError`: escribirlo en la consola. */
+export function avisarEnConsola(error) {
+    console.warn("[seatsyoo]", error.code, error.message);
+}
+/**
+ * `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 function errorDeOpciones(err) {
+    return { code: "invalid-options", message: err instanceof Error ? err.message : String(err) };
+}
+/**
+ * Qué compra el visor montado con estas opciones: el evento, o la temporada (con los eventos del abono parcial, en
+ * cualquier orden, como los guarda el visor); `null` si solo enseña el plano (`link`, `document`: no retiene nada).
+ */
+function destino(i) {
+    // Con el mismo orden que el visor: document, link, season y event.
+    if (i.document || i.link)
+        return null;
+    if (!i.season)
+        return `evento:${i.event ?? ""}`;
+    const abono = i.seasonEvents?.length ? `@${[...i.seasonEvents].sort().join(",")}` : "";
+    return `temporada:${i.season}${abono}`;
+}
+/**
+ * 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 function sueltaAlCambiar(antes, despues) {
+    if (antes.holdToken !== undefined || antes.mode === "manager" || destino(antes) === null)
+        return false;
+    const recupera = despues.holdToken === undefined &&
+        despues.mode !== "manager" &&
+        (antes.session ?? "continue") === "continue" &&
+        (despues.session ?? "continue") === "continue" &&
+        antes.server === despues.server &&
+        antes.publicKey === despues.publicKey &&
+        destino(antes) === destino(despues);
+    return !recupera;
+}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@seatsyoo/vue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.1.0",
+  "description": "Componente de Vue para el visor de mapas de asientos de Seatsyoo: elegir butacas, retenerlas y venderlas en tiempo real.",
+  "license": "MIT",
+  "keywords": [
+    "seatsyoo",
+    "vue",
+    "mapa de asientos",
+    "butacas",
+    "entradas",
+    "seating chart",
+    "seat map",
+    "tickets"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/*.js",
+    "dist/*.d.ts"
+  ],
+  "dependencies": {
+    "@seatsyoo/visor": "^1.1.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.3.0"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  }
 }