@harmonics/lattice-ui 0.5.0 → 0.6.0

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/face.d.ts

@@ -28,5 +28,8 @@ export declare class LatticeFace extends LatticeElement {
     set decorative(decorative: boolean | string | null);
     attributeChangedCallback(name: string, _: string | null, value: string | null): void;
 }
-/** Register `<lattice-face>` once; a second call, or a call on a server, does nothing. */
-export declare const defineLatticeFace: () => void;
+/**
+ * Register `<lattice-face>` 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 defineLatticeFace: (name?: string) => void;

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

@@ -1 +1 @@
-export { type Area, apart, boxOf, type Corner, cornerAt, cornerOf, cornersOf, covered, fits, glued, type Hex, hexAt, MAGNET, type Magnet, magnetOf, moved, nearestFit, outlineOf, type Part, type Piece, pieceOf, pivotPoint, pulledOff, screenArea, seamsOf, sharedSides, snapDelta, snapFrames, stepFor, stepOnScreen, type Tri, touching, trisOf, turned, unitAt, } from "../hexes";
+export { type Area, apart, boxOf, type Corner, cornerAt, cornerOf, cornersOf, covered, crossesCell, crossesLine, crossesRing, fits, glued, type Hex, hexAt, MAGNET, type Magnet, magnetOf, moved, nearestFit, outlineOf, type Part, type Piece, pieceOf, pivotPoint, pulledOff, screenArea, seamsOf, sharedSides, snapDelta, snapFrames, stepFor, stepOnScreen, type Tri, touching, trisOf, turned, unitAt, } from "../hexes";

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

@@ -5,8 +5,11 @@
 declare const HostElement: typeof HTMLElement;
 /** One stylesheet per kind of element, made the first time one is shown and shared after. */
 export declare function sheetOf(css: string): () => CSSStyleSheet;
-/** Register an element once, in a browser; a second call, or a call on a server, does nothing. */
-export declare function define(tag: string, element: CustomElementConstructor): void;
+/**
+ * Register an element once, in a browser, as `name` (its own `tag` by default); a second call, or
+ * a call on a server, does nothing. A name another element already holds is left to it, and said.
+ */
+export declare function define(tag: string, element: CustomElementConstructor, name?: string): void;
 /** A whole number from an attribute or a property, or `fallback` when it is not one. */
 export declare const numberOf: (value: unknown, fallback: number) => number;
 /** Whether a boolean attribute or property is on: present, and not "false". */

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

@@ -12,5 +12,8 @@ export declare class LatticeIcon extends LatticeElement {
     set label(label: string);
     attributeChangedCallback(name: string, _: string | null, value: string | null): void;
 }
-/** Register `<lattice-icon>` once; a second call, or a call on a server, does nothing. */
-export declare const defineLatticeIcon: () => void;
+/**
+ * Register `<lattice-icon>` 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 defineLatticeIcon: (name?: string) => void;

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

@@ -1,7 +1,7 @@
 import { defineLatticeFace, LatticeFace } from "./face";
 import { defineLatticeIcon, LatticeIcon } from "./icon";
 import { defineLatticeShape, LatticeShape } from "./shape";
-import { defineShearsPad, ShearsPadElement, type StrokeDetail } from "./shears";
+import { defineShearsPad, ShearsPadElement, type ShearsPadEventMap, type StrokeDetail, type StrokeEndDetail } from "./shears";
 import { defineHexSky, HexSky } from "./sky";
 export { FACES } from "../faceLattice";
 export type { Part } from "../hexes";
@@ -11,7 +11,7 @@ export { SHAPE_TAG } from "./shape";
 export { SHAPE_NAMES, type ShapeName, TONES } from "./shapes";
 export { SHEARS_TAG, type StrokePoint } from "./shears";
 export { SKY_TAG } from "./sky";
-export { defineHexSky, defineLatticeFace, defineLatticeIcon, defineLatticeShape, defineShearsPad, HexSky, LatticeFace, LatticeIcon, LatticeShape, ShearsPadElement, type StrokeDetail, };
+export { defineHexSky, defineLatticeFace, defineLatticeIcon, defineLatticeShape, defineShearsPad, HexSky, LatticeFace, LatticeIcon, LatticeShape, ShearsPadElement, type ShearsPadEventMap, type StrokeDetail, type StrokeEndDetail, };
 /** Register every element once; a second call, or a call on a server, does nothing. */
 export declare function defineLatticeElements(): void;
 declare global {
@@ -22,10 +22,4 @@ declare global {
         "shears-pad": ShearsPadElement;
         "lattice-icon": LatticeIcon;
     }
-    interface HTMLElementEventMap {
-        stroke: CustomEvent<StrokeDetail>;
-        strokeend: CustomEvent<{
-            points: StrokeDetail["points"];
-        }>;
-    }
 }

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

