@alisaitteke/seatmap-canvas 2.3.0 → 2.4.1

package/dist/esm/types/svg/stage/search-circle/circle.d.ts

@@ -0,0 +1,7 @@
+import SvgBase from "../../svg.base";
+import BlocksSearchCircle from "../blocks.search-circle";
+export default class Circle extends SvgBase {
+    parent: BlocksSearchCircle;
+    constructor(parent: BlocksSearchCircle);
+    update(): this;
+}

package/dist/esm/types/svg/stage/stage.index.d.ts

@@ -0,0 +1,11 @@
+import Blocks from "./blocks/blocks.index";
+import Svg from "../svg.index";
+import SvgBase from "../svg.base";
+import BlocksSearchCircle from "./blocks.search-circle";
+export default class Stage extends SvgBase {
+    parent: Svg;
+    blocks: Blocks;
+    searchCircle: BlocksSearchCircle;
+    constructor(parent: Svg);
+    update(): void;
+}

package/dist/esm/types/svg/svg.base.d.ts

@@ -0,0 +1,35 @@
+import { GlobalModel } from "../models/global.model";
+export default class SvgBase {
+    parent: any;
+    node: any | null;
+    domClass: string | null;
+    domTag: string | null;
+    eventCode: string | null;
+    autoGenerate: boolean;
+    tags: Array<string>;
+    child_items: Array<any> | any;
+    dom_attrs: Array<any>;
+    dom_classes: Array<any>;
+    child_index: number | null;
+    domText: string | null;
+    global: GlobalModel;
+    constructor(parent: any);
+    generateThisDom(): this;
+    domGenerate(to: any, index?: number): this;
+    attr(name: string, value: string | number): this;
+    text(value: string): this;
+    addChild(item: any, attrs?: any, replace?: boolean): this;
+    classed(className: string, value?: boolean): this;
+    clear(): this;
+    updateChilds(): this;
+    updateEvents(recursive?: boolean): this;
+    addEventListener(eventType: string, cb: any): this;
+    addTag(tag: string): this;
+    hasTag(tag: string): boolean;
+    getChilds(type?: string | null): Array<any>;
+    getChildCount(): number;
+    beforeGenerate(): void;
+    afterGenerate(): void;
+    addToParent(): this;
+    addTo(container: any): this;
+}

package/dist/esm/types/svg/svg.index.d.ts

@@ -0,0 +1,16 @@
+import Stage from "./stage/stage.index";
+import "reflect-metadata";
+import { SeatMapCanvas } from "../canvas.index";
+import SvgBase from "./svg.base";
+import ZoomOutBg from "./zoom-out.bg";
+import Legend from "./legend";
+import Tooltip from "./tooltip";
+export default class Svg extends SvgBase {
+    parent: SeatMapCanvas;
+    stage: Stage;
+    zoomOutBg: ZoomOutBg;
+    legend: Legend;
+    tooltip: Tooltip;
+    constructor(parent: SeatMapCanvas);
+    update(): void;
+}

package/dist/esm/types/svg/tooltip/rect.d.ts

@@ -0,0 +1,8 @@
+import SvgBase from "../svg.base";
+import Tooltip from "../tooltip";
+export default class TooltipRect extends SvgBase {
+    parent: Tooltip;
+    constructor(parent: Tooltip);
+    update(): this;
+    afterGenerate(): void;
+}

package/dist/esm/types/svg/tooltip/title.d.ts

@@ -0,0 +1,10 @@
+import SvgBase from "../svg.base";
+import Tooltip from "../tooltip";
+export default class TooltipTitle extends SvgBase {
+    parent: Tooltip;
+    title: Array<string>;
+    constructor(parent: Tooltip);
+    update(): this;
+    afterGenerate(): void;
+    generateTitle(): void;
+}

package/dist/esm/types/svg/tooltip.d.ts

@@ -0,0 +1,15 @@
+import SvgBase from "./svg.base";
+import TooltipRect from "./tooltip/rect";
+import Svg from "./svg.index";
+import { SeatItem } from "./stage/blocks/block-item/seat/seat-item.index";
+import TooltipTitle from "./tooltip/title";
+export default class Tooltip extends SvgBase {
+    parent: Svg;
+    rect: TooltipRect;
+    title: TooltipTitle;
+    activeSeat: SeatItem | null;
+    constructor(parent: Svg);
+    setTitle(title: Array<string>): this;
+    update(): this;
+    afterGenerate(): void;
+}

