platform-calendar-seatmap 2.0.0 → 2.0.2

package/dist/helpers/functions/seatMap.d.ts

@@ -0,0 +1,38 @@
+import { T_Seat, T_SeatMap } from 'platform-calendar-helpers';
+import { T_SelectedSeats } from "../../store/reducers/elementSelector/types";
+declare const removeFakeElementsFromSeatMap: (_seatMap: T_SeatMap) => {
+    elements: {
+        objects: import("platform-calendar-helpers").T_Element_Object[];
+        seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+        standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+        tables: import("platform-calendar-helpers").T_Element_Table[];
+        text: import("platform-calendar-helpers").T_Element_Text[];
+        aisles: any;
+    };
+    id: number;
+    name: string;
+    backgroundColor?: string;
+};
+declare const addFakeElementsToSeatMap: (_seatMap: T_SeatMap) => T_SeatMap;
+/**
+ * Sold seats are not mutated. Sold status is determined by the soldSeats list (UI/selectors).
+ * We do NOT set seat.locked for sold seats — being sold is separate from being locked.
+ * (Previously this set locked:true on sold seats, which then got copied on paste/duplicate.)
+ */
+declare const disableSoldSeats: (seatMap: T_SeatMap, _soldSeats: T_Seat[]) => T_SeatMap;
+declare const getElementInitialPosition: (sceneCoords: {
+    x: number;
+    y: number;
+}) => {
+    top: number;
+    left: number;
+};
+/**
+ * Check if an element has any sold seats
+ * @param elementId - The ID of the element to check
+ * @param elementType - The type of element ('tables' | 'seatingGroup')
+ * @param soldSeats - Array of sold seats from Redux state
+ * @returns true if the element has sold seats, false otherwise
+ */
+declare const hasSoldSeats: (elementId: string | number, elementType: "tables" | "seatingGroup", soldSeats: T_SelectedSeats[keyof T_SelectedSeats][]) => boolean;
+export { removeFakeElementsFromSeatMap, addFakeElementsToSeatMap, getElementInitialPosition, disableSoldSeats, hasSoldSeats };

package/dist/helpers/functions/seatSelectionUtils.d.ts

@@ -0,0 +1,33 @@
+export type T_SeatId = string;
+export type T_GridCoord = {
+    row: number;
+    col: number;
+};
+export type T_SeatLookup = (coord: T_GridCoord) => T_SeatId | undefined;
+export type T_IsSelectable = (seatId: T_SeatId) => boolean;
+/**
+ * Computes all selectable seats in the axis-aligned rectangle between anchor and current (inclusive).
+ * Only iterates within bounds; does not scan the full grid.
+ */
+export declare function getRectangleSeats(anchor: T_GridCoord, current: T_GridCoord, seatLookup: T_SeatLookup, isSelectable: T_IsSelectable): Set<T_SeatId>;
+/**
+ * Grid line algorithm (Bresenham) from anchor to current (inclusive).
+ * Missing seats (gaps/aisles) are skipped but the path is preserved.
+ */
+export declare function getLineSeatsBresenham(anchor: T_GridCoord, current: T_GridCoord, seatLookup: T_SeatLookup, isSelectable: T_IsSelectable): Set<T_SeatId>;
+/**
+ * Selects BOTH diagonals of the bounding box defined by anchor/current:
+ * - top-left -> bottom-right
+ * - top-right -> bottom-left
+ */
+export declare function getBothDiagonalsSeats(anchor: T_GridCoord, current: T_GridCoord, seatLookup: T_SeatLookup, isSelectable: T_IsSelectable): Set<T_SeatId>;
+export type T_SelectionApplyMode = 'replace' | 'add' | 'toggle';
+/**
+ * Applies a computed selection set onto an existing set.
+ *
+ * Modifier priority (documented & enforced by caller):
+ * - ctrl/meta => toggle (xor)
+ * - else shift => add
+ * - else => replace
+ */
+export declare function applySelectionWithModifier(existing: Set<T_SeatId>, computed: Set<T_SeatId>, mode: T_SelectionApplyMode): Set<T_SeatId>;

