caissify_chessground/dist/index.d.ts

Vue 3 wrapper for chessground - A modern chess board component

import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';

declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

declare type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};

declare interface AnimCurrent {
    start: DOMHighResTimeStamp;
    frequency: cg.KHz;
    plan: AnimPlan;
}

declare type AnimFadings = Map<cg.Key, cg.Piece>;

declare interface AnimPlan {
    anims: AnimVectors;
    fadings: AnimFadings;
}

declare type AnimVector = cg.NumberQuad;

declare type AnimVectors = Map<cg.Key, AnimVector>;

export declare interface Api {
    set(config: Config): void;
    state: State;
    getFen(): cg.FEN;
    toggleOrientation(): void;
    move(orig: cg.Key, dest: cg.Key): void;
    setPieces(pieces: cg.PiecesDiff): void;
    selectSquare(key: cg.Key | null, force?: boolean): void;
    newPiece(piece: cg.Piece, key: cg.Key): void;
    playPremove(): boolean;
    cancelPremove(): void;
    playPredrop(validate: (drop: cg.Drop) => boolean): boolean;
    cancelPredrop(): void;
    cancelMove(): void;
    stop(): void;
    explode(keys: cg.Key[]): void;
    setShapes(shapes: DrawShape[]): void;
    setAutoShapes(shapes: DrawShape[]): void;
    getKeyAtDomPos(pos: cg.NumberPair): cg.Key | undefined;
    redrawAll: cg.Redraw;
    dragNewPiece(piece: cg.Piece, event: cg.MouchEvent, force?: boolean): void;
    destroy: cg.Unbind;
}

declare type BrushColor = 'green' | 'red' | 'blue' | 'yellow';

export declare const CaissifyChessgroundPlugin: {
    install(app: any): void;
};

declare namespace cg {
    export {
        Color,
        Role,
        File_2 as File,
        Rank,
        Key,
        FEN,
        Pos,
        Piece,
        Drop,
        Pieces,
        PiecesDiff,
        KeyPair,
        NumberPair,
        NumberQuad,
        Rect,
        Dests,
        Elements,
        Dom,
        Exploding,
        MoveMetadata,
        SetPremoveMetadata,
        MouchEvent,
        KeyedNode,
        PieceNode,
        SquareNode,
        Memo,
        Timer,
        Redraw,
        Unbind,
        Milliseconds,
        KHz,
        colors,
        roles,
        files,
        ranks,
        RanksPosition,
        BrushColor,
        SquareClasses
    }
}

export declare interface ChessBoardEmits {
    move: [orig: Key, dest: Key, capturedPiece?: Piece];
    dropNewPiece: [piece: Piece, key: Key];
    select: [key: Key];
    insert: [elements: Elements];
    change: [];
}

export declare interface ChessBoardProps {
    fen?: string;
    orientation?: Color;
    turnColor?: Color;
    check?: Color | boolean;
    lastMove?: Key[];
    coordinates?: boolean;
    coordinatesPosition?: 'inside' | 'outside';
    coordinatesOnSquares?: boolean;
    autoCastle?: boolean;
    viewOnly?: boolean;
    disableContextMenu?: boolean;
    movable?: Config['movable'];
    premovable?: Config['premovable'];
    animation?: Config['animation'];
    highlight?: Config['highlight'];
    drawable?: Config['drawable'];
    selectable?: Config['selectable'];
    onMove?: (orig: Key, dest: Key, capturedPiece?: Piece) => void;
    onDropNewPiece?: (piece: Piece, key: Key) => void;
    onSelect?: (key: Key) => void;
    onInsert?: (elements: Elements) => void;
    onChange?: () => void;
}

export declare type Color = (typeof colors)[number];

declare const colors: readonly ["white", "black"];