package/dist/esm/types/svg/zoom-out.bg.d.ts

@@ -0,0 +1,7 @@
+import SvgBase from "./svg.base";
+import Svg from "./svg.index";
+export default class ZoomOutBg extends SvgBase {
+    parent: Svg;
+    constructor(parent: Svg);
+    update(): void;
+}

package/dist/esm/types/svg/zoom.manager.d.ts

@@ -0,0 +1,41 @@
+import { SeatMapCanvas } from "../canvas.index";
+import { ZoomLevel } from "../enums/global";
+import BlockModel from "../models/block.model";
+export interface ZoomLevelObject {
+    level: string;
+    values: {
+        x: number;
+        y: number;
+        k: number;
+    };
+}
+export default class ZoomManager {
+    private _self;
+    zoomTypes: any;
+    scale: any;
+    private zoomLevels;
+    activeBlocks: Array<any>;
+    minZoom: number | null;
+    zoomLevel: ZoomLevel;
+    constructor(_self: SeatMapCanvas);
+    init(): void;
+    zoomInit(): void;
+    zoomEnd(_self: this): any;
+    animatedZoomEnd(_self: this): any;
+    animatedFastZoomEnd(_self: this): any;
+    zoomHand(_self: this): any;
+    zoomHandAnimated(_self: this): any;
+    zoomHandFastAnimated(_self: this): any;
+    calculateZoomLevel(k: number): void;
+    canvasScopeHandler(): void;
+    calculateZoomLevels(blocks?: Array<BlockModel>): this;
+    calculateActiveBlocks(blocks?: Array<BlockModel>): Array<BlockModel>;
+    zoomToSelection(animation?: boolean): void;
+    zoomToBlock(id: string | number, animation?: boolean, fastAnimated?: boolean): void;
+    zoomToVenue(animation?: boolean, fastAnimated?: boolean): void;
+    zoomEnable(): this;
+    zoomDisable(): this;
+    getZoomLevelValues(level: ZoomLevel): any;
+    getActiveZoom(): any;
+    private dispatchZoomEvent;
+}

package/dist/esm/types/window.manager.d.ts

@@ -0,0 +1,9 @@
+import { SeatMapCanvas } from "./canvas.index";
+export default class WindowManager {
+    parent: SeatMapCanvas;
+    width: number | null;
+    height: number | null;
+    stage: any;
+    constructor(parent: SeatMapCanvas);
+    resizeHandler(): this;
+}

package/dist/types.d.ts