package/dist/helpers/functions/seatStatus.d.ts

@@ -0,0 +1,20 @@
+import { T_Seat } from 'platform-calendar-helpers';
+import { T_SeatColors } from "../constants/seatColors";
+export type { T_SeatColors } from "../constants/seatColors";
+export type T_SeatStatus = 'available' | 'locked' | 'unassigned' | 'sold';
+/**
+ * Determines the status of a seat based on its locked state, whether it's sold, and if it has a ticket assigned
+ */
+export declare const getSeatStatus: (seat: T_Seat, soldSeatIds: Set<string | number>, ticketIds?: {
+    [key: string | number]: boolean;
+}) => T_SeatStatus;
+/**
+ * Gets the appropriate color for a seat based on its status
+ */
+export declare const getSeatColor: (seat: T_Seat, seatColors: T_SeatColors, soldSeatIds: Set<string | number>, ticketIds?: {
+    [key: string | number]: boolean;
+}) => string;
+/**
+ * Gets seat colors with fallback to defaults if missing
+ */
+export declare const getSeatColorsWithDefaults: (seatColors?: Partial<T_SeatColors> | null) => T_SeatColors;

package/dist/helpers/functions/seatingGroup.d.ts

@@ -0,0 +1,4 @@
+import { T_Element } from 'platform-calendar-helpers';
+declare const updateCurve: (elementId: T_Element["id"], curveValue: number) => void;
+declare const updateStretch: (elementId: T_Element["id"], stretchValue: number) => void;
+export { updateCurve, updateStretch };

package/dist/helpers/functions/statistics.d.ts

@@ -0,0 +1,116 @@
+import { T_Element, T_ElementType, T_Seat, T_SeatMap, T_Ticket } from 'platform-calendar-helpers';
+import { T_SelectedSeats } from "../../store/reducers/elementSelector/types";
+/**
+ * Count total seats in the seatmap
+ */
+export declare const getTotalCapacity: (seatMap: T_SeatMap) => number;
+/**
+ * Count total seats including hidden ones (for capacity calculation)
+ * Note: StandingArea capacity is determined by ticket limit, not by seats
+ */
+export declare const getTotalCapacityIncludingHidden: (seatMap: T_SeatMap) => number;
+/**
+ * Calculate occupancy percentage
+ * If there are sold seats but percentage rounds to 0, show at least 1%
+ */
+export declare const getOccupancyPercentage: (sold: number, total: number) => number;
+/**
+ * Seat index structure for efficient lookups
+ */
+export type T_SeatIndex = {
+    bySeatId: Map<T_Seat['id'], {
+        seat: T_Seat;
+        elementId: T_Element['id'];
+        elementTitle: T_Element['title'];
+        elementType: T_ElementType;
+    }>;
+    byElementId: Map<T_Element['id'], {
+        elementTitle: T_Element['title'];
+        elementType: T_ElementType;
+        seats: T_Seat[];
+    }>;
+    totalsByElement: Map<T_Element['id'], {
+        total: number;
+        sold: number;
+    }>;
+    totalsByTicketId: Map<T_Ticket['id'], {
+        total: number;
+        sold: number;
+    }>;
+};
+/**
+ * Build a seat index from the seatmap for efficient lookups
+ */
+export declare const buildSeatIndex: (seatMap: T_SeatMap, tickets?: T_Ticket[]) => T_SeatIndex;
+/**
+ * Audit findings for sold seats
+ */
+export type T_AuditFindings = {
+    orphanSeats: Array<{
+        seatId: T_Seat['id'];
+        elementId?: T_Element['id'];
+        elementTitle?: string;
+    }>;
+    duplicateSeats: Array<{
+        seatId: T_Seat['id'];
+        count: number;
+    }>;
+    ticketMismatches: Array<{
+        seatId: T_Seat['id'];
+        ticketId: T_Ticket['id'];
+        elementTitle?: string;
+    }>;
+    hiddenSoldSeats: Array<{
+        seatId: T_Seat['id'];
+        elementTitle?: string;
+    }>;
+};
+/**
+ * Analyze sold seats against the seatmap index
+ */
+export declare const analyzeSoldSeats: (seatIndex: T_SeatIndex, soldSeats: T_SelectedSeats[keyof T_SelectedSeats][], tickets?: T_Ticket[]) => T_AuditFindings;
+/**
+ * Get occupancy breakdown by element
+ */
+export type T_ElementOccupancy = {
+    elementId: T_Element['id'];
+    elementTitle: T_Element['title'];
+    elementType: T_ElementType;
+    total: number;
+    sold: number;
+    available: number;
+    occupancyPercentage: number;
+};
+export declare const getOccupancyByElement: (seatIndex: T_SeatIndex, seatMap?: T_SeatMap, tickets?: T_Ticket[], filteredSoldSeats?: T_SelectedSeats[keyof T_SelectedSeats][]) => T_ElementOccupancy[];
+/**
+ * Get occupancy breakdown by ticket type
+ */
+export type T_TicketOccupancy = {
+    ticketId: T_Ticket['id'];
+    ticketName?: string;
+    total: number;
+    sold: number;
+    available: number;
+    occupancyPercentage: number;
+};
+export declare const getOccupancyByTicket: (seatIndex: T_SeatIndex, tickets?: T_Ticket[], filteredSoldSeats?: T_SelectedSeats[keyof T_SelectedSeats][]) => T_TicketOccupancy[];
+/**
+ * Type for statistics
+ */
+export type T_Statistics = {
+    totalCapacity: number;
+    soldCount: number;
+    availableCount: number;
+    unassignedCount: number;
+    lockedCount: number;
+    hiddenCount: number;
+    occupancyPercentage: number;
+};
+/**
+ * Calculate detailed seat statistics (unassigned, locked, hidden counts)
+ */
+export declare const calculateDetailedStatistics: (seatMap: T_SeatMap, soldSeats: T_SelectedSeats[keyof T_SelectedSeats][], tickets?: T_Ticket[]) => {
+    unassignedCount: number;
+    lockedCount: number;
+    hiddenCount: number;
+};