export declare interface Config {
    fen?: cg.FEN;
    orientation?: cg.Color;
    turnColor?: cg.Color;
    check?: cg.Color | boolean;
    lastMove?: cg.Key[];
    selected?: cg.Key;
    coordinates?: boolean;
    coordinatesOnSquares?: boolean;
    autoCastle?: boolean;
    viewOnly?: boolean;
    disableContextMenu?: boolean;
    addPieceZIndex?: boolean;
    addDimensionsCssVarsTo?: HTMLElement;
    blockTouchScroll?: boolean;
    trustAllEvents?: boolean;
    highlight?: {
        lastMove?: boolean;
        check?: boolean;
        custom?: cg.SquareClasses;
    };
    animation?: {
        enabled?: boolean;
        duration?: number;
    };
    movable?: {
        free?: boolean;
        color?: cg.Color | 'both';
        dests?: cg.Dests;
        showDests?: boolean;
        events?: {
            after?: (orig: cg.Key, dest: cg.Key, metadata: cg.MoveMetadata) => void;
            afterNewPiece?: (role: cg.Role, key: cg.Key, metadata: cg.MoveMetadata) => void;
        };
        rookCastle?: boolean;
    };
    premovable?: {
        enabled?: boolean;
        showDests?: boolean;
        castle?: boolean;
        dests?: cg.Key[];
        customDests?: cg.Dests;
        events?: {
            set?: (orig: cg.Key, dest: cg.Key, metadata?: cg.SetPremoveMetadata) => void;
            unset?: () => void;
        };
    };
    predroppable?: {
        enabled?: boolean;
        events?: {
            set?: (role: cg.Role, key: cg.Key) => void;
            unset?: () => void;
        };
    };
    draggable?: {
        enabled?: boolean;
        distance?: number;
        autoDistance?: boolean;
        showGhost?: boolean;
        deleteOnDropOff?: boolean;
    };
    selectable?: {
        enabled?: boolean;
    };
    events?: {
        change?: () => void;
        move?: (orig: cg.Key, dest: cg.Key, capturedPiece?: cg.Piece) => void;
        dropNewPiece?: (piece: cg.Piece, key: cg.Key) => void;
        select?: (key: cg.Key) => void;
        insert?: (elements: cg.Elements) => void;
    };
    drawable?: {
        enabled?: boolean;
        visible?: boolean;
        defaultSnapToValidMove?: boolean;
        eraseOnClick?: boolean;
        shapes?: DrawShape[];
        autoShapes?: DrawShape[];
        brushes?: DrawBrushes;
        onChange?: (shapes: DrawShape[]) => void;
    };
}