@@ -0,0 +1,533 @@
+declare class SeatStyle {
+    radius: number;
+    color: string;
+    not_salable: string;
+    selected: string;
+    hover: string;
+    focus: string;
+    focus_out: string;
+    check_color: string;
+    check_icon: string;
+    check_icon_color: string;
+}
+
+declare class BLockStyle {
+    fill: string;
+    stroke: string;
+    border_width: number;
+    title_color: string;
+    title_font_size: number;
+}
+
+declare class LegendStyle {
+    radius: number;
+    padding: number;
+    font_size: number;
+    font_color: string;
+}
+
+declare class LabelStyle {
+    color: string;
+    bg: string;
+    font_size: number;
+    radius: number;
+}
+
+declare class TooltipStyle {
+    border_width: number;
+    width: number;
+    height: number;
+    color: string;
+    bg: string;
+}
+
+declare class StyleConfig {
+    seat: SeatStyle;
+    block: BLockStyle;
+    legend: LegendStyle;
+    label: LabelStyle;
+    tooltip: TooltipStyle;
+}
+declare class DefaultsModel {
+    min_zoom: number;
+    max_zoom: number;
+    animation_speed: number;
+    resizable: boolean;
+    container: any;
+    zoom_focus_circle_radius: number;
+    click_enable_sold_seats: boolean;
+    zoom_out_button: string;
+    legend: boolean;
+    canvas_stageout_control: boolean;
+    style: StyleConfig;
+    lang: {
+        selectable: string;
+        non_selectable: string;
+        your_selection: string;
+    };
+    constructor(config: any);
+    getAll(): this;
+}
+
+declare class ModelBase {
+    child_index: number | null;
+    item_type: string | null;
+    constructor();
+}
+
+declare class Seats extends SvgBase {
+    parent: Block;
+    item: BlockModel;
+    constructor(parent: Block, item: BlockModel);
+    update(): this;
+    getSeat(id: any): SeatItem;
+    getSeats(): Array<SeatItem>;
+    getSeatsCount(): number;
+    getSeatByIndex(index: number): SeatItem;
+    resetSeatsColors(animation?: boolean): void;
+}
+
+declare class SeatItemCircle extends SvgBase {
+    parent: SeatItem;
+    constructor(parent: SeatItem);
+    update(): this;
+}
+
+declare class CoordinateModel {
+    private x;
+    private y;
+    constructor(item?: any);
+    toArray(): number[];
+    toJson(): {};
+}
+
+declare class SeatItemTitle extends SvgBase {
+    parent: SeatItem;
+    constructor(parent: SeatItem);
+    update(): this;
+}
+
+declare enum ZoomLevel {
+    VENUE = "VENUE",
+    BLOCK = "BLOCK",
+    SEAT = "SEAT"
+}
+declare enum SeatAction {
+    HOVER = "hover",
+    FOCUS = "focus",
+    LEAVE = "leave",
+    SELECT = "select",
+    NORMAL = "normal"
+}
+
+declare class SeatItemCheck extends SvgBase {
+    parent: SeatItem;
+    constructor(parent: SeatItem);
+    update(): this;
+    afterGenerate(): void;
+    show(): this;
+    hide(): this;
+}
+
+declare class SeatItem extends SvgBase {
+    parent: Seats;
+    item: SeatModel;
+    circle: SeatItemCircle;
+    title: SeatItemTitle;
+    coordinates: CoordinateModel;
+    check: SeatItemCheck;
+    constructor(parent: Seats, item: SeatModel);
+    setColor(color: string, animation?: boolean): this;
+    updateColor(color?: string | null): this;
+    select(color?: string | null): this;
+    unSelect(): this;
+    isSelected(): Boolean;
+    isSalable(): Boolean;
+    hover(): void;
+    blur(): void;
+    getColor(action?: SeatAction | null): string;
+    update(): this;
+    afterGenerate(): void;
+}
+
+declare class SeatModel extends ModelBase {
+    id: any;
+    x: number;
+    y: number;
+    title?: string;
+    selected: boolean;
+    color: string;
+    block: BlockModel;
+    salable: boolean;
+    note?: string;
+    tags: Array<string>;
+    tag_index: any;
+    custom_data?: any;
+    svg: SeatItem | null;
+    icon?: string | null;
+    constructor(item: any);
+    selectedToggle(): boolean;
+    addTag(tag: string): void;
+    removeTags(tag: string): void;
+    toJson(): {
+        id: any;
+        x: number;
+        y: number;
+        salable: boolean;
+        note: string | undefined;
+        color: string;
+        block: {
+            id: string;
+            title: String;
+            x: number;
+            y: number;
+            color: string;
+            width: number;
+            height: number;
+        };
+    };
+}
+
+declare class LabelModel extends ModelBase {
+    x: number;
+    y: number;
+    title: string;
+    block: BlockModel;
+    constructor(item: any);
+}
+
+declare class BlockModel extends ModelBase {
+    id: string;
+    seats: Array<SeatModel>;
+    labels: Array<LabelModel>;
+    title: String;
+    bounds: any;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    color: string;
+    border_color: string;
+    bbox: any;
+    zoom_bbox: any;
+    rotate: number;
+    constructor(item: any);
+    toJson(): {
+        id: string;
+        title: String;
+        x: number;
+        y: number;
+        color: string;
+        width: number;
+        height: number;
+    };
+}
+
+interface BlockQuery {
+    id?: number | string;
+}
+declare class DataModel {
+    private _self;
+    blocks: Array<BlockModel>;
+    private eventManager;
+    addEventListener: any;
+    constructor(_self: SeatMapCanvas);
+    addBlock(block_data: any): this;
+    addBulkBlock(block_data: Array<BlockModel>): this;
+    replaceData(block_data: Array<any>): this;
+    getBlock(id: string | number): BlockModel | null;
+    getBlocks(blockId?: string): Array<BlockModel>;
+    removeBlock(id: string | number): this;
+    getSeat(seatId: string | number, blockId: string | number): SeatModel | null;
+    getSelectedSeats(blockId?: string): Array<SeatModel>;
+    filterBlock(query: BlockQuery): Array<BlockModel>;
+    toJson(): {
+        blocks: BlockModel[];
+    };
+}
+
+declare class ZoomManager {
+    private _self;
+    zoomTypes: any;
+    scale: any;
+    private zoomLevels;
+    activeBlocks: Array<any>;
+    minZoom: number | null;
+    zoomLevel: ZoomLevel;
+    constructor(_self: SeatMapCanvas);
+    init(): void;
+    zoomInit(): void;
+    zoomEnd(_self: this): any;
+    animatedZoomEnd(_self: this): any;
+    animatedFastZoomEnd(_self: this): any;
+    zoomHand(_self: this): any;
+    zoomHandAnimated(_self: this): any;
+    zoomHandFastAnimated(_self: this): any;
+    calculateZoomLevel(k: number): void;
+    canvasScopeHandler(): void;
+    calculateZoomLevels(blocks?: Array<BlockModel>): this;
+    calculateActiveBlocks(blocks?: Array<BlockModel>): Array<BlockModel>;
+    zoomToSelection(animation?: boolean): void;
+    zoomToBlock(id: string | number, animation?: boolean, fastAnimated?: boolean): void;
+    zoomToVenue(animation?: boolean, fastAnimated?: boolean): void;
+    zoomEnable(): this;
+    zoomDisable(): this;
+    getZoomLevelValues(level: ZoomLevel): any;
+    getActiveZoom(): any;
+    private dispatchZoomEvent;
+}
+
+interface EventObject {
+    type: string;
+    fn: any;
+}
+declare class EventManager {
+    private _self;
+    events: Array<EventObject>;
+    constructor(_self: SeatMapCanvas);
+    addEventListener(type: string | any, fn: any): this;
+    dispatch(type: string, data: any): this;
+}
+
+declare class WindowManager {
+    parent: SeatMapCanvas;
+    width: number | null;
+    height: number | null;
+    stage: any;
+    constructor(parent: SeatMapCanvas);
+    resizeHandler(): this;
+}
+
+interface GlobalModel {
+    config: DefaultsModel;
+    eventManager: EventManager;
+    windowManager: WindowManager;
+    data: DataModel;
+    root: SeatMapCanvas;
+    zoomManager: ZoomManager;
+    svg: Svg;
+    multi_select: boolean;
+    best_available: boolean;
+}
+
+declare class SvgBase {
+    parent: any;
+    node: any | null;
+    domClass: string | null;
+    domTag: string | null;
+    eventCode: string | null;
+    autoGenerate: boolean;
+    tags: Array<string>;
+    child_items: Array<any> | any;
+    dom_attrs: Array<any>;
+    dom_classes: Array<any>;
+    child_index: number | null;
+    domText: string | null;
+    global: GlobalModel;
+    constructor(parent: any);
+    generateThisDom(): this;
+    domGenerate(to: any, index?: number): this;
+    attr(name: string, value: string | number): this;
+    text(value: string): this;
+    addChild(item: any, attrs?: any, replace?: boolean): this;
+    classed(className: string, value?: boolean): this;
+    clear(): this;
+    updateChilds(): this;
+    updateEvents(recursive?: boolean): this;
+    addEventListener(eventType: string, cb: any): this;
+    addTag(tag: string): this;
+    hasTag(tag: string): boolean;
+    getChilds(type?: string | null): Array<any>;
+    getChildCount(): number;
+    beforeGenerate(): void;
+    afterGenerate(): void;
+    addToParent(): this;
+    addTo(container: any): this;
+}
+
+declare class BlockTitle extends SvgBase {
+    parent: BlockInfo;
+    constructor(parent: BlockInfo);
+    update(): this;
+}
+
+declare class BlockInfo extends SvgBase {
+    parent: Block;
+    item: BlockModel;
+    title: BlockTitle;
+    constructor(parent: Block, item: BlockModel);
+    update(): this;
+}
+
+declare class BlockMask extends SvgBase {
+    parent: Block;
+    item: BlockModel;
+    blockLevelMask: BoundItem;
+    seatLevelMask: BoundItem;
+    constructor(parent: Block, item: BlockModel);
+    update(): this;
+}
+
+declare class BoundItem extends SvgBase {
+    parent: BlockBounds | BlockMask;
+    item: BlockModel;
+    constructor(parent: BlockBounds | BlockMask, item: BlockModel);
+    show(): void;
+    hide(): void;
+    update(): this;
+}
+
+declare class BlockBounds extends SvgBase {
+    parent: Block;
+    item: BlockModel;
+    bound1: BoundItem;
+    bound2: BoundItem;
+    constructor(parent: Block, item: BlockModel);
+    update(): this;
+}
+
+declare class LabelItemCircle extends SvgBase {
+    parent: LabelItem;
+    constructor(parent: LabelItem);
+    update(): this;
+}
+
+declare class LabelItem extends SvgBase {
+    parent: Labels;
+    item: LabelModel;
+    circle: LabelItemCircle;
+    coordinates: CoordinateModel;
+    constructor(parent: Labels, item: LabelModel);
+    update(): this;
+}
+
+declare class Labels extends SvgBase {
+    parent: Block;
+    item: BlockModel;
+    constructor(parent: Block, item: BlockModel);
+    update(): this;
+    getLabels(): Array<LabelItem>;
+}
+
+declare class Block extends SvgBase {
+    parent: Blocks;
+    item: BlockModel;
+    seats: Seats;
+    labels: Labels;
+    info: BlockInfo;
+    mask: BlockMask;
+    bounds: BlockBounds;
+    center_position: any;
+    top_position: any;
+    constructor(parent: Blocks, item: BlockModel);
+    update(): this;
+    infosToTop(): void;
+    infosToCenter(): void;
+}
+
+declare class Blocks extends SvgBase {
+    parent: Stage;
+    seats: Array<SeatItem>;
+    constructor(parent: Stage);
+    update(): this;
+    getBlock(id: any): Block | null;
+    getBlocks(): Array<Block>;
+    center(): void;
+}
+
+declare class Circle extends SvgBase {
+    parent: BlocksSearchCircle;
+    constructor(parent: BlocksSearchCircle);
+    update(): this;
+}
+
+declare class BlocksSearchCircle extends SvgBase {
+    parent: Stage;
+    circle: Circle;
+    is_enable: boolean;
+    constructor(parent: Stage);
+    update(): this;
+    enable(): this;
+    disable(): this;
+}
+
+declare class Stage extends SvgBase {
+    parent: Svg;
+    blocks: Blocks;
+    searchCircle: BlocksSearchCircle;
+    constructor(parent: Svg);
+    update(): void;
+}
+
+declare class ZoomOutBg extends SvgBase {
+    parent: Svg;
+    constructor(parent: Svg);
+    update(): void;
+}
+
+declare class Legend extends SvgBase {
+    parent: Svg;
+    constructor(parent: Svg);
+    update(): void;
+    afterGenerate(): void;
+}
+
+declare class TooltipRect extends SvgBase {
+    parent: Tooltip;
+    constructor(parent: Tooltip);
+    update(): this;
+    afterGenerate(): void;
+}
+
+declare class TooltipTitle extends SvgBase {
+    parent: Tooltip;
+    title: Array<string>;
+    constructor(parent: Tooltip);
+    update(): this;
+    afterGenerate(): void;
+    generateTitle(): void;
+}
+
+declare class Tooltip extends SvgBase {
+    parent: Svg;
+    rect: TooltipRect;
+    title: TooltipTitle;
+    activeSeat: SeatItem | null;
+    constructor(parent: Svg);
+    setTitle(title: Array<string>): this;
+    update(): this;
+    afterGenerate(): void;
+}
+
+declare class Svg extends SvgBase {
+    parent: SeatMapCanvas;
+    stage: Stage;
+    zoomOutBg: ZoomOutBg;
+    legend: Legend;
+    tooltip: Tooltip;
+    constructor(parent: SeatMapCanvas);
+    update(): void;
+}
+
+declare class SeatMapDevTools {
+    private context;
+    constructor(context: SeatMapCanvas);
+    log(...messages: any[]): this;
+}
+
+declare class SeatMapCanvas {
+    container_selector: any;
+    node: any;
+    svg: Svg;
+    dev: SeatMapDevTools;
+    data: DataModel;
+    config: DefaultsModel;
+    global: GlobalModel;
+    windowManager: WindowManager;
+    zoomManager: ZoomManager;
+    eventManager: EventManager;
+    addEventListener: any;
+    constructor(container_selector: any, _config: DefaultsModel);
+}
+
+export { SeatMapCanvas };