@@ -12,7 +12,8 @@ export declare class LatticeShape extends LatticeElement {
     private readonly labelSignal;
     get shape(): ShapeName;
     set shape(name: string);
-    /** The parts drawn: those given, or the shape's. */
+    private made;
+    /** The parts drawn: those given, or the shape's; the same array until an input changes. */
     get parts(): Part[];
     set parts(parts: unknown);
     get tone(): number;
@@ -25,5 +26,8 @@ export declare class LatticeShape extends LatticeElement {
     set label(label: string);
     attributeChangedCallback(name: string, _: string | null, value: string | null): void;
 }
-/** Register `<lattice-shape>` once; a second call, or a call on a server, does nothing. */
-export declare const defineLatticeShape: () => void;
+/**
+ * Register `<lattice-shape>` 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 defineLatticeShape: (name?: string) => void;

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

@@ -6,9 +6,28 @@ export type StrokePoint = {
     y: number;
 };
 export interface StrokeDetail {
+    /** The stroke so far, a copy of its own. */
     points: StrokePoint[];
+    /** The newest point, the last of `points`. */
+    point: StrokePoint;
     fresh: boolean;
 }
+export interface StrokeEndDetail {
+    points: StrokePoint[];
+    /** The stroke was cut short instead of lifted. */
+    cancelled: boolean;
+}
+/** The pad's own events, for `addEventListener`. */
+export interface ShearsPadEventMap extends HTMLElementEventMap {
+    stroke: CustomEvent<StrokeDetail>;
+    strokeend: CustomEvent<StrokeEndDetail>;
+}
+export interface ShearsPadElement {
+    addEventListener<K extends keyof ShearsPadEventMap>(type: K, listener: (this: ShearsPadElement, event: ShearsPadEventMap[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ShearsPadEventMap>(type: K, listener: (this: ShearsPadElement, event: ShearsPadEventMap[K]) => unknown, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
 export declare class ShearsPadElement extends LatticeElement {
     static readonly observedAttributes: string[];
     private readonly disabledSignal;
@@ -16,5 +35,8 @@ export declare class ShearsPadElement extends LatticeElement {
     set disabled(disabled: boolean | string | null);
     attributeChangedCallback(_: string, __: string | null, value: string | null): void;
 }
-/** Register `<shears-pad>` once; a second call, or a call on a server, does nothing. */
-export declare const defineShearsPad: () => void;
+/**
+ * Register `<shears-pad>` 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 defineShearsPad: (name?: string) => void;

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

@@ -19,5 +19,8 @@ export declare class HexSky extends LatticeElement {
     set y(y: number | string);
     attributeChangedCallback(name: string, _: string | null, value: string | null): void;
 }
-/** Register `<hex-sky>` once; a second call, or a call on a server, does nothing. */
-export declare const defineHexSky: () => void;
+/**
+ * Register `<hex-sky>` 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 defineHexSky: (name?: string) => void;

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

@@ -1,4 +1,5 @@
-import type { HexSky, IconName, LatticeFace, LatticeIcon, LatticeShape, Part, ShapeName, ShearsPadElement, StrokeDetail, StrokePoint } from "./index";
+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 {
         interface IntrinsicElements {
@@ -13,6 +14,7 @@ declare module "solid-js" {
             };
             "hex-sky": JSX.HTMLAttributes<HexSky> & {
                 kind?: "sky" | "earth";
+                orient?: "pointy" | "flat";
                 scale?: number | string;
                 x?: number | string;
                 y?: number | string;
@@ -32,15 +34,24 @@ 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 {
-            stroke: CustomEvent<StrokeDetail>;
-            strokeend: CustomEvent<{
-                points: StrokePoint[];
+            change: CustomEvent<BoardChangeDetail>;
+            catch: CustomEvent<{
+                id: string;
             }>;
+            stroke: CustomEvent<StrokeDetail>;
+            strokeend: CustomEvent<StrokeEndDetail>;
         }
     }
 }