@harmonics/lattice-ui 0.5.1 → 0.6.0

package/dist/types/boardTypes.d.ts

@@ -0,0 +1,2 @@
+/** What was done to the pieces, as a `change` says it. */
+export type BoardAction = "move" | "turn" | "glue" | "break" | "pull" | "add" | "remove";

package/dist/types/elements/board-entry.d.ts

@@ -0,0 +1,9 @@
+import { BOARD_TAG, type BoardChangeDetail, type BoardPiece, defineLatticeBoard, LatticeBoard, type LatticeBoardEventMap } from "./board";
+export type { BoardAction } from "../boardTypes";
+export type { Part, Piece } from "../hexes";
+export { BOARD_TAG, type BoardChangeDetail, type BoardPiece, defineLatticeBoard, LatticeBoard, type LatticeBoardEventMap, };
+declare global {
+    interface HTMLElementTagNameMap {
+        "lattice-board": LatticeBoard;
+    }
+}

package/dist/types/elements/board.d.ts

@@ -0,0 +1,59 @@
+import type { BoardAction } from "../boardTypes";
+import { type Part, type Piece } from "../hexes";
+import { LatticeElement } from "./host";
+export declare const BOARD_TAG = "lattice-board";
+/** A piece as a page hands it over: an id of its own (one is made if not) and its parts. */
+export interface BoardPiece {
+    id?: string;
+    parts: Part[];
+}
+export interface BoardChangeDetail {
+    /** The board's pieces now, fixed ones left out. */
+    pieces: Piece[];
+    action: BoardAction;
+    /** The piece acted on ("" when the board itself moved pieces back into view). */
+    id: string;
+}
+/** The board's own events, for `addEventListener`. */
+export interface LatticeBoardEventMap extends HTMLElementEventMap {
+    change: CustomEvent<BoardChangeDetail>;
+    catch: CustomEvent<{
+        id: string;
+    }>;
+}
+export interface LatticeBoard {
+    addEventListener<K extends keyof LatticeBoardEventMap>(type: K, listener: (this: LatticeBoard, event: LatticeBoardEventMap[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof LatticeBoardEventMap>(type: K, listener: (this: LatticeBoard, event: LatticeBoardEventMap[K]) => unknown, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export declare class LatticeBoard extends LatticeElement {
+    static readonly observedAttributes: string[];
+    private readonly givenSignal;
+    private readonly fixedSignal;
+    private readonly traySignal;
+    private readonly scaleSignal;
+    private readonly labelSignal;
+    /** The board's pieces while it is drawn. */
+    private live;
+    private made;
+    private readonly madeId;
+    /** The pieces on the board, fixed ones left out. */
+    get pieces(): Piece[];
+    set pieces(pieces: unknown);
+    /** Pieces drawn flat and in the way, never handled. */
+    get fixed(): Piece[];
+    set fixed(pieces: unknown);
+    get tray(): boolean;
+    set tray(tray: boolean | string | null);
+    get scale(): number;
+    set scale(scale: number | string);
+    get label(): string;
+    set label(label: string);
+    attributeChangedCallback(name: string, _: string | null, value: string | null): void;
+}
+/**
+ * Register `<lattice-board>` once, or as `name` (a tag of your own, when another library holds
+ * this one); a second call, or a call on a server, does nothing.
+ */
+export declare const defineLatticeBoard: (name?: string) => void;

package/dist/types/elements/solid.d.ts

@@ -1,3 +1,4 @@
+import type { BoardChangeDetail, BoardPiece, LatticeBoard } from "./board-entry";
 import type { HexSky, IconName, LatticeFace, LatticeIcon, LatticeShape, Part, ShapeName, ShearsPadElement, StrokeDetail, StrokeEndDetail } from "./index";
 declare module "solid-js" {
     namespace JSX {
@@ -33,11 +34,22 @@ declare module "solid-js" {
                 name?: IconName;
                 label?: string;
             };
+            "lattice-board": JSX.HTMLAttributes<LatticeBoard> & {
+                tray?: boolean;
+                scale?: number | string;
+                label?: string;
+            };
         }
         interface ExplicitProperties {
             parts: Part[] | string;
+            pieces: BoardPiece[] | string;
+            fixed: BoardPiece[];
         }
         interface CustomEvents {
+            change: CustomEvent<BoardChangeDetail>;
+            catch: CustomEvent<{
+                id: string;
+            }>;
             stroke: CustomEvent<StrokeDetail>;
             strokeend: CustomEvent<StrokeEndDetail>;
         }