@scm-js/plugin-api 1.52.0 → 1.54.0

package/index.d.ts

@@ -5098,11 +5098,38 @@ export interface MapViewSpec {
 	 * where they were. Not called when another map, already showing the view, comes to the front.
 	 */
 	onShow?(look: MapViewCamera): void;
+	/**
+	 * The person zoomed while the view is shown — View ▸ Zoom In, Zoom Out, one of the levels or
+	 * Zoom to Fit, the toolbar's buttons, their keys, or a wheel you passed on (`MapViewHandle.wheel`):
+	 * look at `look`, at that scale or as near to it as the view goes. The editor works the view's
+	 * zoom out from where it last said it looks (`setCamera`) and the view's size on the screen, and
+	 * shows it in the toolbar and the status bar: say where you look after each change, or the next
+	 * step starts from the old scale. Without `onZoom` the editor's zoom is the map's, hidden behind.
+	 */
+	onZoom?(look: MapViewCamera): void;
 	/**
 	 * What the minimap shows while the view is shown. Without it the minimap shows the map, and
 	 * its box and presses are the map's own view's (hidden behind this one).
 	 */
 	minimap?: MapViewMinimapSpec;
+	/**
+	 * View ▸ Fog of War, the toolbar's button and its key, while the view is shown: turn the view's
+	 * own fog on or off. The toggle then shows the view's fog, as you last said it
+	 * (`MapViewHandle.setFog`), not the map's. Without `onFog` the toggle is off while the view is shown.
+	 */
+	onFog?(on: boolean): void;
+	/**
+	 * What `MapViewHandle.paintOver` draws changed — View ▸ Grid or Locations turned on or off, the
+	 * grid's settings, the map's locations, another plugin's overlay: draw over the view again. With
+	 * it the editor's Grid, Locations and Location Names toggles, and the other plugins' overlays,
+	 * stay on offer while the view is shown; without it they are off, as the view cannot show them.
+	 */
+	onRepaint?(): void;
+}
+/** Where the pointer is over a map view (`MapViewHandle.setPointer`), in map pixels. */
+export interface MapViewPointer {
+	x: number;
+	y: number;
 }
 /**
  * Where a view looks, in map pixels (32 to a tile): the point in the middle of what it shows,
@@ -5146,6 +5173,20 @@ export interface MapViewMinimapSpec {
 	 */
 	press?(x: number, y: number): void;
 }
+/**
+ * A wheel turned over a map view (`MapViewHandle.wheel`): as the browser's `WheelEvent` has it,
+ * and the map pixel under the pointer.
+ */
+export interface MapViewWheel {
+	deltaY: number;
+	/** `WheelEvent.deltaMode`: 0 pixels (as when left out), 1 lines, 2 pages. */
+	deltaMode?: number;
+	ctrlKey?: boolean;
+	metaKey?: boolean;
+	shiftKey?: boolean;
+	x: number;
+	y: number;
+}
 /** Map pixels to minimap canvas pixels, for `MapViewMinimapSpec.draw`. */
 export interface MinimapView {
 	/** Minimap canvas pixels per map pixel. */
@@ -5178,8 +5219,44 @@ export interface MapViewHandle extends Disposable {
 	 * the same scale.
 	 */
 	setCamera(camera: MapViewCamera): void;
+	/**
+	 * A wheel turned over the view, for the editor to zoom by the same rule as over the map: with
+	 * Ctrl, or alone where the person's preferences say the wheel zooms, toward the pointer where
+	 * they say that. A step calls `onZoom`. Whether the editor took the wheel for zooming — false
+	 * too while the view is not shown or has no `onZoom`, and the wheel is yours to use.
+	 *
+	 * @example
+	 * // The play page in an iframe hands its wheel back; zoom the game by the editor's rule.
+	 * game.onWheel((w) => view.wheel(w));
+	 */
+	wheel(wheel: MapViewWheel): boolean;
 	/** Make the minimap's picture again (`minimap.draw`), at most once a frame. Cheap: call it as the view's contents move. */
 	redrawMinimap(): void;
+	/**
+	 * Whether the view shows its fog now, for View ▸ Fog of War and the toolbar's button while it
+	 * is shown (`onFog`); null when it has none to show at the moment, which greys the toggle. Say
+	 * it whenever it changes, by the person's hand or yours.
+	 */
+	setFog(on: boolean | null): void;
+	/**
+	 * Where the pointer is over the view, in map pixels, for the status bar's tile and position;
+	 * null once it leaves. A view in an iframe hears the pointer and the editor does not.
+	 */
+	setPointer(at: MapViewPointer | null): void;
+	/**
+	 * Draw what the editor draws over a map onto your canvas over the view, mapped by `view` as a
+	 * map tool's or an overlay's `draw` is: the grid and the locations as View ▸ Grid, Locations and
+	 * Location Names have them, then the other plugins' visible overlays (yours are your own to draw).
+	 * Call it from your own drawing, above the view's picture and below your marks, each time you
+	 * draw; `onRepaint` says when it would draw something else. Nothing while the view is not shown.
+	 *
+	 * @example
+	 * function drawOver(ctx: CanvasRenderingContext2D, v: MapView) {
+	 *   handle.paintOver(ctx, v);
+	 *   drawMyMarks(ctx, v);
+	 * }
+	 */
+	paintOver(ctx: CanvasRenderingContext2D, view: MapView): void;
 }
 export interface PanelHandle {
 	close(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scm-js/plugin-api",
-  "version": "1.52.0",
+  "version": "1.54.0",
   "description": "Type declarations for the scmJS plugin API",
   "license": "MIT",
   "types": "index.d.ts",