@seatschart/vue 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SeatsChart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,135 @@
-# Temporary Holding Version
+# @seatschart/vue
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Vue 3 components for SeatsChart: the buyer seat chart, the Event Manager and the map designer. They are thin wrappers
+over the script-tag host API of [`@seatschart/embed`](https://www.npmjs.com/package/@seatschart/embed) (`SeatsChart`,
+`SeatsChartEventManager`, `SeatsChartDesigner`): same options, seats.io-compatible callback names and the same
+commands. Works with Nuxt: nothing touches `window` at import and the iframe is created on mount only.
+
+## Install
+
+```bash
+npm install @seatschart/vue @seatschart/embed
+```
+
+Vue 3.3 or newer.
+
+## Buyer seat chart
+
+`token` is a short-lived buyer JWT minted by your server with the API key (`POST /api/viewer-tokens`). Never pass an
+API key or a secret to the browser.
+
+```vue
+<script setup lang="ts">
+import { ref } from "vue";
+import { SeatChart, useSeatChart } from "@seatschart/vue";
+
+const props = defineProps<{ eventId: string; jwt: string }>();
+const chart = useSeatChart(); // typed template ref (SeatChartHandle | null)
+const cart = ref<string[]>([]);
+const maxSeats = ref(4);
+</script>
+
+<template>
+  <SeatChart
+    ref="chart"
+    class="seat-map"
+    web-base="https://your-tenant.seatschart.com"
+    :event="props.eventId"
+    :token="props.jwt"
+    language="pt"
+    :height="640"
+    :max-selected-objects="maxSeats"
+    :object-color="{ byStatus: { locked: '#f59e0b' } }"
+    :settings3d="{ lightPreset: 'exteriorSunset' }"
+    @chart-rendered="(e) => console.log('ready', e.objectCount)"
+    @object-selected="(e) => cart.push(e.label)"
+    @object-deselected="(e) => (cart = cart.filter((l) => l !== e.label))"
+    @session-hold="(e) => console.log('hold token', e.holdToken)"
+    @hold-failed="(e) => console.error(e.objectIds, e.message)"
+  />
+  <button type="button" @click="chart?.clearSelection()">Clear</button>
+  <button type="button" @click="chart?.selectBestAvailable({ number: 2, categories: ['VIP'] })">Best 2 VIP</button>
+  <button type="button" @click="chart?.showViewFromSeat(cart[0] ?? '')">View from seat</button>
+</template>
+```
+
+- **Props** are the `SeatsChart` options of `@seatschart/embed` (`event`, `token`, `webBase`, `parentOrigin`,
+  `channel`, `channelKey(s)`, `holdToken`, `pricing`, `language`, `theme`, `defaultRenderer`, …) and every declarative
+  renderer option (`objectColor`, `objectLabel`, `tooltip`, `maxSelectedObjects`, `legend`, `filterControls`,
+  `settings3d`, …). The chart `style` option (`{ font, cornerRadius, buttonShape }`) is **`chart-style`**: `class` and
+  `style` style the wrapper `<div data-seatschart-chart>`; `class-name` styles the iframe.
+- **Reactive updates**: values are compared, not identities (nested changes count). Declarative options and `pricing`
+  are applied live with `changeConfig` (no reload); `height`, `title` and `class-name` update the iframe in place; any
+  other prop re-renders the iframe and the hold session continues.
+- **Events**: every chart callback, kebab-case without `on`: `@object-selected`, `@object-clicked`,
+  `@hold-succeeded`, `@hold-confirmed`, `@selection-invalid`, `@best-available-selected`, `@floor-changed`,
+  `@full-screen-opened`, `@hold-created` (`SEATSCHART_RESERVATION_SUCCESS`), … (payloads as in `@seatschart/embed`).
+- **Host-drawn prompts**: a `@places-prompt`, `@ticket-type-prompt` or `@places-with-ticket-types-prompt` handler
+  switches that viewer prompt to your page; it gets `(params, confirm, cancel)`.
+- **Template ref** (`SeatChartHandle`): every `SeatsChart` command — `selectObjects`, `deselectObjects`,
+  `clearSelection`, `trySelectObjects`, `selectBestAvailable`, `changeConfig`, `setFilters`, `zoomToObjects`,
+  `zoomToSection`, `goToFloor`, `showViewFromSeat`, `getHoldToken`, `releaseHoldToken`, `exportImage`, … Each resolves
+  once the chart rendered and rejects with `ChartCommandError`. Also `selectedObjects`, `holdToken`, `chart` (the
+  `SeatsChart` instance), `getIframe()` and `rerender()`.
+- **Cleanup**: unmounting removes the iframe and its message listener; pending commands reject.
+
+## Event Manager (back office)
+
+```vue
+<script setup lang="ts">
+import { EventManager, useEventManager } from "@seatschart/vue";
+const manager = useEventManager();
+</script>
+
+<template>
+  <EventManager
+    ref="manager"
+    web-base="https://your-tenant.seatschart.com"
+    :event="eventId"
+    :token="managerEmbedToken"
+    mode="select"
+    color-scheme="auto"
+    :max-selected-objects="8"
+    @selection-changed="(objects) => (cart = objects.map((o) => o.label))"
+  />
+  <button type="button" @click="manager?.setHighlightedObjects(['A-1'])">Highlight A-1</button>
+</template>
+```
+
+Selectability rules, `max-selected-objects`, `selected-objects`, `order`, `filters`, `language` and `color-scheme`
+change live (`changeConfig`); `mode`, `event` or `token` re-render the iframe. The ref has every
+`SeatsChartEventManager` command (`listSelectedObjects`, `selectObjects`, `listOrderChanges`, `zoomToObjects`, …).
+
+## Designer
+
+```vue
+<script setup lang="ts">
+import { Designer, useDesigner } from "@seatschart/vue";
+const designer = useDesigner();
+</script>
+
+<template>
+  <Designer
+    ref="designer"
+    web-base="https://your-tenant.seatschart.com"
+    :token="designerEmbedToken"
+    :chart-id="chartId"
+    mode="safe"
+    canvas-color-scheme="dark"
+    @chart-updated="(id) => (saved = true)"
+    @exit-requested="router.back()"
+  />
+  <button type="button" @click="designer?.publish('Summer layout')">Publish</button>
+</template>
+```
+
+Without `chart-id` the designer creates a chart (`@chart-created`). The Exit button shows only with an
+`@exit-requested` handler. `language`, `color-scheme`, `canvas-color-scheme`, `mode` and `safe-mode-options` change
+live. The ref has `save()`, `publish(note?)`, `getState()`, `changeConfig()` and `chartId`.
+
+## Documentation
+
+- [Embed guide](https://github.com/seatschart/seatschart-prod/blob/main/docs/locales/en/README.md) and
+  [Quickstart](https://github.com/seatschart/seatschart-prod/blob/main/docs/locales/en/QUICKSTART.md)
+- Every option, callback and command: `@seatschart/embed` (`SeatsChartConfig`, `SeatsChartEventManagerConfig`,
+  `SeatsChartDesignerConfig`).

package/dist/Designer.d.ts

@@ -0,0 +1,65 @@
+import { type ShallowRef } from "vue";
+import type { DesignerCallbacks, DesignerMode, SeatsChartDesigner, SeatsChartDesignerConfig } from "@seatschart/embed";
+import { EmbedBinding, type DesignerCallbackKey, type DesignerCommands, type DesignerConfigKey } from "./host-core.js";
+import { type CallbackEmits } from "./define.js";
+/** `<Designer>` props: the `SeatsChartDesigner` config (seats.io `SeatingChartDesigner` names) without the container. */
+export type DesignerProps = {
+    [K in DesignerConfigKey]?: SeatsChartDesignerConfig[K];
+} & {
+    /** seats.io `onExitRequested` (`@exit-requested`): the Exit button shows only when a handler is set. */
+    onExitRequested?: () => void;
+};
+type DesignerEventKey = Exclude<DesignerCallbackKey, "onExitRequested">;
+/** Every designer callback as an event: `onChartUpdated` → `@chart-updated` (same arguments). */
+export type DesignerEmits = CallbackEmits<DesignerCallbacks, DesignerEventKey>;
+/** Template ref API: every `SeatsChartDesigner` command (each waits for the designer to render). */
+export type DesignerHandle = DesignerCommands & {
+    /** The underlying `SeatsChartDesigner` (null before mount / after unmount). */
+    readonly designer: SeatsChartDesigner | null;
+    /** The chart being edited (the created one when no `chartId` was given; null until known). */
+    readonly chartId: string | null;
+    readonly mode: DesignerMode | null;
+    getIframe: () => HTMLIFrameElement | null;
+    /** Re-create the iframe with the current props (keeps the chart created inside the designer). */
+    rerender: () => void;
+};
+export declare function createDesignerHandle(binding: EmbedBinding<SeatsChartDesigner>): DesignerHandle;
+/**
+ * The embedded SeatsChart map designer. Without `chartId` it creates a chart (`@chart-created`). `language`,
+ * `colorScheme`, `canvasColorScheme`, `mode` and `safeModeOptions` are applied live with `changeConfig`; other changes
+ * re-render the iframe. `token` is a short-lived designer embed token from your backend — never a secret key.
+ */
+export declare const Designer: import("vue").DefineSetupFnComponent<DesignerProps, DesignerEmits, {}, {
+    canvasColorScheme?: "auto" | "dark" | "light" | undefined;
+    chartId?: string | undefined;
+    chartKey?: string | undefined;
+    className?: string | undefined;
+    colorScheme?: "auto" | "dark" | "light" | undefined;
+    features?: import("@seatschart/embed").DesignerFeatureGates | undefined;
+    height?: string | number | undefined;
+    language?: "ar" | "az" | "bn" | "de" | "en" | "es" | "fa" | "fr" | "gu" | "hi" | "id" | "it" | "ja" | "kk" | "kn" | "ko" | "ml" | "mr" | "ms" | "nl" | "pl" | "ps" | "pt" | "ru" | "ta" | "te" | "th" | "tr" | "uk" | "ur" | "vi" | "zh" | undefined;
+    mode?: "normal" | "readOnly" | "safe" | undefined;
+    openDraftDrawing?: boolean | undefined;
+    openLatestDrawing?: boolean | undefined;
+    parentOrigin?: string | undefined;
+    safeModeOptions?: import("@seatschart/embed").DesignerSafeModeOptions | undefined;
+    timeoutMs?: number | undefined;
+    title?: string | undefined;
+    token?: string | undefined;
+    webBase?: string | undefined;
+} & {
+    /** seats.io `onExitRequested` (`@exit-requested`): the Exit button shows only when a handler is set. */
+    onExitRequested?: () => void;
+} & {
+    onActionRefused?: ((event: import("@seatschart/embed").DesignerActionRefused) => any) | undefined;
+    onChartCreated?: ((chartId: string, event: import("@seatschart/embed").DesignerChartCreated) => any) | undefined;
+    onChartPublished?: ((chartId: string, event: import("@seatschart/embed").DesignerChartPublished) => any) | undefined;
+    onChartUpdated?: ((chartId: string, event: import("@seatschart/embed").DesignerChartUpdated) => any) | undefined;
+    onDesignerRendered?: ((designer: SeatsChartDesigner, event: import("@seatschart/embed").DesignerRendered) => any) | undefined;
+    onDesignerRenderingFailed?: ((designer: SeatsChartDesigner, event: import("@seatschart/embed").DesignerRenderingFailed) => any) | undefined;
+    onError?: ((error: import("@seatschart/embed").DesignerErrorInfo) => any) | undefined;
+}, import("vue").PublicProps>;
+/** A typed template ref for `<Designer ref="designer">`. */
+export declare function useDesigner(): ShallowRef<DesignerHandle | null>;
+export {};
+//# sourceMappingURL=Designer.d.ts.map

package/dist/Designer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Designer.d.ts","sourceRoot":"","sources":["../src/Designer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqE,KAAK,UAAU,EAAE,MAAM,KAAK,CAAC;AACzG,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AACvH,OAAO,EAKL,YAAY,EAEZ,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAA2C,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAE1F,yHAAyH;AACzH,MAAM,MAAM,aAAa,GAAG;KAAG,CAAC,IAAI,iBAAiB,CAAC,CAAC,EAAE,wBAAwB,CAAC,CAAC,CAAC;CAAE,GAAG;IACvF,wGAAwG;IACxG,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,KAAK,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAC;AAExE,iGAAiG;AACjG,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,CAAC;AAE/E,oGAAoG;AACpG,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG;IAC9C,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC7C,8FAA8F;IAC9F,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,SAAS,EAAE,MAAM,iBAAiB,GAAG,IAAI,CAAC;IAC1C,iGAAiG;IACjG,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAIF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,CAAC,kBAAkB,CAAC,GAAG,cAAc,CAW9F;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;IAzCnB,wGAAwG;sBACtF,MAAM,IAAI;;;;;;;;;6BA8D7B,CAAC;AAEF,4DAA4D;AAC5D,wBAAgB,WAAW,IAAI,UAAU,CAAC,cAAc,GAAG,IAAI,CAAC,CAE/D"}

package/dist/Designer.js

@@ -0,0 +1,45 @@
+import { defineComponent, h, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import { DESIGNER_CALLBACKS, DESIGNER_COMMANDS, DESIGNER_KEYS, DESIGNER_KIND, EmbedBinding, delegateCommands, } from "./host-core.js";
+import { emitForwarders, eventNames, pickOptions } from "./define.js";
+const EVENT_CALLBACKS = DESIGNER_CALLBACKS.filter((key) => key !== "onExitRequested");
+export function createDesignerHandle(binding) {
+    const handle = {
+        ...delegateCommands(() => binding.current, DESIGNER_COMMANDS, binding.label),
+        getIframe: () => binding.current?.getIframe() ?? null,
+        rerender: () => binding.rerender(),
+    };
+    return Object.defineProperties(handle, {
+        designer: { enumerable: true, get: () => binding.current },
+        chartId: { enumerable: true, get: () => binding.current?.chartId ?? null },
+        mode: { enumerable: true, get: () => binding.current?.mode ?? null },
+    });
+}
+/**
+ * The embedded SeatsChart map designer. Without `chartId` it creates a chart (`@chart-created`). `language`,
+ * `colorScheme`, `canvasColorScheme`, `mode` and `safeModeOptions` are applied live with `changeConfig`; other changes
+ * re-render the iframe. `token` is a short-lived designer embed token from your backend — never a secret key.
+ */
+export const Designer = defineComponent((props, { emit, expose }) => {
+    const container = shallowRef(null);
+    const binding = new EmbedBinding(DESIGNER_KIND);
+    const forwarders = emitForwarders(EVENT_CALLBACKS, emit);
+    const exit = () => props.onExitRequested?.();
+    const config = () => ({
+        ...pickOptions(props, DESIGNER_KEYS),
+        ...forwarders,
+        // Its presence shows the Exit button (adding or removing the handler re-renders the designer).
+        ...(props.onExitRequested !== undefined ? { onExitRequested: exit } : {}),
+    });
+    onMounted(() => {
+        if (container.value !== null)
+            binding.mount(container.value, config());
+    });
+    watch(config, (next) => binding.update(next), { deep: true });
+    onBeforeUnmount(() => binding.destroy());
+    expose(createDesignerHandle(binding));
+    return () => h("div", { ref: container, "data-seatschart-designer": "" });
+}, { name: "Designer", props: [...DESIGNER_KEYS, "onExitRequested"], emits: eventNames(EVENT_CALLBACKS) });
+/** A typed template ref for `<Designer ref="designer">`. */
+export function useDesigner() {
+    return shallowRef(null);
+}

package/dist/EventManager.d.ts

@@ -0,0 +1,44 @@
+import { type ShallowRef } from "vue";
+import type { EventManagerCallbacks, EventManagerMode, SeatsChartEventManager, SeatsChartEventManagerConfig } from "@seatschart/embed";
+import { EmbedBinding, type EventManagerCallbackKey, type EventManagerCommands, type EventManagerConfigKey } from "./host-core.js";
+import { type CallbackEmits } from "./define.js";
+/** `<EventManager>` props: the `SeatsChartEventManager` config (seats.io `EventManager` names) without the container. */
+export type EventManagerProps = {
+    [K in EventManagerConfigKey]?: SeatsChartEventManagerConfig[K];
+};
+/** Every manager callback as an event: `onSelectionChanged` → `@selection-changed` (same payload). */
+export type EventManagerEmits = CallbackEmits<EventManagerCallbacks, EventManagerCallbackKey>;
+/** Template ref API: every `SeatsChartEventManager` command (each waits for the manager to render). */
+export type EventManagerHandle = EventManagerCommands & {
+    /** The underlying `SeatsChartEventManager` (null before mount / after unmount). */
+    readonly manager: SeatsChartEventManager | null;
+    /** Ids of the selected objects, synchronously. */
+    readonly selectedObjects: string[];
+    readonly mode: EventManagerMode | null;
+    getIframe: () => HTMLIFrameElement | null;
+    /** Re-create the iframe with the current props (the selection is cleared). */
+    rerender: () => void;
+};
+export declare function createEventManagerHandle(binding: EmbedBinding<SeatsChartEventManager>): EventManagerHandle;
+/**
+ * The embedded SeatsChart Event Manager (back office). Selectability rules, `maxSelectedObjects`, `selectedObjects`,
+ * `order`, `filters`, `language` and `colorScheme` are applied live with `changeConfig`; other changes re-render the
+ * iframe. `token` is a short-lived manager embed token from your backend — never a secret key.
+ */
+export declare const EventManager: import("vue").DefineSetupFnComponent<EventManagerProps, EventManagerEmits, {}, EventManagerProps & {
+    onChartRendered?: ((event: import("@seatschart/embed").EventManagerRendered) => any) | undefined;
+    onChartRenderingFailed?: ((event: import("@seatschart/embed").EventManagerRenderingFailed) => any) | undefined;
+    onError?: ((error: import("@seatschart/embed").EventManagerErrorInfo) => any) | undefined;
+    onEventManagerRendered?: ((event: import("@seatschart/embed").EventManagerRendered) => any) | undefined;
+    onModeChanged?: ((mode: "createOrder" | "editOrder" | "filter" | "history" | "manageCategories" | "manageChannels" | "manageForSale" | "manageListings" | "manageObjectStatuses" | "manageTableBooking" | "salesRules" | "select" | "static") => any) | undefined;
+    onObjectDeselected?: ((object: import("@seatschart/embed").EventManagerObject) => any) | undefined;
+    onObjectSelected?: ((object: import("@seatschart/embed").EventManagerObject) => any) | undefined;
+    onOrderChanged?: ((changes: import("@seatschart/embed").OrderChange[]) => any) | undefined;
+    onSelectionChanged?: ((objects: import("@seatschart/embed").EventManagerObject[]) => any) | undefined;
+    onSelectionInvalid?: ((event: import("@seatschart/embed").EventManagerSelectionInvalid) => any) | undefined;
+    onSubmitFailed?: ((event: import("@seatschart/embed").EventManagerSubmitFailed) => any) | undefined;
+    onSubmitSucceeded?: ((event: import("@seatschart/embed").EventManagerSubmitSucceeded) => any) | undefined;
+}, import("vue").PublicProps>;
+/** A typed template ref for `<EventManager ref="manager">`. */
+export declare function useEventManager(): ShallowRef<EventManagerHandle | null>;
+//# sourceMappingURL=EventManager.d.ts.map

package/dist/EventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventManager.d.ts","sourceRoot":"","sources":["../src/EventManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqE,KAAK,UAAU,EAAE,MAAM,KAAK,CAAC;AACzG,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AACvI,OAAO,EAKL,YAAY,EAEZ,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAA2C,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAE1F,yHAAyH;AACzH,MAAM,MAAM,iBAAiB,GAAG;KAAG,CAAC,IAAI,qBAAqB,CAAC,CAAC,EAAE,4BAA4B,CAAC,CAAC,CAAC;CAAE,CAAC;AAEnG,sGAAsG;AACtG,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,qBAAqB,EAAE,uBAAuB,CAAC,CAAC;AAE9F,uGAAuG;AACvG,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG;IACtD,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAChD,kDAAkD;IAClD,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,SAAS,EAAE,MAAM,iBAAiB,GAAG,IAAI,CAAC;IAC1C,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,YAAY,CAAC,sBAAsB,CAAC,GAAG,kBAAkB,CAW1G;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;6BAgBxB,CAAC;AAEF,+DAA+D;AAC/D,wBAAgB,eAAe,IAAI,UAAU,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAEvE"}

package/dist/EventManager.js

@@ -0,0 +1,38 @@
+import { defineComponent, h, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import { EVENT_MANAGER_CALLBACKS, EVENT_MANAGER_COMMANDS, EVENT_MANAGER_KEYS, EVENT_MANAGER_KIND, EmbedBinding, delegateCommands, } from "./host-core.js";
+import { emitForwarders, eventNames, pickOptions } from "./define.js";
+export function createEventManagerHandle(binding) {
+    const handle = {
+        ...delegateCommands(() => binding.current, EVENT_MANAGER_COMMANDS, binding.label),
+        getIframe: () => binding.current?.getIframe() ?? null,
+        rerender: () => binding.rerender(),
+    };
+    return Object.defineProperties(handle, {
+        manager: { enumerable: true, get: () => binding.current },
+        selectedObjects: { enumerable: true, get: () => binding.current?.selectedObjects ?? [] },
+        mode: { enumerable: true, get: () => binding.current?.mode ?? null },
+    });
+}
+/**
+ * The embedded SeatsChart Event Manager (back office). Selectability rules, `maxSelectedObjects`, `selectedObjects`,
+ * `order`, `filters`, `language` and `colorScheme` are applied live with `changeConfig`; other changes re-render the
+ * iframe. `token` is a short-lived manager embed token from your backend — never a secret key.
+ */
+export const EventManager = defineComponent((props, { emit, expose }) => {
+    const container = shallowRef(null);
+    const binding = new EmbedBinding(EVENT_MANAGER_KIND);
+    const forwarders = emitForwarders(EVENT_MANAGER_CALLBACKS, emit);
+    const config = () => ({ ...pickOptions(props, EVENT_MANAGER_KEYS), ...forwarders });
+    onMounted(() => {
+        if (container.value !== null)
+            binding.mount(container.value, config());
+    });
+    watch(config, (next) => binding.update(next), { deep: true });
+    onBeforeUnmount(() => binding.destroy());
+    expose(createEventManagerHandle(binding));
+    return () => h("div", { ref: container, "data-seatschart-event-manager": "" });
+}, { name: "EventManager", props: [...EVENT_MANAGER_KEYS], emits: eventNames(EVENT_MANAGER_CALLBACKS) });
+/** A typed template ref for `<EventManager ref="manager">`. */
+export function useEventManager() {
+    return shallowRef(null);
+}

package/dist/SeatChart.d.ts

@@ -0,0 +1,164 @@
+import { type ShallowRef } from "vue";
+import { type SeatsChart, type SeatsChartConfig, type SeatsChartPromptCallbacks } from "@seatschart/embed";
+import { EmbedBinding, type ChartCallbackKey, type ChartCommands, type ChartConfigKey } from "./host-core.js";
+import { type CallbackEmits } from "./define.js";
+/**
+ * `<SeatChart>` options: every `SeatsChart` option of `@seatschart/embed` (seats.io renderer names) except the
+ * container. The chart `style` option (font, corner radius, button shape) is `chartStyle`, so the `style` and `class`
+ * attributes keep styling the wrapper element.
+ */
+export type SeatChartOptions = {
+    [K in Exclude<ChartConfigKey, "style">]?: SeatsChartConfig[K];
+} & {
+    /** The chart's `style` option (`{ font, cornerRadius, buttonShape }`), not CSS. */
+    chartStyle?: SeatsChartConfig["style"];
+};
+/** `<SeatChart>` props: the options plus the host-drawn prompts (`@places-prompt`, …), which switch the matching viewer prompt to the host page. */
+export type SeatChartProps = SeatChartOptions & SeatsChartPromptCallbacks;
+/** The chart callbacks (seats.io names) the events mirror. */
+export type SeatChartCallbacks = Pick<SeatsChartConfig, ChartCallbackKey>;
+/** Every chart callback as an event: `onObjectSelected` → `@object-selected` (same payload). */
+export type SeatChartEmits = CallbackEmits<SeatChartCallbacks, ChartCallbackKey>;
+/** Template ref API: every `SeatsChart` command (each waits for the chart to render) plus the live state. */
+export type SeatChartHandle = ChartCommands & {
+    /** The underlying `SeatsChart` instance (null before mount / after unmount). */
+    readonly chart: SeatsChart | null;
+    /** Seats.io `selectedObjects`: ids of the selected objects, synchronously. */
+    readonly selectedObjects: string[];
+    /** Current hold token, synchronously (null before a session exists). */
+    readonly holdToken: string | null;
+    getIframe: () => HTMLIFrameElement | null;
+    /** Re-create the iframe with the current props; an active hold session continues. */
+    rerender: () => void;
+};
+export declare function createSeatChartHandle(binding: EmbedBinding<SeatsChart>): SeatChartHandle;
+/**
+ * The SeatsChart buyer seat map (sandboxed viewer iframe). Props map to the `SeatsChart` loader options; changes to
+ * declarative options (colours, labels, caps, pricing, prompts, `settings3d`, …) are applied live with
+ * `changeConfig`, other changes re-render the iframe (the hold session continues). Every chart callback is an event.
+ * `token` is a short-lived buyer JWT from your backend — never an API key.
+ */
+export declare const SeatChart: import("vue").DefineSetupFnComponent<SeatChartProps, SeatChartEmits, {}, {
+    accessibilityFilter?: ("aisle" | "companion" | "hearing" | "hideLimitedLegroom" | "hideLimitedView" | "hideVertigo" | "liftUpArmrests" | "plusSize" | "semiAmbulatory" | "wheelchair")[] | undefined;
+    activeFloor?: string | undefined;
+    allowFullscreen?: boolean | undefined;
+    availableCategories?: string[] | undefined;
+    backgroundColor?: string | number | undefined;
+    canGoBack?: boolean | undefined;
+    channel?: string | undefined;
+    channelKey?: string | undefined;
+    channelKeys?: string[] | undefined;
+    className?: string | undefined;
+    currency?: string | undefined;
+    defaultRenderer?: "2d" | "3d" | undefined;
+    event?: string | undefined;
+    events?: string[] | undefined;
+    filterControls?: boolean | import("@seatschart/embed").FilterControlsConfig | undefined;
+    fitTo?: import("@seatschart/embed").ChartFitTo | undefined;
+    form?: string | HTMLFormElement | undefined;
+    fullScreenTarget?: import("@seatschart/embed").FullScreenTarget | undefined;
+    gestureHandling?: import("@seatschart/embed").GestureHandling | undefined;
+    height?: string | number | undefined;
+    hideSectionsNotForSale?: boolean | undefined;
+    holdToken?: string | undefined;
+    holdTokenInputName?: string | undefined;
+    isObjectVisible?: import("@seatschart/embed").ObjectOverrides<boolean> | undefined;
+    language?: "ar" | "az" | "bn" | "de" | "en" | "es" | "fa" | "fr" | "gu" | "hi" | "id" | "it" | "ja" | "kk" | "kn" | "ko" | "ml" | "mr" | "ms" | "nl" | "pl" | "ps" | "pt" | "ru" | "ta" | "te" | "th" | "tr" | "uk" | "ur" | "vi" | "zh" | undefined;
+    legend?: import("@seatschart/embed").LegendConfig | undefined;
+    loading?: import("@seatschart/embed").ChartLoadingConfig | undefined;
+    lockActiveFloor?: boolean | undefined;
+    maxSelectedObjects?: number | import("@seatschart/embed").MaxSelectedObjectsConfig | undefined;
+    messages?: Record<string, string> | undefined;
+    minimumSelectedPlaces?: number | undefined;
+    mode?: import("@seatschart/embed").ChartMode | undefined;
+    multiSelectEnabled?: boolean | undefined;
+    numberOfPlacesToSelect?: number | undefined;
+    objectColor?: import("@seatschart/embed").ObjectOverrides<string> | undefined;
+    objectIcon?: import("@seatschart/embed").ObjectOverrides<"ban" | "bolt" | "check" | "eye" | "heart" | "info" | "star" | "tag"> | undefined;
+    objectLabel?: import("@seatschart/embed").ObjectOverrides<string> | undefined;
+    objectPopover?: import("@seatschart/embed").ObjectPopoverConfig | undefined;
+    objectWithoutCategorySelectable?: boolean | undefined;
+    objectWithoutPricingSelectable?: boolean | undefined;
+    parentOrigin?: string | undefined;
+    partySize?: number | import("@seatschart/embed").PartySizeConfig | undefined;
+    priceFormatter?: import("@seatschart/embed").PriceFormatterSpec | undefined;
+    pricing?: unknown;
+    prompts?: import("@seatschart/embed").ChartPromptsConfig | undefined;
+    publicKey?: string | undefined;
+    resaleListings?: import("@seatschart/embed").ResaleListingsConfig | undefined;
+    season?: string | undefined;
+    sectionColor?: import("@seatschart/embed").ObjectOverrides<string> | undefined;
+    selectableObjects?: string[] | undefined;
+    selectedObjects?: import("@seatschart/embed").ChartObjectRefInput[] | undefined;
+    selectedObjectsInputName?: string | undefined;
+    selectionModes?: import("@seatschart/embed").BuyerSelectionMode[] | undefined;
+    selectionValidators?: import("@seatschart/embed").SelectionValidatorsConfig | undefined;
+    session?: import("@seatschart/embed").SessionMode | undefined;
+    sessionMode?: import("@seatschart/embed").SessionMode | undefined;
+    settings3d?: import("@seatschart/embed").Settings3dConfig | undefined;
+    showFilterControls?: boolean | undefined;
+    showFloorElevator?: boolean | undefined;
+    showFullScreenButton?: boolean | undefined;
+    showLegend?: boolean | undefined;
+    showMinimap?: boolean | undefined;
+    showObjectPopover?: boolean | undefined;
+    showSeatLabels?: boolean | undefined;
+    showSectionContents?: import("@seatschart/embed").ShowSectionContents | undefined;
+    showSectionPricingOverlay?: boolean | undefined;
+    showSurroundings?: boolean | undefined;
+    showZoomOutButton?: boolean | undefined;
+    statusPalette?: "accessible" | "standard" | undefined;
+    theme?: "auto" | "dark" | "light" | undefined;
+    timeoutMs?: number | undefined;
+    title?: string | undefined;
+    token?: string | undefined;
+    tooltip?: import("@seatschart/embed").TooltipConfig | undefined;
+    transparent?: boolean | undefined;
+    unavailableCategories?: string[] | undefined;
+    webBase?: string | undefined;
+    workspaceKey?: string | undefined;
+} & {
+    /** The chart's `style` option (`{ font, cornerRadius, buttonShape }`), not CSS. */
+    chartStyle?: SeatsChartConfig["style"];
+} & SeatsChartPromptCallbacks & {
+    onAccessibilityFilterChanged?: ((event: import("@seatschart/embed").ChartAccessibilityFilterChanged) => any) | undefined;
+    onBestAvailableFailed?: ((event: import("@seatschart/embed").ChartBestAvailableFailed) => any) | undefined;
+    onBestAvailableSelected?: ((event: import("@seatschart/embed").ChartBestAvailableSelected) => any) | undefined;
+    onBestAvailableSelectionFailed?: ((event: import("@seatschart/embed").ChartBestAvailableFailed) => any) | undefined;
+    onChartRendered?: ((event: import("@seatschart/embed").ChartRendered) => any) | undefined;
+    onChartRenderingFailed?: ((event: import("@seatschart/embed").ChartRenderingFailed) => any) | undefined;
+    onChartRerenderingStarted?: ((event: import("@seatschart/embed").ChartRerendering) => any) | undefined;
+    onFilteredCategoriesChanged?: ((event: import("@seatschart/embed").ChartFilteredCategoriesChanged) => any) | undefined;
+    onFiltersChanged?: ((event: import("@seatschart/embed").ChartFiltersChanged) => any) | undefined;
+    onFloorChanged?: ((event: import("@seatschart/embed").ChartFloorChanged) => any) | undefined;
+    onFullScreenClosed?: ((event: import("@seatschart/embed").ChartFullScreenClosed) => any) | undefined;
+    onFullScreenOpened?: ((event: import("@seatschart/embed").ChartFullScreenOpened) => any) | undefined;
+    onFullScreenRequest?: ((event: import("@seatschart/embed").ChartFullScreenRequest) => any) | undefined;
+    onHoldCallsComplete?: ((event: import("@seatschart/embed").ChartHoldSettled) => any) | undefined;
+    onHoldCallsInProgress?: ((event: import("@seatschart/embed").ChartHoldPending) => any) | undefined;
+    onHoldConfirmed?: ((event: import("@seatschart/embed").ChartHoldConfirmed) => any) | undefined;
+    onHoldCreated?: ((payload: import("@seatschart/embed").EmbedReservationPayload) => any) | undefined;
+    onHoldFailed?: ((event: import("@seatschart/embed").ChartHoldFailed) => any) | undefined;
+    onHoldSucceeded?: ((event: import("@seatschart/embed").ChartHoldSucceeded) => any) | undefined;
+    onHoldTokenExpired?: ((event: import("@seatschart/embed").ChartSessionExpired) => any) | undefined;
+    onObjectClicked?: ((event: import("@seatschart/embed").ChartObjectClicked) => any) | undefined;
+    onObjectDeselected?: ((event: import("@seatschart/embed").ChartObjectDeselected) => any) | undefined;
+    onObjectHovered?: ((event: import("@seatschart/embed").ChartObjectHovered) => any) | undefined;
+    onObjectMouseOut?: ((event: import("@seatschart/embed").ChartObjectUnhovered) => any) | undefined;
+    onObjectMouseOver?: ((event: import("@seatschart/embed").ChartObjectHovered) => any) | undefined;
+    onObjectSelected?: ((event: import("@seatschart/embed").ChartObjectSelected) => any) | undefined;
+    onObjectStatusChanged?: ((event: import("@seatschart/embed").ChartObjectStatusChanged) => any) | undefined;
+    onObjectUnhovered?: ((event: import("@seatschart/embed").ChartObjectUnhovered) => any) | undefined;
+    onPromptRequest?: ((event: import("@seatschart/embed").ChartPromptRequest) => any) | undefined;
+    onReleaseHoldFailed?: ((event: import("@seatschart/embed").ChartReleaseFailed) => any) | undefined;
+    onReleaseHoldSucceeded?: ((event: import("@seatschart/embed").ChartReleaseSucceeded) => any) | undefined;
+    onSelectedObjectBooked?: ((event: import("@seatschart/embed").ChartHoldConfirmed) => any) | undefined;
+    onSelectedObjectUnavailable?: ((event: import("@seatschart/embed").ChartSelectionLost) => any) | undefined;
+    onSelectionInvalid?: ((event: import("@seatschart/embed").ChartSelectionInvalid) => any) | undefined;
+    onSelectionValid?: ((event: import("@seatschart/embed").ChartSelectionValid) => any) | undefined;
+    onSessionHold?: ((event: import("@seatschart/embed").ChartSessionHold) => any) | undefined;
+    onSessionInitialized?: ((event: import("@seatschart/embed").ChartSessionInitialized) => any) | undefined;
+}, import("vue").PublicProps>;
+/** A typed template ref for `<SeatChart ref="chart">` (`const chart = useSeatChart()` in `<script setup>`). */
+export declare function useSeatChart(): ShallowRef<SeatChartHandle | null>;
+//# sourceMappingURL=SeatChart.d.ts.map

package/dist/SeatChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SeatChart.d.ts","sourceRoot":"","sources":["../src/SeatChart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqE,KAAK,UAAU,EAAE,MAAM,KAAK,CAAC;AACzG,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,EAC/B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAKL,YAAY,EAGZ,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EAEpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAA2C,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAE1F;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG;KAAG,CAAC,IAAI,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;CAAE,GAAG;IACjG,mFAAmF;IACnF,UAAU,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CACxC,CAAC;AAEF,oJAAoJ;AACpJ,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,yBAAyB,CAAC;AAE1E,8DAA8D;AAC9D,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;AAE1E,gGAAgG;AAChG,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAAC;AAEjF,6GAA6G;AAC7G,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG;IAC5C,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAClC,8EAA8E;IAC9E,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IACnC,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,SAAS,EAAE,MAAM,iBAAiB,GAAG,IAAI,CAAC;IAC1C,qFAAqF;IACrF,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAIF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,GAAG,eAAe,CAWxF;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/CpB,mFAAmF;iBACtE,gBAAgB,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAmFvC,CAAC;AAEF,+GAA+G;AAC/G,wBAAgB,YAAY,IAAI,UAAU,CAAC,eAAe,GAAG,IAAI,CAAC,CAEjE"}

package/dist/SeatChart.js

@@ -0,0 +1,68 @@
+import { defineComponent, h, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import { promptsForCallbacks, } from "@seatschart/embed";
+import { CHART_CALLBACKS, CHART_COMMANDS, CHART_CONFIG_KEYS, CHART_KIND, EmbedBinding, PROMPT_CALLBACKS, delegateCommands, } from "./host-core.js";
+import { emitForwarders, eventNames, pickOptions } from "./define.js";
+const OPTION_KEYS = CHART_CONFIG_KEYS.map((key) => (key === "style" ? "chartStyle" : key));
+export function createSeatChartHandle(binding) {
+    const handle = {
+        ...delegateCommands(() => binding.current, CHART_COMMANDS, binding.label),
+        getIframe: () => binding.current?.getIframe() ?? null,
+        rerender: () => binding.rerender(),
+    };
+    return Object.defineProperties(handle, {
+        chart: { enumerable: true, get: () => binding.current },
+        selectedObjects: { enumerable: true, get: () => binding.current?.selectedObjects ?? [] },
+        holdToken: { enumerable: true, get: () => binding.current?.holdToken ?? null },
+    });
+}
+/**
+ * The SeatsChart buyer seat map (sandboxed viewer iframe). Props map to the `SeatsChart` loader options; changes to
+ * declarative options (colours, labels, caps, pricing, prompts, `settings3d`, …) are applied live with
+ * `changeConfig`, other changes re-render the iframe (the hold session continues). Every chart callback is an event.
+ * `token` is a short-lived buyer JWT from your backend — never an API key.
+ */
+export const SeatChart = defineComponent((props, { emit, expose }) => {
+    const container = shallowRef(null);
+    const binding = new EmbedBinding(CHART_KIND);
+    const forwarders = emitForwarders(CHART_CALLBACKS, emit);
+    // A set prompt handler switches its viewer prompt to the host (adding / removing one re-renders the chart). The
+    // forwarder reads the latest handler when a prompt arrives.
+    const promptForwarders = {};
+    for (const key of PROMPT_CALLBACKS) {
+        promptForwarders[key] = (params, confirm, cancel) => {
+            const handler = props[key];
+            if (handler === undefined)
+                cancel();
+            else
+                handler(params, confirm, cancel);
+        };
+    }
+    const config = () => {
+        const options = pickOptions(props, OPTION_KEYS);
+        if (options.chartStyle !== undefined)
+            options.style = options.chartStyle;
+        delete options.chartStyle;
+        // Same merge as the loader, so a live `prompts` patch keeps the prompts the handlers switched on.
+        const hostPrompts = { ...(props.prompts ?? {}), ...promptsForCallbacks(props) };
+        if (Object.keys(hostPrompts).length > 0)
+            options.prompts = hostPrompts;
+        else
+            delete options.prompts;
+        for (const key of PROMPT_CALLBACKS)
+            if (props[key] !== undefined)
+                options[key] = promptForwarders[key];
+        return { ...options, ...forwarders };
+    };
+    onMounted(() => {
+        if (container.value !== null)
+            binding.mount(container.value, config());
+    });
+    watch(config, (next) => binding.update(next), { deep: true });
+    onBeforeUnmount(() => binding.destroy());
+    expose(createSeatChartHandle(binding));
+    return () => h("div", { ref: container, "data-seatschart-chart": "" });
+}, { name: "SeatChart", props: [...OPTION_KEYS, ...PROMPT_CALLBACKS], emits: eventNames(CHART_CALLBACKS) });
+/** A typed template ref for `<SeatChart ref="chart">` (`const chart = useSeatChart()` in `<script setup>`). */
+export function useSeatChart() {
+    return shallowRef(null);
+}

package/dist/define.d.ts

@@ -0,0 +1,15 @@
+import { type EmbedConfig, type EventNameOf } from "./host-core.js";
+type Args<F> = F extends (...args: infer A) => unknown ? A : never;
+/** `{ onObjectSelected?: (e: E) => void }` → `{ objectSelected: (e: E) => true }` (typed Vue emits). */
+export type CallbackEmits<C, K extends keyof C & string> = {
+    [N in EventNameOf<K>]: (...args: Args<NonNullable<C[`on${Capitalize<N>}` & keyof C]>>) => true;
+};
+/** Vue event names of these callbacks (`onObjectSelected` → `objectSelected`). */
+export declare function eventNames(callbacks: readonly string[]): string[];
+type Emit = (event: string, ...args: unknown[]) => void;
+/** One stable function per callback that re-emits its arguments as the matching component event. */
+export declare function emitForwarders(callbacks: readonly string[], emit: Emit): EmbedConfig;
+/** Copy the option props that are set. */
+export declare function pickOptions(props: Readonly<Record<string, unknown>>, keys: readonly string[]): EmbedConfig;
+export {};
+//# sourceMappingURL=define.d.ts.map

package/dist/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../src/define.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE/E,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,OAAO,GAAG,CAAC,GAAG,KAAK,CAAC;AAEnE,wGAAwG;AACxG,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,IAAI;KACxD,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;CAC/F,CAAC;AAEF,kFAAkF;AAClF,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAEjE;AAED,KAAK,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;AAExD,oGAAoG;AACpG,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,WAAW,CAOpF;AAED,0CAA0C;AAC1C,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAO1G"}

package/dist/define.js

@@ -0,0 +1,24 @@
+import { eventName } from "./host-core.js";
+/** Vue event names of these callbacks (`onObjectSelected` → `objectSelected`). */
+export function eventNames(callbacks) {
+    return callbacks.map((key) => eventName(key));
+}
+/** One stable function per callback that re-emits its arguments as the matching component event. */
+export function emitForwarders(callbacks, emit) {
+    const out = {};
+    for (const key of callbacks) {
+        const name = eventName(key);
+        out[key] = (...args) => emit(name, ...args);
+    }
+    return out;
+}
+/** Copy the option props that are set. */
+export function pickOptions(props, keys) {
+    const out = {};
+    for (const key of keys) {
+        const value = props[key];
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}

package/dist/host-core.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Framework-agnostic glue between a component and one `@seatschart/embed` host instance (`SeatsChart`,
+ * `SeatsChartEventManager` or `SeatsChartDesigner`). This file is identical in `@seatschart/vue` and
+ * `@seatschart/angular` (a unit test keeps the two copies in step): the wrappers only map framework props, events
+ * and lifecycle onto it, every embed behaviour (iframe, origin checks, commands, sessions) stays in the embed.
+ *
+ * Prop updates are compared by value with what the instance last received, then applied the cheapest correct way:
+ * iframe attributes in place, live keys through `changeConfig` (no reload), other keys through `rerender(config)`
+ * (the hold session / the created chart is kept), mount-only keys by re-creating the instance.
+ */
+import { DESIGNER_CALLBACKS, EVENT_MANAGER_CALLBACKS, SeatsChart, SeatsChartDesigner, SeatsChartEventManager, type SeatsChartConfig, type SeatsChartDesignerConfig, type SeatsChartEventManagerConfig } from "@seatschart/embed";
+/** Every buyer chart option a component accepts as a prop / input (the host config keys first). */
+export declare const CHART_CONFIG_KEYS: readonly ["objectColor", "objectLabel", "tooltip", "priceFormatter", "numberOfPlacesToSelect", "maxSelectedObjects", "showSectionContents", "showMinimap", "showSurroundings", "sessionMode", "selectionValidators", "accessibilityFilter", "mode", "prompts", "objectWithoutPricingSelectable", "fitTo", "loading", "messages", "selectedObjects", "gestureHandling", "selectionModes", "showSeatLabels", "minimumSelectedPlaces", "sectionColor", "objectIcon", "isObjectVisible", "hideSectionsNotForSale", "selectableObjects", "objectWithoutCategorySelectable", "showSectionPricingOverlay", "showObjectPopover", "showFilterControls", "showLegend", "showZoomOutButton", "showFullScreenButton", "fullScreenTarget", "canGoBack", "resaleListings", "partySize", "style", "objectPopover", "legend", "filterControls", "activeFloor", "lockActiveFloor", "showFloorElevator", "settings3d", "webBase", "event", "events", "publicKey", "workspaceKey", "token", "parentOrigin", "channel", "channelKey", "channelKeys", "session", "season", "language", "multiSelectEnabled", "holdToken", "availableCategories", "unavailableCategories", "currency", "theme", "statusPalette", "transparent", "backgroundColor", "pricing", "defaultRenderer", "height", "title", "className", "allowFullscreen", "timeoutMs", "holdTokenInputName", "selectedObjectsInputName", "form"];
+export type ChartConfigKey = (typeof CHART_CONFIG_KEYS)[number];
+/** Chart callbacks (seats.io names) forwarded as component events. */
+export declare const CHART_CALLBACKS: readonly ["onObjectSelected", "onObjectDeselected", "onSessionHold", "onHoldSucceeded", "onHoldCallsInProgress", "onHoldCallsComplete", "onHoldConfirmed", "onReleaseHoldSucceeded", "onReleaseHoldFailed", "onSelectedObjectUnavailable", "onChartRerenderingStarted", "onPromptRequest", "onHoldTokenExpired", "onChartRendered", "onChartRenderingFailed", "onObjectClicked", "onObjectHovered", "onObjectUnhovered", "onHoldFailed", "onSelectionInvalid", "onSelectionValid", "onObjectStatusChanged", "onBestAvailableSelected", "onBestAvailableFailed", "onFilteredCategoriesChanged", "onAccessibilityFilterChanged", "onFiltersChanged", "onSessionInitialized", "onFloorChanged", "onFullScreenOpened", "onFullScreenClosed", "onFullScreenRequest", "onObjectMouseOver", "onObjectMouseOut", "onBestAvailableSelectionFailed", "onSelectedObjectBooked", "onHoldCreated"];
+export type ChartCallbackKey = (typeof CHART_CALLBACKS)[number];
+/** Host-drawn prompts: registering one switches the matching viewer prompt to the host. */
+export declare const PROMPT_CALLBACKS: readonly ["onPlacesPrompt", "onTicketTypePrompt", "onPlacesWithTicketTypesPrompt"];
+export type PromptCallbackKey = (typeof PROMPT_CALLBACKS)[number];
+export declare const EVENT_MANAGER_KEYS: readonly ["isObjectSelectable", "unavailableObjectsSelectable", "selectableObjects", "selectedObjects", "maxSelectedObjects", "order", "filters", "webBase", "event", "eventId", "token", "mode", "language", "colorScheme", "parentOrigin", "height", "title", "className", "timeoutMs"];
+export type EventManagerConfigKey = (typeof EVENT_MANAGER_KEYS)[number];
+export { EVENT_MANAGER_CALLBACKS };
+export type EventManagerCallbackKey = (typeof EVENT_MANAGER_CALLBACKS)[number];
+export declare const DESIGNER_KEYS: readonly ["webBase", "chartId", "chartKey", "token", "mode", "safeModeOptions", "features", "language", "colorScheme", "canvasColorScheme", "openDraftDrawing", "openLatestDrawing", "parentOrigin", "height", "title", "className", "timeoutMs"];
+export type DesignerConfigKey = (typeof DESIGNER_KEYS)[number];
+export { DESIGNER_CALLBACKS };
+export type DesignerCallbackKey = (typeof DESIGNER_CALLBACKS)[number];
+type Assert<T extends true> = T;
+type Covers<All, Listed> = [Exclude<All, Listed>] extends [never] ? true : false;
+/** Compile-time guard: a new embed option or callback must be mapped by the wrappers. */
+export type ConfigKeysCovered = [
+    Assert<Covers<keyof SeatsChartConfig, ChartConfigKey | ChartCallbackKey | PromptCallbackKey | "divId" | "container">>,
+    Assert<Covers<keyof SeatsChartEventManagerConfig, EventManagerConfigKey | EventManagerCallbackKey | "divId" | "container">>,
+    Assert<Covers<keyof SeatsChartDesignerConfig, DesignerConfigKey | DesignerCallbackKey | "divId" | "container">>
+];
+/** `"onObjectSelected"` → `"objectSelected"` (Vue event / Angular output name). */
+export type EventNameOf<K> = K extends `on${infer N}` ? Uncapitalize<N> : never;
+/** `onObjectSelected` → `objectSelected`. */
+export declare function eventName<K extends string>(callback: K): EventNameOf<K>;
+type PromiseMethods<T> = {
+    [K in keyof T]-?: T[K] extends (...args: never[]) => Promise<unknown> ? K : never;
+}[keyof T];
+/** Every promise command of `SeatsChart` (each waits for the chart to render; rejects with `ChartCommandError`). */
+export declare const CHART_COMMANDS: readonly ["whenReady", "request", "selectObjects", "deselectObjects", "clearSelection", "listSelectedObjects", "selectBestAvailable", "findObject", "listCategories", "setFilteredCategories", "clearFilteredCategories", "setFilters", "clearFilters", "highlightObjects", "clearHighlights", "zoomToObjects", "zoomToSelectedObjects", "zoomToSection", "zoomToFilteredCategories", "resetView", "goToFloor", "listFloors", "goToAllFloorsView", "getReportBySelectability", "getReportBySelectabilityGroupedBy", "getHoldToken", "startNewSession", "releaseHoldToken", "isObjectInChannel", "showViewFromSeat", "trySelectObjects", "doSelectObjects", "selectCategories", "deselectCategories", "listZones", "setSpotlight", "setSpotlightObjects", "setSpotlightOnSelection", "clearSpotlight", "clearSpotlightObjects", "pulse", "unpulse", "resolvePrompt", "exportImage", "setPricing", "changeConfig"];
+export type ChartCommands = Pick<SeatsChart, (typeof CHART_COMMANDS)[number]>;
+/** Every promise command of `SeatsChartEventManager` (seats.io `EventManager` methods). */
+export declare const EVENT_MANAGER_COMMANDS: readonly ["whenReady", "request", "listSelectedObjects", "selectObjects", "doSelectObjects", "trySelectObjects", "deselectObjects", "clearSelection", "setHighlightedObjects", "clearHighlightedObjects", "listOrderChanges", "zoomToObjects", "zoomToSelectedObjects", "changeConfig"];
+export type EventManagerCommands = Pick<SeatsChartEventManager, (typeof EVENT_MANAGER_COMMANDS)[number]>;
+/** Every promise command of `SeatsChartDesigner`. */
+export declare const DESIGNER_COMMANDS: readonly ["whenReady", "request", "save", "publish", "getState", "changeConfig"];
+export type DesignerCommands = Pick<SeatsChartDesigner, (typeof DESIGNER_COMMANDS)[number]>;
+/** Compile-time guard: a new embed command must be exposed by the wrappers. */
+export type CommandsCovered = [
+    Assert<Covers<PromiseMethods<SeatsChart>, (typeof CHART_COMMANDS)[number]>>,
+    Assert<Covers<PromiseMethods<SeatsChartEventManager>, (typeof EVENT_MANAGER_COMMANDS)[number]>>,
+    Assert<Covers<PromiseMethods<SeatsChartDesigner>, (typeof DESIGNER_COMMANDS)[number]>>
+];
+/**
+ * Methods that forward to the current instance (re-created instances included). Before mount and after unmount
+ * they reject with `ChartCommandError` ("… is not mounted.") instead of throwing.
+ */
+export declare function delegateCommands<I extends object, K extends keyof I & string>(current: () => I | null, names: readonly K[], label: string): Pick<I, K>;
+/** Run one promise command on the instance (rejects with `ChartCommandError` without one). */
+export declare function runCommand(instance: object | null, name: string, label: string, args: readonly unknown[]): Promise<unknown>;
+/**
+ * Order-independent fingerprint of a prop value: plain objects and arrays by value (reactive proxies included),
+ * functions as "a function", other objects (a form element) by identity. `undefined` = not set.
+ */
+export declare function valueKey(value: unknown): string | undefined;
+/**
+ * Deep copy of plain objects and arrays (reactive proxies become plain data the embed can post to the iframe);
+ * functions and other objects are kept as they are.
+ */
+export declare function toPlain<T>(value: T): T;
+/** What every embed host instance offers the binding. */
+export type EmbedInstance = {
+    render(): unknown;
+    destroy(): void;
+    getIframe(): HTMLIFrameElement | null;
+};
+export type EmbedConfig = Record<string, unknown>;
+export type EmbedKind<I extends EmbedInstance> = {
+    /** "Seat chart", "Event Manager", "Designer" (error messages). */
+    label: string;
+    create: (config: EmbedConfig & {
+        container: HTMLElement;
+    }) => I;
+    rerender: (instance: I, config: EmbedConfig) => void;
+    changeConfig: (instance: I, patch: EmbedConfig, config: EmbedConfig) => Promise<unknown>;
+    /** Keys applied live through `changeConfig`. */
+    liveKeys: ReadonlySet<string>;
+    /** Keys read when the instance is created (a change re-creates it). */
+    mountKeys: ReadonlySet<string>;
+    defaultHeight: number;
+    defaultTitle: string;
+};
+export type BindingAction = "none" | "frame" | "changeConfig" | "rerender" | "remount";
+/** One mounted embed instance driven by component props. */
+export declare class EmbedBinding<I extends EmbedInstance> {
+    private readonly kind;
+    private instance;
+    private container;
+    private config;
+    private applied;
+    constructor(kind: EmbedKind<I>);
+    /** The live embed instance (null before mount / after unmount). */
+    get current(): I | null;
+    get label(): string;
+    /** Create the instance in `container` and render it (browser only). */
+    mount(container: HTMLElement, config: EmbedConfig): void;
+    /** Apply new props; returns what was done (tests and diagnostics). */
+    update(next: EmbedConfig): BindingAction;
+    /** Re-create the iframe with the current props (seats.io `rerender()`). */
+    rerender(): void;
+    /** Remove the iframe and every listener. */
+    destroy(): void;
+    private remember;
+    private remount;
+    private applyFrame;
+}
+export declare const CHART_KIND: EmbedKind<SeatsChart>;
+export declare const EVENT_MANAGER_KIND: EmbedKind<SeatsChartEventManager>;
+export declare const DESIGNER_KIND: EmbedKind<SeatsChartDesigner>;
+//# sourceMappingURL=host-core.d.ts.map

package/dist/host-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-core.d.ts","sourceRoot":"","sources":["../src/host-core.ts"],"names":[],"mappings":"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"}

package/dist/host-core.js

@@ -0,0 +1,292 @@
+/**
+ * Framework-agnostic glue between a component and one `@seatschart/embed` host instance (`SeatsChart`,
+ * `SeatsChartEventManager` or `SeatsChartDesigner`). This file is identical in `@seatschart/vue` and
+ * `@seatschart/angular` (a unit test keeps the two copies in step): the wrappers only map framework props, events
+ * and lifecycle onto it, every embed behaviour (iframe, origin checks, commands, sessions) stays in the embed.
+ *
+ * Prop updates are compared by value with what the instance last received, then applied the cheapest correct way:
+ * iframe attributes in place, live keys through `changeConfig` (no reload), other keys through `rerender(config)`
+ * (the hold session / the created chart is kept), mount-only keys by re-creating the instance.
+ */
+import { CHART_EVENT_CALLBACKS, ChartCommandError, DESIGNER_CALLBACKS, DESIGNER_PATCH_KEYS, EVENT_MANAGER_CALLBACKS, EVENT_MANAGER_CONFIG_KEYS, HOST_CONFIG_KEYS, SeatsChart, SeatsChartDesigner, SeatsChartEventManager, } from "@seatschart/embed";
+// --- Prop / callback names ------------------------------------------------------------------------------------
+/** Loader options of the buyer chart that are not declarative host config keys. */
+const CHART_LOADER_KEYS = [
+    "webBase", "event", "events", "publicKey", "workspaceKey", "token", "parentOrigin", "channel", "channelKey",
+    "channelKeys", "session", "season", "language", "multiSelectEnabled", "holdToken", "availableCategories",
+    "unavailableCategories", "currency", "theme", "statusPalette", "transparent", "backgroundColor", "pricing",
+    "defaultRenderer", "height", "title", "className", "allowFullscreen", "timeoutMs", "holdTokenInputName",
+    "selectedObjectsInputName", "form",
+];
+/** Every buyer chart option a component accepts as a prop / input (the host config keys first). */
+export const CHART_CONFIG_KEYS = [...HOST_CONFIG_KEYS, ...CHART_LOADER_KEYS];
+/** Chart callbacks (seats.io names) forwarded as component events. */
+export const CHART_CALLBACKS = [...CHART_EVENT_CALLBACKS, "onHoldCreated"];
+/** Host-drawn prompts: registering one switches the matching viewer prompt to the host. */
+export const PROMPT_CALLBACKS = ["onPlacesPrompt", "onTicketTypePrompt", "onPlacesWithTicketTypesPrompt"];
+export const EVENT_MANAGER_KEYS = [
+    ...EVENT_MANAGER_CONFIG_KEYS, "webBase", "event", "eventId", "token", "mode", "language", "colorScheme",
+    "parentOrigin", "height", "title", "className", "timeoutMs",
+];
+export { EVENT_MANAGER_CALLBACKS };
+export const DESIGNER_KEYS = [
+    "webBase", "chartId", "chartKey", "token", "mode", "safeModeOptions", "features", "language", "colorScheme",
+    "canvasColorScheme", "openDraftDrawing", "openLatestDrawing", "parentOrigin", "height", "title", "className",
+    "timeoutMs",
+];
+export { DESIGNER_CALLBACKS };
+/** `onObjectSelected` → `objectSelected`. */
+export function eventName(callback) {
+    const name = callback.startsWith("on") ? callback.slice(2) : callback;
+    return (name.charAt(0).toLowerCase() + name.slice(1));
+}
+/** Every promise command of `SeatsChart` (each waits for the chart to render; rejects with `ChartCommandError`). */
+export const CHART_COMMANDS = [
+    "whenReady", "request", "selectObjects", "deselectObjects", "clearSelection", "listSelectedObjects",
+    "selectBestAvailable", "findObject", "listCategories", "setFilteredCategories", "clearFilteredCategories",
+    "setFilters", "clearFilters", "highlightObjects", "clearHighlights", "zoomToObjects", "zoomToSelectedObjects",
+    "zoomToSection", "zoomToFilteredCategories", "resetView", "goToFloor", "listFloors", "goToAllFloorsView",
+    "getReportBySelectability", "getReportBySelectabilityGroupedBy", "getHoldToken", "startNewSession",
+    "releaseHoldToken", "isObjectInChannel", "showViewFromSeat", "trySelectObjects", "doSelectObjects",
+    "selectCategories", "deselectCategories", "listZones", "setSpotlight", "setSpotlightObjects",
+    "setSpotlightOnSelection", "clearSpotlight", "clearSpotlightObjects", "pulse", "unpulse", "resolvePrompt",
+    "exportImage", "setPricing", "changeConfig",
+];
+/** Every promise command of `SeatsChartEventManager` (seats.io `EventManager` methods). */
+export const EVENT_MANAGER_COMMANDS = [
+    "whenReady", "request", "listSelectedObjects", "selectObjects", "doSelectObjects", "trySelectObjects",
+    "deselectObjects", "clearSelection", "setHighlightedObjects", "clearHighlightedObjects", "listOrderChanges",
+    "zoomToObjects", "zoomToSelectedObjects", "changeConfig",
+];
+/** Every promise command of `SeatsChartDesigner`. */
+export const DESIGNER_COMMANDS = [
+    "whenReady", "request", "save", "publish", "getState", "changeConfig",
+];
+/**
+ * Methods that forward to the current instance (re-created instances included). Before mount and after unmount
+ * they reject with `ChartCommandError` ("… is not mounted.") instead of throwing.
+ */
+export function delegateCommands(current, names, label) {
+    const out = {};
+    for (const name of names)
+        out[name] = (...args) => runCommand(current(), name, label, args);
+    return out;
+}
+/** Run one promise command on the instance (rejects with `ChartCommandError` without one). */
+export function runCommand(instance, name, label, args) {
+    if (instance === null)
+        return Promise.reject(new ChartCommandError(`${label} is not mounted.`, name));
+    const method = instance[name];
+    return method.apply(instance, [...args]);
+}
+// --- Value comparison -------------------------------------------------------------------------------------------
+function isPlainObject(value) {
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+const identities = new WeakMap();
+let lastIdentity = 0;
+/**
+ * Order-independent fingerprint of a prop value: plain objects and arrays by value (reactive proxies included),
+ * functions as "a function", other objects (a form element) by identity. `undefined` = not set.
+ */
+export function valueKey(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "function")
+        return "ƒ";
+    if (value === null || typeof value !== "object")
+        return typeof value === "string" ? JSON.stringify(value) : String(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => valueKey(item) ?? "u").join(",")}]`;
+    if (!isPlainObject(value)) {
+        let id = identities.get(value);
+        if (id === undefined) {
+            id = ++lastIdentity;
+            identities.set(value, id);
+        }
+        return `#${id}`;
+    }
+    const record = value;
+    const parts = [];
+    for (const key of Object.keys(record).sort()) {
+        const item = valueKey(record[key]);
+        if (item !== undefined)
+            parts.push(`${JSON.stringify(key)}:${item}`);
+    }
+    return `{${parts.join(",")}}`;
+}
+/**
+ * Deep copy of plain objects and arrays (reactive proxies become plain data the embed can post to the iframe);
+ * functions and other objects are kept as they are.
+ */
+export function toPlain(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => toPlain(item));
+    if (!isPlainObject(value))
+        return value;
+    const out = {};
+    for (const [key, item] of Object.entries(value))
+        out[key] = toPlain(item);
+    return out;
+}
+/** Iframe attributes updated in place (no reload). */
+const FRAME_KEYS = new Set(["height", "title", "className"]);
+/** One mounted embed instance driven by component props. */
+export class EmbedBinding {
+    constructor(kind) {
+        this.kind = kind;
+        this.instance = null;
+        this.container = null;
+        this.config = {};
+        this.applied = new Map();
+    }
+    /** The live embed instance (null before mount / after unmount). */
+    get current() {
+        return this.instance;
+    }
+    get label() {
+        return this.kind.label;
+    }
+    /** Create the instance in `container` and render it (browser only). */
+    mount(container, config) {
+        if (this.instance !== null)
+            return;
+        this.container = container;
+        this.remember(config);
+        const instance = this.kind.create({ ...this.config, container });
+        this.instance = instance;
+        instance.render();
+    }
+    /** Apply new props; returns what was done (tests and diagnostics). */
+    update(next) {
+        const previous = this.applied;
+        const before = this.config;
+        this.remember(next);
+        const instance = this.instance;
+        if (instance === null)
+            return "none";
+        const changed = [];
+        for (const key of new Set([...previous.keys(), ...this.applied.keys()])) {
+            if (previous.get(key) !== this.applied.get(key))
+                changed.push(key);
+        }
+        if (changed.length === 0)
+            return "none";
+        if (changed.some((key) => this.kind.mountKeys.has(key))) {
+            this.remount();
+            return "remount";
+        }
+        if (changed.some((key) => !this.kind.liveKeys.has(key) && !FRAME_KEYS.has(key))) {
+            // Keys that disappeared are passed as undefined so the instance forgets them.
+            const config = { ...this.config };
+            for (const key of Object.keys(before))
+                if (!(key in config))
+                    config[key] = undefined;
+            this.kind.rerender(instance, config);
+            return "rerender";
+        }
+        let action = "none";
+        if (changed.some((key) => FRAME_KEYS.has(key))) {
+            this.applyFrame(instance.getIframe());
+            action = "frame";
+        }
+        const patch = {};
+        for (const key of changed)
+            if (this.kind.liveKeys.has(key))
+                patch[key] = this.config[key] ?? null;
+        if (Object.keys(patch).length > 0) {
+            void this.kind.changeConfig(instance, patch, this.config).catch((error) => {
+                // A patch still waiting when the instance goes away is moot.
+                if (this.instance === instance)
+                    console.warn(`[SeatsChart] ${this.kind.label}: config not applied:`, error);
+            });
+            action = "changeConfig";
+        }
+        return action;
+    }
+    /** Re-create the iframe with the current props (seats.io `rerender()`). */
+    rerender() {
+        if (this.instance !== null)
+            this.kind.rerender(this.instance, { ...this.config });
+    }
+    /** Remove the iframe and every listener. */
+    destroy() {
+        this.instance?.destroy();
+        this.instance = null;
+        this.container = null;
+    }
+    remember(config) {
+        const plain = {};
+        const applied = new Map();
+        for (const [key, value] of Object.entries(config)) {
+            if (value === undefined)
+                continue;
+            plain[key] = toPlain(value);
+            const fingerprint = valueKey(value);
+            if (fingerprint !== undefined)
+                applied.set(key, fingerprint);
+        }
+        this.config = plain;
+        this.applied = applied;
+    }
+    remount() {
+        const container = this.container;
+        this.instance?.destroy();
+        this.instance = null;
+        if (container !== null)
+            this.mount(container, this.config);
+    }
+    applyFrame(iframe) {
+        if (iframe === null)
+            return;
+        const { height, title, className } = this.config;
+        const h = typeof height === "number" || typeof height === "string" ? height : this.kind.defaultHeight;
+        iframe.style.height = typeof h === "number" ? `${h}px` : h;
+        iframe.title = typeof title === "string" ? title : this.kind.defaultTitle;
+        iframe.className = typeof className === "string" ? className : "";
+    }
+}
+// --- The three embeds -------------------------------------------------------------------------------------------
+export const CHART_KIND = {
+    label: "Seat chart",
+    create: (config) => new SeatsChart(config),
+    rerender: (chart, config) => {
+        chart.rerender(config);
+    },
+    changeConfig: (chart, patch, config) => {
+        // Host pricing follows the chart's sales channel.
+        const withChannel = "pricing" in patch && typeof config.channel === "string" ? { ...patch, channel: config.channel } : patch;
+        return chart.changeConfig(withChannel);
+    },
+    liveKeys: new Set([...HOST_CONFIG_KEYS, "pricing"]),
+    mountKeys: new Set(["timeoutMs", "holdTokenInputName", "selectedObjectsInputName", "form"]),
+    defaultHeight: 640,
+    defaultTitle: "Seat map",
+};
+export const EVENT_MANAGER_KIND = {
+    label: "Event Manager",
+    create: (config) => new SeatsChartEventManager(config),
+    rerender: (manager, config) => {
+        manager.rerender(config);
+    },
+    changeConfig: (manager, patch) => manager.changeConfig(patch),
+    liveKeys: new Set([...EVENT_MANAGER_CONFIG_KEYS, "language", "colorScheme"]),
+    mountKeys: new Set(["timeoutMs"]),
+    defaultHeight: 760,
+    defaultTitle: "Event Manager",
+};
+export const DESIGNER_KIND = {
+    label: "Designer",
+    create: (config) => new SeatsChartDesigner(config),
+    rerender: (designer, config) => {
+        designer.rerender(config);
+    },
+    changeConfig: (designer, patch) => designer.changeConfig(patch),
+    liveKeys: new Set(DESIGNER_PATCH_KEYS),
+    mountKeys: new Set(["timeoutMs"]),
+    defaultHeight: 800,
+    defaultTitle: "Seating chart designer",
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { SeatChart, createSeatChartHandle, useSeatChart, type SeatChartCallbacks, type SeatChartHandle, type SeatChartOptions, type SeatChartEmits, type SeatChartProps, } from "./SeatChart.js";
+export { EventManager, createEventManagerHandle, useEventManager, type EventManagerHandle, type EventManagerProps, type EventManagerEmits, } from "./EventManager.js";
+export { Designer, createDesignerHandle, useDesigner, type DesignerHandle, type DesignerProps, type DesignerEmits, } from "./Designer.js";
+export { CHART_CALLBACKS, CHART_COMMANDS, CHART_CONFIG_KEYS, DESIGNER_COMMANDS, DESIGNER_KEYS, EVENT_MANAGER_COMMANDS, EVENT_MANAGER_KEYS, EmbedBinding, eventName, type BindingAction, type ChartCommands, type DesignerCommands, type EventManagerCommands, } from "./host-core.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,qBAAqB,EACrB,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,YAAY,EACZ,wBAAwB,EACxB,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,sBAAsB,EACtB,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,GAC1B,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { SeatChart, createSeatChartHandle, useSeatChart, } from "./SeatChart.js";
+export { EventManager, createEventManagerHandle, useEventManager, } from "./EventManager.js";
+export { Designer, createDesignerHandle, useDesigner, } from "./Designer.js";
+export { CHART_CALLBACKS, CHART_COMMANDS, CHART_CONFIG_KEYS, DESIGNER_COMMANDS, DESIGNER_KEYS, EVENT_MANAGER_COMMANDS, EVENT_MANAGER_KEYS, EmbedBinding, eventName, } from "./host-core.js";

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@seatschart/vue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Vue 3 components for SeatsChart seat maps: buyer chart, Event Manager and designer embeds",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seatschart/seatschart-prod.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "seatschart",
+    "seats",
+    "vue",
+    "nuxt",
+    "embed",
+    "ticketing"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test src",
+    "prepublishOnly": "bun run build"
+  },
+  "peerDependencies": {
+    "vue": ">=3.3.0"
+  },
+  "dependencies": {
+    "@seatschart/embed": "^0.6.0"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^21.0.4",
+    "happy-dom": "^21.0.4",
+    "typescript": "^7.0.2",
+    "vue": "^3.5.44"
+  },
+  "sideEffects": false
+}