package/dist/helpers/functions/zoomToFit.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Calculates the optimal scale and translation to fit all elements in the viewport
+ * @param elements - Array of element positions and dimensions
+ * @param viewportWidth - Width of the viewport
+ * @param viewportHeight - Height of the viewport
+ * @param padding - Padding around elements (in pixels)
+ * @param minScale - Minimum allowed scale
+ * @param maxScale - Maximum allowed scale
+ * @returns Object with scale, translateX, and translateY
+ */
+export declare const calculateZoomToFit: (elements: Array<{
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}>, viewportWidth: number, viewportHeight: number, padding?: number, minScale?: number, maxScale?: number) => {
+    scale: number;
+    translateX: number;
+    translateY: number;
+};

package/dist/helpers/types/aisle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * LOCAL AISLE TYPES
+ * These are defined locally until platform-calendar-helpers is updated
+ */
+export type T_AisleStyle = 'solid' | 'dashed' | 'dotted' | 'carpet' | 'arrows';
+export type T_Element_Aisle = {
+    id: string;
+    title: string;
+    position: {
+        top: number;
+        left: number;
+    };
+    width: number;
+    height: number;
+    rotate: number;
+    zIndex: number;
+    style: T_AisleStyle;
+    color: string;
+    opacity: number;
+    showLabel: boolean;
+    showArrows: boolean;
+    isEmergencyExit: boolean;
+};
+export declare const AISLE_ELEMENT_TYPE: "aisles";
+export declare const D_ELEMENT_AISLE: T_Element_Aisle;

package/dist/helpers/types/commons.d.ts

@@ -0,0 +1,10 @@
+import { MODES } from "../constants/commons";
+type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+type T_Mode = (typeof MODES)[keyof typeof MODES];
+type T_SceneTransform = React.MutableRefObject<{
+    x: number;
+    y: number;
+}>;
+export { type RecursivePartial, type T_Mode, type T_SceneTransform };

