@mintplayer/ng-bootstrap 21.27.0 → 21.29.0

package/types/mintplayer-ng-bootstrap-tile-manager.d.ts

@@ -0,0 +1,285 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, AfterViewInit, ElementRef } from '@angular/core';
+import * as lit from 'lit';
+import { LitElement, TemplateResult, PropertyValues } from 'lit';
+
+/**
+ * Grid placement of a single tile, in CSS Grid 1-based coordinates.
+ * `colStart` / `rowStart` are inclusive; `colSpan` / `rowSpan` are counts of cells.
+ */
+interface TilePosition {
+    colStart: number;
+    rowStart: number;
+    colSpan: number;
+    rowSpan: number;
+}
+
+/**
+ * One tile inside a `<bs-tile-manager>`.
+ *
+ * The component captures two `TemplateRef`s — one for the header (a child
+ * `<bs-tile-header>`) and one for the body (everything else) — which the
+ * manager projects into named slots on the underlying `<mp-tile-manager>`
+ * web component (`${id}-header` and `${id}-content`).
+ */
+declare class BsTileComponent {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly position: _angular_core.InputSignal<TilePosition>;
+    readonly disableMove: _angular_core.InputSignal<boolean>;
+    readonly disableResize: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly positionChange: _angular_core.OutputEmitterRef<TilePosition>;
+    readonly headerTpl: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly contentTpl: _angular_core.Signal<TemplateRef<unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTileComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTileComponent, "bs-tile", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": true; "isSignal": true; }; "disableMove": { "alias": "disableMove"; "required": false; "isSignal": true; }; "disableResize": { "alias": "disableResize"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "positionChange": "positionChange"; }, never, ["bs-tile-header", "*"], true, never>;
+}
+
+/**
+ * Stable, JSON-serializable snapshot of the manager's layout.
+ * One entry per tile, keyed by stable id. Host apps `JSON.stringify`
+ * this for persistence and project it back into per-tile `position`
+ * inputs to restore.
+ */
+type TileLayoutSnapshot = Array<{
+    id: string;
+    position: TilePosition;
+}>;
+interface TileGestureBlocked {
+    id: string;
+    reason: 'locked-overlap' | 'no-valid-layout';
+}
+
+/**
+ * Half-open rectangle in grid coordinates: `[colStart, colStart + colSpan) × [rowStart, rowStart + rowSpan)`.
+ * Same shape as `TilePosition` but used internally for overlap math; kept
+ * as its own type so call-sites read clearly.
+ */
+interface GridRect {
+    colStart: number;
+    rowStart: number;
+    colSpan: number;
+    rowSpan: number;
+}
+declare function rectsOverlap(a: GridRect, b: GridRect): boolean;
+
+interface MintTile {
+    id: string;
+    position: TilePosition;
+    disableMove: boolean;
+    disableResize: boolean;
+    label: string | null;
+}
+type TileDragMode = 'tile' | 'header' | 'off';
+type TileResizeMode = 'hover' | 'always' | 'off';
+type GestureState = {
+    kind: 'idle';
+} | {
+    kind: 'arming-touch-drag';
+    pointerId: number;
+    tileId: string;
+    startX: number;
+    startY: number;
+    timer: number | null;
+    pressingTimer: number | null;
+} | {
+    kind: 'drag';
+    pointerId: number;
+    tileId: string;
+    pointerOffset: {
+        dx: number;
+        dy: number;
+    };
+    currentRect: GridRect;
+    blocked: boolean;
+} | {
+    kind: 'resize';
+    pointerId: number;
+    tileId: string;
+    mode: 'side' | 'bottom' | 'corner';
+    startPointer: {
+        x: number;
+        y: number;
+    };
+    startSpans: {
+        colSpan: number;
+        rowSpan: number;
+    };
+    currentRect: GridRect;
+    blocked: boolean;
+};
+declare class MintTileManagerElement extends LitElement {
+    static styles: lit.CSSResult[];
+    static get observedAttributes(): string[];
+    static properties: {
+        tiles: {
+            attribute: boolean;
+        };
+        columnCount: {
+            attribute: string;
+            type: NumberConstructor;
+        };
+        minColumnWidth: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        minRowHeight: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        gap: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        dragMode: {
+            attribute: string;
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        resizeMode: {
+            attribute: string;
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        animateReflow: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        label: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        previewLayout: {
+            state: boolean;
+        };
+        gestureKind: {
+            state: boolean;
+        };
+        blocked: {
+            state: boolean;
+        };
+        effectiveColumnCount: {
+            state: boolean;
+        };
+        keyboardMode: {
+            state: boolean;
+        };
+        liveRegionMessage: {
+            state: boolean;
+        };
+    };
+    tiles: ReadonlyArray<MintTile>;
+    columnCount: number | null;
+    minColumnWidth: string;
+    minRowHeight: string;
+    gap: string;
+    dragMode: TileDragMode;
+    resizeMode: TileResizeMode;
+    animateReflow: boolean;
+    label: string | null;
+    private gestureState;
+    private keyboardState;
+    protected previewLayout: TileLayoutSnapshot | null;
+    protected gestureKind: GestureState['kind'];
+    protected blocked: boolean;
+    protected effectiveColumnCount: number;
+    protected liveRegionMessage: string;
+    private hostResizeObserver;
+    private flipPreviousRects;
+    private cellMetrics;
+    private readonly onWindowPointerMove;
+    private readonly onWindowPointerUp;
+    private readonly onWindowPointerCancel;
+    private readonly onWindowKeyDown;
+    private readonly onVisibilityChange;
+    render(): TemplateResult;
+    private renderTile;
+    private computeGridStyle;
+    /**
+     * Refresh the cached layout metrics by reading layout / computed-style state
+     * once. Called from firstUpdated, the ResizeObserver tick, and updated()
+     * when an input that affects metrics changes — never from render().
+     */
+    private updateLayoutCache;
+    private computeActiveTransform;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected firstUpdated(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    protected willUpdate(_changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    private shouldAnimate;
+    private lastPointerPosition;
+    private onTilePointerDown;
+    private onResizeHandlePointerDown;
+    private armPointerDrag;
+    private armTouchDrag;
+    private cleanupTouchArming;
+    private beginDragFromTouchArm;
+    private beginDrag;
+    private beginResize;
+    private attachWindowListeners;
+    private detachWindowListeners;
+    private handleEscapeKey;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private runPackerForCurrentGesture;
+    private computeDragRect;
+    private computeResizeRect;
+    private commitGesture;
+    private cancelGesture;
+    private cleanupGesture;
+    private positionsEqual;
+    private cloneSnapshot;
+    private activeTileId;
+    /** Read-only snapshot of the current layout. Mirrors `BsDockManagerComponent.captureLayout()`. */
+    captureLayout(): TileLayoutSnapshot;
+    /**
+     * True while a drag or resize is in flight. The Angular wrapper uses this to
+     * avoid clobbering `tiles` mid-gesture. Touch long-press arming does NOT
+     * count — the WC isn't yet owning the layout during the hold.
+     */
+    get isGestureActive(): boolean;
+    private onTileKeyDown;
+    private applyKeyboardStep;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mp-tile-manager': MintTileManagerElement;
+    }
+}
+
+declare class BsTileManagerComponent implements AfterViewInit {
+    readonly columnCount: _angular_core.InputSignal<number | null>;
+    readonly minColumnWidth: _angular_core.InputSignal<string>;
+    readonly minRowHeight: _angular_core.InputSignal<string>;
+    readonly gap: _angular_core.InputSignal<string>;
+    readonly dragMode: _angular_core.InputSignal<TileDragMode>;
+    readonly resizeMode: _angular_core.InputSignal<TileResizeMode>;
+    readonly animateReflow: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly layoutChange: _angular_core.OutputEmitterRef<TileLayoutSnapshot>;
+    readonly gestureBlocked: _angular_core.OutputEmitterRef<TileGestureBlocked>;
+    readonly tiles: _angular_core.Signal<readonly BsTileComponent[]>;
+    readonly managerRef: _angular_core.Signal<ElementRef<MintTileManagerElement> | undefined>;
+    protected readonly columnCountAttr: _angular_core.Signal<string | null>;
+    private readonly tilesSnapshot;
+    constructor();
+    ngAfterViewInit(): void;
+    /** Returns the current layout. Mirrors `BsDockManagerComponent.captureLayout()`. */
+    captureLayout(): TileLayoutSnapshot;
+    protected onLayoutChange(event: Event): void;
+    protected onPositionChange(event: Event): void;
+    protected onGestureBlocked(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTileManagerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTileManagerComponent, "bs-tile-manager", never, { "columnCount": { "alias": "columnCount"; "required": false; "isSignal": true; }; "minColumnWidth": { "alias": "minColumnWidth"; "required": false; "isSignal": true; }; "minRowHeight": { "alias": "minRowHeight"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "dragMode": { "alias": "dragMode"; "required": false; "isSignal": true; }; "resizeMode": { "alias": "resizeMode"; "required": false; "isSignal": true; }; "animateReflow": { "alias": "animateReflow"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "layoutChange": "layoutChange"; "gestureBlocked": "gestureBlocked"; }, ["tiles"], never, true, never>;
+}
+
+declare class BsTileHeaderComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsTileHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsTileHeaderComponent, "bs-tile-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { BsTileComponent, BsTileHeaderComponent, BsTileManagerComponent, MintTileManagerElement, rectsOverlap };
+export type { GridRect, MintTile, TileDragMode, TileGestureBlocked, TileLayoutSnapshot, TilePosition, TileResizeMode };