declare const _default: DefineComponent<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ChessBoardProps>, {
orientation: string;
coordinates: boolean;
coordinatesPosition: string;
coordinatesOnSquares: boolean;
viewOnly: boolean;
disableContextMenu: boolean;
autoCastle: boolean;
}>>, {
set: (config: Config) => void;
toggleOrientation: () => void;
setPieces: (pieces: PiecesDiff) => void;
selectSquare: (key: Key | null) => void;
move: (orig: Key, dest: Key) => void;
newPiece: (piece: Piece, key: Key) => void;
playPremove: () => boolean;
cancelPremove: () => void;
cancelMove: () => void;
stop: () => void;
explode: (keys: Key[]) => void;
setAutoShapes: (shapes: DrawShape[]) => void;
setShapes: (shapes: DrawShape[]) => void;
getKeyAtDomPos: (pos: [number, number]) => Key | undefined;
redrawAll: () => void;
dragNewPiece: (piece: Piece, event: Event, force?: boolean | undefined) => void;
chessground: Api | undefined;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: () => void;
select: (key: Key) => void;
move: (orig: Key, dest: Key, capturedPiece?: Piece | undefined) => void;
dropNewPiece: (piece: Piece, key: Key) => void;
insert: (elements: Elements) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ChessBoardProps>, {
orientation: string;
coordinates: boolean;
coordinatesPosition: string;
coordinatesOnSquares: boolean;
viewOnly: boolean;
disableContextMenu: boolean;
autoCastle: boolean;
}>>> & Readonly<{
onChange?: (() => any) | undefined;
onSelect?: ((key: Key) => any) | undefined;
onMove?: ((orig: Key, dest: Key, capturedPiece?: Piece | undefined) => any) | undefined;
onDropNewPiece?: ((piece: Piece, key: Key) => any) | undefined;
onInsert?: ((elements: Elements) => any) | undefined;
}>, {
orientation: "white" | "black";
coordinates: boolean;
coordinatesPosition: "inside" | "outside";
coordinatesOnSquares: boolean;
autoCastle: boolean;
viewOnly: boolean;
disableContextMenu: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { _default as ChessBoard }
export default _default;

declare type Dests = Map<Key, Key[]>;

declare interface Dom {
    elements: Elements;
    bounds: Memo<DOMRectReadOnly>;
    redraw: () => void;
    redrawNow: (skipSvg?: boolean) => void;
    unbind?: Unbind;
    destroyed?: boolean;
}

declare interface DragCurrent {
    orig: cg.Key;
    piece: cg.Piece;
    origPos: cg.NumberPair;
    pos: cg.NumberPair;
    started: boolean;
    element: cg.PieceNode | (() => cg.PieceNode | undefined);
    newPiece?: boolean;
    force?: boolean;
    previouslySelected?: cg.Key;
    originTarget: EventTarget | null;
    keyHasChanged: boolean;
}

declare interface Drawable {
    enabled: boolean;
    visible: boolean;
    defaultSnapToValidMove: boolean;
    eraseOnClick: boolean;
    onChange?: (shapes: DrawShape[]) => void;
    shapes: DrawShape[];
    autoShapes: DrawShape[];
    current?: DrawCurrent;
    brushes: DrawBrushes;
    prevSvgHash: string;
}

declare interface DrawBrush {
    key: string;
    color: string;
    opacity: number;
    lineWidth: number;
}

declare interface DrawBrushes {
    green: DrawBrush;
    red: DrawBrush;
    blue: DrawBrush;
    yellow: DrawBrush;
    [color: string]: DrawBrush;
}

declare interface DrawCurrent {
    orig: cg.Key;
    dest?: cg.Key;
    mouseSq?: cg.Key;
    pos: cg.NumberPair;
    brush: cg.BrushColor;
    snapToValidMove: boolean;
}

declare interface DrawModifiers {
    lineWidth?: number;
    hilite?: boolean;
}

declare interface DrawShape {
    orig: cg.Key;
    dest?: cg.Key;
    brush?: string;
    modifiers?: DrawModifiers;
    piece?: DrawShapePiece;
    customSvg?: {
        html: string;
        center?: 'orig' | 'dest' | 'label';
    };
    label?: {
        text: string;
        fill?: string;
    };
}

declare interface DrawShapePiece {
    role: cg.Role;
    color: cg.Color;
    scale?: number;
}

declare interface Drop {
    role: Role;
    key: Key;
}

declare interface Elements {
    board: HTMLElement;
    wrap: HTMLElement;
    container: HTMLElement;
    ghost?: HTMLElement;
    svg?: SVGElement;
    customSvg?: SVGElement;
    autoPieces?: HTMLElement;
}

declare interface Exploding {
    stage: number;
    keys: readonly Key[];
}

declare type FEN = string;

declare type File_2 = (typeof files)[number];

declare const files: readonly ["a", "b", "c", "d", "e", "f", "g", "h"];

declare interface HeadlessState {
    pieces: cg.Pieces;
    orientation: cg.Color;
    turnColor: cg.Color;
    check?: cg.Key;
    lastMove?: cg.Key[];
    selected?: cg.Key;
    coordinates: boolean;
    coordinatesOnSquares: boolean;
    ranksPosition: cg.RanksPosition;
    autoCastle: boolean;
    viewOnly: boolean;
    disableContextMenu: boolean;
    addPieceZIndex: boolean;
    addDimensionsCssVarsTo?: HTMLElement;
    blockTouchScroll: boolean;
    pieceKey: boolean;
    trustAllEvents?: boolean;
    highlight: {
        lastMove: boolean;
        check: boolean;
        custom?: cg.SquareClasses;
    };
    animation: {
        enabled: boolean;
        duration: number;
        current?: AnimCurrent;
    };
    movable: {
        free: boolean;
        color?: cg.Color | 'both';
        dests?: cg.Dests;
        showDests: boolean;
        events: {
            after?: (orig: cg.Key, dest: cg.Key, metadata: cg.MoveMetadata) => void;
            afterNewPiece?: (role: cg.Role, key: cg.Key, metadata: cg.MoveMetadata) => void;
        };
        rookCastle: boolean;
    };
    premovable: {
        enabled: boolean;
        showDests: boolean;
        castle: boolean;
        dests?: cg.Key[];
        customDests?: cg.Dests;
        current?: cg.KeyPair;
        events: {
            set?: (orig: cg.Key, dest: cg.Key, metadata?: cg.SetPremoveMetadata) => void;
            unset?: () => void;
        };
    };
    predroppable: {
        enabled: boolean;
        current?: {
            role: cg.Role;
            key: cg.Key;
        };
        events: {
            set?: (role: cg.Role, key: cg.Key) => void;
            unset?: () => void;
        };
    };
    draggable: {
        enabled: boolean;
        distance: number;
        autoDistance: boolean;
        showGhost: boolean;
        deleteOnDropOff: boolean;
        current?: DragCurrent;
    };
    dropmode: {
        active: boolean;
        piece?: cg.Piece;
    };
    selectable: {
        enabled: boolean;
    };
    stats: {
        dragged: boolean;
        ctrlKey?: boolean;
    };
    events: {
        change?: () => void;
        move?: (orig: cg.Key, dest: cg.Key, capturedPiece?: cg.Piece) => void;
        dropNewPiece?: (piece: cg.Piece, key: cg.Key) => void;
        select?: (key: cg.Key) => void;
        insert?: (elements: cg.Elements) => void;
    };
    drawable: Drawable;
    exploding?: cg.Exploding;
    hold: cg.Timer;
}

export declare type Key = 'a0' | `${File_2}${Rank}`;

declare interface KeyedNode extends HTMLElement {
    cgKey: Key;
}

declare type KeyPair = [Key, Key];

declare type KHz = number;

declare interface Memo<A> {
    (): A;
    clear: () => void;
}

declare type Milliseconds = number;

declare type MouchEvent = Event & Partial<MouseEvent & TouchEvent>;

declare interface MoveMetadata {
    premove: boolean;
    ctrlKey?: boolean;
    holdTime?: number;
    captured?: Piece;
    predrop?: boolean;
}

declare type NumberPair = [number, number];

declare type NumberQuad = [number, number, number, number];

export declare interface Piece {
    role: Role;
    color: Color;
    promoted?: boolean;
}

declare interface PieceNode extends KeyedNode {
    tagName: 'PIECE';
    cgPiece: string;
    cgAnimating?: boolean;
    cgFading?: boolean;
    cgDragging?: boolean;
    cgScale?: number;
}

declare type Pieces = Map<Key, Piece>;

export declare type PiecesDiff = Map<Key, Piece | undefined>;

declare type Pos = [number, number];

declare type Rank = (typeof ranks)[number];

declare const ranks: readonly ["1", "2", "3", "4", "5", "6", "7", "8"];

declare type RanksPosition = 'left' | 'right';

declare interface Rect {
    left: number;
    top: number;
    width: number;
    height: number;
}

declare type Redraw = () => void;

export declare type Role = (typeof roles)[number];

declare const roles: readonly ["pawn", "knight", "bishop", "rook", "queen", "king"];

declare interface SetPremoveMetadata {
    ctrlKey?: boolean;
}

declare type SquareClasses = Map<Key, string>;

declare interface SquareNode extends KeyedNode {
    tagName: 'SQUARE';
}

declare interface State extends HeadlessState {
    dom: cg.Dom;
}

declare interface Timer {
    start: () => void;
    cancel: () => void;
    stop: () => number;
}

declare type Unbind = () => void;

export declare function useChessground(element: Ref<HTMLElement | undefined>, config: Ref<Config>): UseChessgroundReturn;

export declare interface UseChessgroundReturn {
    chessground: Readonly<Ref<Api | undefined>>;
    set: (config: Config) => void;
    toggleOrientation: () => void;
    setPieces: (pieces: PiecesDiff) => void;
    selectSquare: (key: Key | null) => void;
    move: (orig: Key, dest: Key) => void;
    newPiece: (piece: Piece, key: Key) => void;
    playPremove: () => boolean;
    cancelPremove: () => void;
    cancelMove: () => void;
    stop: () => void;
    explode: (keys: Key[]) => void;
    setAutoShapes: (shapes: DrawShape[]) => void;
    setShapes: (shapes: DrawShape[]) => void;
    getKeyAtDomPos: (pos: [number, number]) => Key | undefined;
    redrawAll: () => void;
    dragNewPiece: (piece: Piece, event: Event, force?: boolean) => void;
}

export { }