package/dist/hooks/useCopyPaste.d.ts

@@ -0,0 +1 @@
+export declare const useCopyPaste: () => void;

package/dist/hooks/useElementWrapperActionHandlers.d.ts

@@ -0,0 +1,21 @@
+import { T_Element, T_ElementType } from 'platform-calendar-helpers';
+import { T_Element_Aisle } from "../helpers/types/aisle";
+/** Element type union: helpers + local aisle */
+type T_ElementType_SeatMap = T_ElementType | 'aisles';
+type T_Props = {
+    element: T_Element | T_Element_Aisle;
+    elementType: T_ElementType_SeatMap;
+};
+declare const useElementWrapperActionHandlers: ({ element, elementType }: T_Props) => {
+    deleteElement: () => void;
+    editElement: () => void;
+    duplicateElement: () => void;
+    resize: (updatedSizes: {
+        top: number;
+        left: number;
+        height: number;
+        width: number;
+    }) => void;
+    rotate: (updatedAngle: T_Element["rotate"]) => void;
+};
+export { useElementWrapperActionHandlers };

package/dist/hooks/useIsViewOnly.d.ts

@@ -0,0 +1,2 @@
+declare const useIsViewOnly: () => boolean;
+export { useIsViewOnly };

package/dist/hooks/useKeyboardSeatNavigation.d.ts

@@ -0,0 +1,22 @@
+/**
+ * KEYBOARD SEAT NAVIGATION
+ * Navigate seats using arrow keys, Enter to select
+ */
+import { T_Seat } from 'platform-calendar-helpers';
+export declare const useKeyboardSeatNavigation: (enabled?: boolean) => {
+    focusedSeat: {
+        seatId: T_Seat["id"];
+        elementId: string;
+        elementType: "seatingGroup" | "tables";
+        rowIndex: number;
+        colIndex: number;
+    };
+    setFocusedSeat: import("react").Dispatch<import("react").SetStateAction<{
+        seatId: T_Seat["id"];
+        elementId: string;
+        elementType: "seatingGroup" | "tables";
+        rowIndex: number;
+        colIndex: number;
+    }>>;
+    clearFocus: () => void;
+};

package/dist/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1 @@
+export declare const useKeyboardShortcuts: () => void;

package/dist/hooks/useScaleTracker.d.ts

@@ -0,0 +1,2 @@
+declare const useScaleTracker: (wrapperRef: React.MutableRefObject<HTMLDivElement>) => number;
+export { useScaleTracker };

package/dist/hooks/useSmoothZoom.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SMOOTH ZOOM HOOK
+ * Animated zoom to selection, zoom to fit, etc.
+ */
+import { T_Seat } from 'platform-calendar-helpers';
+type T_ZoomTarget = {
+    scale: number;
+    x: number;
+    y: number;
+};
+export declare const useSmoothZoom: (sceneRef: React.RefObject<HTMLDivElement>, wrapperRef: React.RefObject<HTMLDivElement>) => {
+    zoomToSelection: (padding?: number) => void;
+    zoomToSeat: (seatId: T_Seat["id"], targetScale?: number) => void;
+    zoomToElement: (elementId: string, padding?: number) => void;
+    animateTo: (target: T_ZoomTarget, duration?: number) => void;
+    cleanup: () => void;
+};
+export {};

package/dist/hooks/useUndoRedo.d.ts

@@ -0,0 +1,4 @@
+export declare const useUndoRedo: () => {
+    canUndo: boolean;
+    canRedo: boolean;
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { App as SeatMap } from './components/app/App';
+export { useResetOnboarding } from './components/onboarding/Onboarding';

package/dist/index.html

@@ -0,0 +1 @@
+<!doctype html><html><head><meta charset="utf-8"><title>Webpack App</title><meta name="viewport" content="width=device-width,initial-scale=1"><script defer="defer" src="./index.js"></script></head><body></body></html>