@mark1russell7/visuals 0.3.3 → 0.3.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +147 -2
- package/build/globe.d.ts +2 -2
- package/build/graph.d.ts +417 -0
- package/build/graph.d.ts.map +1 -0
- package/build/graph.js +855 -0
- package/build/graph.js.map +1 -0
- package/build/highlight-BJ6xGp6V.d.ts +30 -0
- package/build/highlight-BJ6xGp6V.d.ts.map +1 -0
- package/build/index.d.ts +2 -1
- package/build/index.d.ts.map +1 -1
- package/build/index.js +1 -1
- package/build/labels.d.ts +1 -1
- package/build/markers.d.ts +2 -2
- package/build/{motion-BvRKIWAC.js → motion-VS13e4Pw.js} +14 -3
- package/build/{motion-BvRKIWAC.js.map → motion-VS13e4Pw.js.map} +1 -1
- package/build/{stage-DmFfah2e.d.ts → stage-D8JVM6wZ.d.ts} +3 -2
- package/build/stage-D8JVM6wZ.d.ts.map +1 -0
- package/build/{theme-3EGbXXoP.d.ts → theme-DBbBlCbC.d.ts} +2 -30
- package/build/theme-DBbBlCbC.d.ts.map +1 -0
- package/build/three.d.ts +2 -2
- package/build/three.js +2 -8
- package/build/three.js.map +1 -1
- package/package.json +6 -1
- package/build/stage-DmFfah2e.d.ts.map +0 -1
- package/build/theme-3EGbXXoP.d.ts.map +0 -1
package/README.md
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
|
|
3
3
|
3D stages for data. A stage is one canvas of three.js with a camera that a person moves. The content of the stage is your data.
|
|
4
4
|
|
|
5
|
-
The package has
|
|
5
|
+
The package has eight entries and two style sheets:
|
|
6
6
|
|
|
7
7
|
- The entry `.` has the camera maths and the model of a replay. It needs no browser, and it does not need `three`.
|
|
8
8
|
- The entry `/marks` has the marks that a viewer draws, as plain data. It needs no browser, and it does not need `three`.
|
|
@@ -13,6 +13,7 @@ The package has seven entries and two style sheets:
|
|
|
13
13
|
- The file `/scrubber.css` is the style sheet of the scrubber.
|
|
14
14
|
- The entry `/labels` has the labels of a stage: a short text next to a point, as an element of the page. It needs a browser.
|
|
15
15
|
- The file `/labels.css` is the style sheet of the labels.
|
|
16
|
+
- The entry `/graph` has the stage of a flat picture, for example a graph of boxes and edges. It does not need `three`.
|
|
16
17
|
|
|
17
18
|
## Install
|
|
18
19
|
|
|
@@ -20,7 +21,7 @@ The package has seven entries and two style sheets:
|
|
|
20
21
|
npm install @mark1russell7/visuals three
|
|
21
22
|
```
|
|
22
23
|
|
|
23
|
-
A package that uses only the entries `.`, `/marks` and `/
|
|
24
|
+
A package that uses only the entries `.`, `/marks`, `/scrubber` and `/graph` does not install `three`.
|
|
24
25
|
|
|
25
26
|
## A stage
|
|
26
27
|
|
|
@@ -470,6 +471,150 @@ stage?.refresh();
|
|
|
470
471
|
- The pick of a field gives the mark. `fieldValue` reads the value of a cell.
|
|
471
472
|
- The content draws the marks in the space of the stage. `transformMarks` moves the marks of a different space into it.
|
|
472
473
|
|
|
474
|
+
## A flat picture
|
|
475
|
+
|
|
476
|
+
The entry `/graph` is for a flat picture that a person moves and zooms, for example a graph of boxes and edges.
|
|
477
|
+
It has a stage on a canvas, and the maths of its camera, its pointers and its keys. It imports no `three`.
|
|
478
|
+
|
|
479
|
+
```ts
|
|
480
|
+
import { aimRects, createPictureStage, type PictureContent } from "@mark1russell7/visuals/graph";
|
|
481
|
+
|
|
482
|
+
interface Box {
|
|
483
|
+
readonly id: string;
|
|
484
|
+
readonly x: number;
|
|
485
|
+
readonly y: number;
|
|
486
|
+
readonly w: number;
|
|
487
|
+
readonly h: number;
|
|
488
|
+
}
|
|
489
|
+
|
|
490
|
+
const first: Box = { id: "a", x: 0, y: 0, w: 160, h: 60 };
|
|
491
|
+
const boxes: readonly Box[] = [first, { id: "b", x: 240, y: 120, w: 160, h: 60 }];
|
|
492
|
+
|
|
493
|
+
// A content draws in CSS pixels. The view of the frame has the zoom and the position of the picture.
|
|
494
|
+
const content: PictureContent<Box, { readonly box: string; readonly selected: string }> = {
|
|
495
|
+
bounds: { x: 0, y: 0, w: 400, h: 180 },
|
|
496
|
+
has: (record) => boxes.some((box) => box.id === record),
|
|
497
|
+
pick: ({ point }) => {
|
|
498
|
+
const box = boxes.find((b) => point.x >= b.x && point.x <= b.x + b.w && point.y >= b.y && point.y <= b.y + b.h);
|
|
499
|
+
return box === undefined ? undefined : { record: box.id, value: box };
|
|
500
|
+
},
|
|
501
|
+
draw(context, { view }, theme, highlight) {
|
|
502
|
+
context.translate(view.x, view.y);
|
|
503
|
+
context.scale(view.k, view.k);
|
|
504
|
+
for (const box of boxes) {
|
|
505
|
+
context.fillStyle = highlight(box.id) === 0 ? theme.box : theme.selected;
|
|
506
|
+
context.fillRect(box.x, box.y, box.w, box.h);
|
|
507
|
+
}
|
|
508
|
+
return false;
|
|
509
|
+
},
|
|
510
|
+
};
|
|
511
|
+
|
|
512
|
+
const stage = createPictureStage(document.body, {
|
|
513
|
+
content,
|
|
514
|
+
theme: { box: "#c8d0d8", selected: "#2f6fd0" },
|
|
515
|
+
label: "Two boxes",
|
|
516
|
+
views: { first: aimRects([first], { least: 0.6 }) },
|
|
517
|
+
keys: { f: "first" },
|
|
518
|
+
onSelect: (box) => console.log(box?.id),
|
|
519
|
+
});
|
|
520
|
+
stage?.setView("first");
|
|
521
|
+
```
|
|
522
|
+
|
|
523
|
+
The stage fills its container, so give the container a size. `createPictureStage` gives `undefined` when the browser gives no 2D context.
|
|
524
|
+
|
|
525
|
+
- A drag moves the picture. The wheel, two fingers and a double click change the zoom at the pointer.
|
|
526
|
+
- A click selects the record below the pointer, and `onSelect` gets its value. `onHover` gets the record below a mouse or a pen.
|
|
527
|
+
- The wheel moves the page until a person uses the picture. Set `wheel` to `always` for a picture that fills the page.
|
|
528
|
+
- A view is an aim: a function that gives the view for a picture and a screen.
|
|
529
|
+
- `aimAll` shows all of the picture, and `aimRects` shows a group of boxes. `aimReveal` moves the camera only for a selection that is out of view.
|
|
530
|
+
- The stage asks the aim again after a change of the size, until a person moves the picture.
|
|
531
|
+
- A part of the picture stays in view: `keepRect` keeps 64 pixels of it in the free area.
|
|
532
|
+
- A very large picture gets a smaller least zoom from `zoomLimitsFor`, so a person can show all of it.
|
|
533
|
+
- `setInsets` tells the stage which parts of the picture the page covers. Each view uses the free area.
|
|
534
|
+
- `stackPictureContents` makes one content from layers, for example boxes below routes below labels.
|
|
535
|
+
- The stage makes a picture only after a change. A content that continues to change gives true from `draw`.
|
|
536
|
+
- A person who asks for less motion gets each view immediately.
|
|
537
|
+
|
|
538
|
+
| Function of the stage | What it does |
|
|
539
|
+
| --- | --- |
|
|
540
|
+
| `setContent` | It shows a different content, and disposes the old content. |
|
|
541
|
+
| `setTheme` | It changes the colors. |
|
|
542
|
+
| `setView` | It moves the camera to a view: a name of the options, or an aim. |
|
|
543
|
+
| `setInsets` | It sets the parts of the picture that the page covers. |
|
|
544
|
+
| `zoomBy` | It changes the zoom by a factor at the middle of the free area, for the buttons of a page. |
|
|
545
|
+
| `view`, `area` | They give the view of the camera, and the free area. |
|
|
546
|
+
| `highlight`, `select` | They highlight records by their names, and select one record. |
|
|
547
|
+
| `refresh` | It makes a new picture after a change of the content. |
|
|
548
|
+
| `dispose` | It removes the canvas, and disposes the content. |
|
|
549
|
+
|
|
550
|
+
The maths of the camera are pure functions, so a test in Node.js uses them:
|
|
551
|
+
|
|
552
|
+
```ts
|
|
553
|
+
import { fitRect, freeArea, toPicture, viewBetween, zoomView } from "@mark1russell7/visuals/graph";
|
|
554
|
+
|
|
555
|
+
// A panel of the page covers 300 pixels at the right of a picture of 1000 by 600 pixels.
|
|
556
|
+
const area = freeArea({ width: 1000, height: 600 }, { right: 300 }); // => { x: 0, y: 0, w: 700, h: 600 }
|
|
557
|
+
const all = fitRect({ x: 0, y: 0, w: 1304, h: 400 }, area); // => { x: 24, y: 200, k: 0.5 }
|
|
558
|
+
|
|
559
|
+
// A zoom at the middle of the free area: the point of the picture there stays there.
|
|
560
|
+
const near = zoomView(all, { x: 350, y: 300 }, 2); // => { x: -302, y: 100, k: 1 }
|
|
561
|
+
toPicture(near, { x: 350, y: 300 }); // => { x: 652, y: 200 }
|
|
562
|
+
viewBetween(all, near, 0.5).k; // => 0.707: a half of the way is a half of the factor of the zoom
|
|
563
|
+
```
|
|
564
|
+
|
|
565
|
+
A view has the zoom `k` and the screen position of the origin of the picture. A point `p` shows at `p * k + (x, y)`.
|
|
566
|
+
|
|
567
|
+
| Function | What it gives |
|
|
568
|
+
| --- | --- |
|
|
569
|
+
| `toPicture`, `toScreen`, `rectToScreen` | The point of the picture at a screen point, and the screen position of a point or a rectangle. |
|
|
570
|
+
| `viewAt`, `panView`, `zoomView` | The view that shows a point at a screen point, the view after a move, and the view after a zoom at a screen point. |
|
|
571
|
+
| `wheelFactor` | The factor of the zoom for one event of a wheel, also for a pinch on a touch pad. |
|
|
572
|
+
| `pinchView` | The view after the two pointers of a pinch move. Each pointer keeps its point of the picture. |
|
|
573
|
+
| `freeArea` | The part of a picture that the page does not cover. A camera shows a selection there. |
|
|
574
|
+
| `fitRect` | The view that shows a rectangle in an area, as large as the area permits. |
|
|
575
|
+
| `zoomLimitsFor` | The limits of the zoom for a picture, with a least zoom that shows all of it. |
|
|
576
|
+
| `keepRect` | The view that keeps a part of a rectangle in an area, so a person cannot lose the picture. |
|
|
577
|
+
| `aimAll`, `aimRects`, `aimReveal` | The aims of a stage: all of the picture, a group of boxes, and a selection. |
|
|
578
|
+
| `stackPictureContents` | One content from a list of contents. The last content is on top. |
|
|
579
|
+
| `frameRects` | The view for the first rectangle of a list that the area shows at a least zoom or more. |
|
|
580
|
+
| `showsRect` | True when a view shows all of a rectangle in an area. |
|
|
581
|
+
| `revealRects` | The view that shows a selection. It is the view of the camera when the selection is in view, so the camera stays. |
|
|
582
|
+
| `viewBetween`, `pictureMoveAt` | A view on the way between two views, and the view at a time of a move. |
|
|
583
|
+
| `pointerDown`, `pointerMove`, `pointerUp`, `pointerCancel` | The pointers that are down on a picture, the view after a pointer moved, and the answer if a pointer made a click. |
|
|
584
|
+
| `pictureKeyAction` | The action of a key: a move of the camera, or a view by its name. |
|
|
585
|
+
|
|
586
|
+
The pointers of a picture are a value. Each event of a pointer gives the next value:
|
|
587
|
+
|
|
588
|
+
```ts
|
|
589
|
+
import { NO_POINTERS, UNIT_VIEW, pointerDown, pointerMove, pointerUp, toPicture } from "@mark1russell7/visuals/graph";
|
|
590
|
+
|
|
591
|
+
let pointers = NO_POINTERS;
|
|
592
|
+
let view = UNIT_VIEW;
|
|
593
|
+
const at = (event: PointerEvent) => ({ x: event.offsetX, y: event.offsetY });
|
|
594
|
+
|
|
595
|
+
canvas.addEventListener("pointerdown", (event) => {
|
|
596
|
+
pointers = pointerDown(pointers, event.pointerId, at(event));
|
|
597
|
+
});
|
|
598
|
+
canvas.addEventListener("pointermove", (event) => {
|
|
599
|
+
// One pointer moves the picture. Two pointers make a pinch.
|
|
600
|
+
({ pointers, view } = pointerMove(pointers, event.pointerId, at(event), view));
|
|
601
|
+
});
|
|
602
|
+
canvas.addEventListener("pointerup", (event) => {
|
|
603
|
+
const up = pointerUp(pointers, event.pointerId, at(event));
|
|
604
|
+
pointers = up.pointers;
|
|
605
|
+
if (up.click) select(toPicture(view, at(event)));
|
|
606
|
+
});
|
|
607
|
+
```
|
|
608
|
+
|
|
609
|
+
- One pointer moves the picture, and the point of the picture below the pointer stays there. Two pointers make a pinch.
|
|
610
|
+
- A click is one pointer that goes up near its start. A drag and a pinch make no click.
|
|
611
|
+
- A finger moves more than a mouse. Give `TOUCH_CLICK_DISTANCE` to `pointerUp` for an event with the pointer type `touch`.
|
|
612
|
+
- An arrow key moves the camera. The keys `+` and `-` zoom at the middle of the free area, and `Home` shows the home view.
|
|
613
|
+
- A move between two views is a zoom at one screen point. Each point of the picture moves along a straight line, in one direction.
|
|
614
|
+
- The zoom of a move changes by an equal factor for each equal step, so it has one speed in the picture.
|
|
615
|
+
- `frameRects` gets the bounds of groups of boxes, the largest group first. It takes the first group that a person can read.
|
|
616
|
+
- The zoom stays in `ZOOM_LIMITS`. Each function with a zoom takes different limits as a parameter.
|
|
617
|
+
|
|
473
618
|
## The camera maths
|
|
474
619
|
|
|
475
620
|
The entry `.` has pure functions. A page with no WebGL 2 and a test in Node.js use the same functions as the stage.
|
package/build/globe.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { r as StageContent } from "./stage-
|
|
2
|
-
import {
|
|
1
|
+
import { r as StageContent } from "./stage-D8JVM6wZ.js";
|
|
2
|
+
import { _ as ViewAngles, a as StageView, t as StageTheme } from "./theme-DBbBlCbC.js";
|
|
3
3
|
import { Raycaster } from "three";
|
|
4
4
|
import { LatLon, Region } from "@mark1russell7/geo";
|
|
5
5
|
import { Point3 } from "@mark1russell7/layout-contract";
|
package/build/graph.d.ts
ADDED
|
@@ -0,0 +1,417 @@
|
|
|
1
|
+
import { n as Highlight } from "./highlight-BJ6xGp6V.js";
|
|
2
|
+
import { Point, Rect } from "@mark1russell7/layout-contract";
|
|
3
|
+
/**
|
|
4
|
+
* The camera of a flat picture: a zoom and the position of the origin.
|
|
5
|
+
* A point `p` of the picture shows at the screen point `p * k + (x, y)`. Each screen length is in CSS pixels.
|
|
6
|
+
*/
|
|
7
|
+
interface PictureView {
|
|
8
|
+
/** The screen position of the origin of the picture, from the left edge. */
|
|
9
|
+
readonly x: number;
|
|
10
|
+
/** The screen position of the origin of the picture, from the top edge. */
|
|
11
|
+
readonly y: number;
|
|
12
|
+
/** The zoom: the screen length of one unit of the picture. */
|
|
13
|
+
readonly k: number;
|
|
14
|
+
}
|
|
15
|
+
/** The limits of the zoom of a camera. */
|
|
16
|
+
interface ZoomLimits {
|
|
17
|
+
readonly min: number;
|
|
18
|
+
readonly max: number;
|
|
19
|
+
}
|
|
20
|
+
/** The default limits of the zoom. */
|
|
21
|
+
export declare const ZOOM_LIMITS: ZoomLimits;
|
|
22
|
+
/** The view that shows each point of the picture at its own position. */
|
|
23
|
+
export declare const UNIT_VIEW: PictureView;
|
|
24
|
+
/** This function gives a zoom in its limits. A zoom that is not a number gives the smallest zoom. */
|
|
25
|
+
export declare function clampZoom(k: number, limits?: ZoomLimits): number;
|
|
26
|
+
/** This function gives the point of the picture that shows at a screen point. */
|
|
27
|
+
export declare function toPicture(view: PictureView, screen: Point): Point;
|
|
28
|
+
/** This function gives the screen point that shows a point of the picture. */
|
|
29
|
+
export declare function toScreen(view: PictureView, point: Point): Point;
|
|
30
|
+
/** This function gives the screen rectangle that shows a rectangle of the picture. */
|
|
31
|
+
export declare function rectToScreen(view: PictureView, rect: Rect): Rect;
|
|
32
|
+
/** This function gives the view with the zoom `k` that shows the point `point` of the picture at the screen point `at`. */
|
|
33
|
+
export declare function viewAt(point: Point, at: Point, k: number): PictureView;
|
|
34
|
+
/** This function gives the view after a move of the picture by a screen distance. */
|
|
35
|
+
export declare function panView(view: PictureView, dx: number, dy: number): PictureView;
|
|
36
|
+
/**
|
|
37
|
+
* This function gives the view after a zoom by `factor`. The zoom stays in its limits.
|
|
38
|
+
* The screen point `at` shows the same point of the picture before and after the zoom.
|
|
39
|
+
*/
|
|
40
|
+
export declare function zoomView(view: PictureView, at: Point, factor: number, limits?: ZoomLimits): PictureView;
|
|
41
|
+
/** The positions of the two pointers of a pinch, in CSS pixels. */
|
|
42
|
+
type PointerPair = readonly [Point, Point];
|
|
43
|
+
/**
|
|
44
|
+
* This function gives the view after the two pointers of a pinch move from `before` to `after`.
|
|
45
|
+
*
|
|
46
|
+
* The zoom changes by the ratio of the two distances between the pointers.
|
|
47
|
+
* The point of the picture at the middle of the pointers stays at their middle.
|
|
48
|
+
* Thus each pointer keeps its point of the picture, if the pointers do not turn and the zoom is in its limits.
|
|
49
|
+
*/
|
|
50
|
+
export declare function pinchView(view: PictureView, before: PointerPair, after: PointerPair, limits?: ZoomLimits): PictureView;
|
|
51
|
+
/** The speed of the zoom of a wheel: the change of the natural logarithm of the zoom for one CSS pixel of the wheel. */
|
|
52
|
+
export declare const WHEEL_SPEED = .0015;
|
|
53
|
+
/** The height of one line of a wheel that gives its turn in lines, in CSS pixels. */
|
|
54
|
+
export declare const WHEEL_LINE = 16;
|
|
55
|
+
/** The factor of the speed of the wheel for a pinch on a touch pad. A browser gives such a pinch as a wheel with the key `Control`. */
|
|
56
|
+
export declare const WHEEL_PINCH = 10;
|
|
57
|
+
/**
|
|
58
|
+
* This function gives the factor of the zoom for one event of a wheel. A turn away from the person makes the picture larger.
|
|
59
|
+
*
|
|
60
|
+
* `deltaY` and `deltaMode` are the fields of the event. A mode of 1 has its turn in lines.
|
|
61
|
+
* `pinch` is the field `ctrlKey` of the event: a pinch on a touch pad has small turns, so its speed is higher.
|
|
62
|
+
*/
|
|
63
|
+
export declare function wheelFactor(deltaY: number, deltaMode?: number, pinch?: boolean): number;
|
|
64
|
+
/** The parts of a picture that a page covers, from each edge, in CSS pixels. */
|
|
65
|
+
interface Insets {
|
|
66
|
+
readonly top: number;
|
|
67
|
+
readonly right: number;
|
|
68
|
+
readonly bottom: number;
|
|
69
|
+
readonly left: number;
|
|
70
|
+
}
|
|
71
|
+
/** The smallest width and height of a free area, in CSS pixels. */
|
|
72
|
+
export declare const SMALLEST_AREA = 80;
|
|
73
|
+
/**
|
|
74
|
+
* This function gives the free area of a picture: the screen rectangle that the page does not cover.
|
|
75
|
+
* A camera shows a selection in this area, so a panel of the page does not hide it.
|
|
76
|
+
* The width and the height of the area are `SMALLEST_AREA` at least.
|
|
77
|
+
*/
|
|
78
|
+
export declare function freeArea(size: {
|
|
79
|
+
readonly width: number;
|
|
80
|
+
readonly height: number;
|
|
81
|
+
}, insets?: Partial<Insets>): Rect;
|
|
82
|
+
/** The default distance between a rectangle that a camera shows and each edge of the area, in CSS pixels. */
|
|
83
|
+
export declare const FIT_PADDING = 24;
|
|
84
|
+
/** The options of `fitRect`. */
|
|
85
|
+
interface FitOptions {
|
|
86
|
+
/** The distance between the rectangle and each edge of the area, in CSS pixels. The default is `FIT_PADDING`. */
|
|
87
|
+
readonly padding?: number | undefined;
|
|
88
|
+
/** The largest zoom of the result. The default is the largest zoom of the limits. */
|
|
89
|
+
readonly most?: number | undefined;
|
|
90
|
+
/** The limits of the zoom. The default is `ZOOM_LIMITS`. */
|
|
91
|
+
readonly limits?: ZoomLimits | undefined;
|
|
92
|
+
}
|
|
93
|
+
/**
|
|
94
|
+
* This function gives the view that shows a rectangle of the picture in an area of the screen, as large as the area permits.
|
|
95
|
+
* The middle of the rectangle is at the middle of the area. A rectangle with no size gets the largest zoom.
|
|
96
|
+
*/
|
|
97
|
+
export declare function fitRect(rect: Rect, area: Rect, options?: FitOptions): PictureView;
|
|
98
|
+
/**
|
|
99
|
+
* This function gives the limits of the zoom for a picture with the bounds `bounds`.
|
|
100
|
+
*
|
|
101
|
+
* The smallest zoom of the result shows all of the picture in the area, with a padding at each edge.
|
|
102
|
+
* A picture that fits at the smallest zoom of `limits` keeps `limits`. Thus a person can show all of a very large picture.
|
|
103
|
+
*/
|
|
104
|
+
export declare function zoomLimitsFor(bounds: Rect, area: Rect, limits?: ZoomLimits, padding?: number): ZoomLimits;
|
|
105
|
+
/** The length of a picture that stays in the free area when a person moves the picture, in CSS pixels. */
|
|
106
|
+
export declare const KEEP_IN_VIEW = 64;
|
|
107
|
+
/**
|
|
108
|
+
* This function gives the view that keeps a part of a rectangle of the picture in an area of the screen.
|
|
109
|
+
* A person who moves the picture then cannot lose it.
|
|
110
|
+
*
|
|
111
|
+
* `least` is the length of the rectangle that stays in the area on each axis, in CSS pixels.
|
|
112
|
+
* A rectangle that is smaller on the screen stays in the area fully. The zoom does not change.
|
|
113
|
+
* The result is `view` itself when the view keeps the rectangle.
|
|
114
|
+
*/
|
|
115
|
+
export declare function keepRect(view: PictureView, rect: Rect, area: Rect, least?: number): PictureView;
|
|
116
|
+
/** The options of `frameRects`. */
|
|
117
|
+
interface FrameOptions extends FitOptions {
|
|
118
|
+
/** The smallest zoom at which a person reads the content of a rectangle. */
|
|
119
|
+
readonly least: number;
|
|
120
|
+
}
|
|
121
|
+
/**
|
|
122
|
+
* This function gives the view for the first rectangle of a list that an area of the screen shows at the zoom `least` or more.
|
|
123
|
+
*
|
|
124
|
+
* Give the bounds of the largest group of boxes first, then the bounds of smaller groups.
|
|
125
|
+
* If no rectangle is small enough, the result has the zoom `least` and the middle of the last rectangle at the middle of the area.
|
|
126
|
+
* An empty list gives `undefined`.
|
|
127
|
+
*/
|
|
128
|
+
export declare function frameRects(rects: readonly Rect[], area: Rect, options: FrameOptions): PictureView | undefined;
|
|
129
|
+
/**
|
|
130
|
+
* This function tells if a view shows all of a rectangle of the picture in an area of the screen.
|
|
131
|
+
* `margin` is the smallest distance between the rectangle and each edge of the area, in CSS pixels.
|
|
132
|
+
*/
|
|
133
|
+
export declare function showsRect(view: PictureView, rect: Rect, area: Rect, margin?: number): boolean;
|
|
134
|
+
/** The options of `revealRects`. */
|
|
135
|
+
interface RevealOptions extends FrameOptions {
|
|
136
|
+
/** The smallest distance between a rectangle in view and each edge of the area, in CSS pixels. The default is 0. */
|
|
137
|
+
readonly margin?: number | undefined;
|
|
138
|
+
}
|
|
139
|
+
/**
|
|
140
|
+
* This function gives the view that shows a selection, and it keeps the view `view` when the selection is in view.
|
|
141
|
+
*
|
|
142
|
+
* The rectangles are the bounds of the groups of the selection, as for `frameRects`, the largest group first.
|
|
143
|
+
* The selection is in view when `view` has the zoom `least` or more, and shows all of the rectangle that `frameRects` selects.
|
|
144
|
+
* The result is then `view` itself, so a camera does not move for a click on a box that a person reads.
|
|
145
|
+
* In each other case, the result is the view of `frameRects`. An empty list gives `view`.
|
|
146
|
+
*/
|
|
147
|
+
export declare function revealRects(view: PictureView, rects: readonly Rect[], area: Rect, options: RevealOptions): PictureView;
|
|
148
|
+
/**
|
|
149
|
+
* This function gives the view at a part of the way between two views. `part` goes from 0 to 1.
|
|
150
|
+
*
|
|
151
|
+
* The zoom changes by an equal factor for each equal step, so a zoom has one speed in the picture.
|
|
152
|
+
* The way is a zoom at one screen point: the point of the picture that the two views show there stays there.
|
|
153
|
+
* Thus each point of the picture moves along a straight line of the screen, in one direction.
|
|
154
|
+
* Two views with one zoom give a straight move at one speed.
|
|
155
|
+
*/
|
|
156
|
+
export declare function viewBetween(from: PictureView, to: PictureView, part: number): PictureView;
|
|
157
|
+
/** A move of the camera of a flat picture from one view to a different view. */
|
|
158
|
+
interface PictureMove {
|
|
159
|
+
readonly from: PictureView;
|
|
160
|
+
readonly to: PictureView;
|
|
161
|
+
/** The time of the start of the move, in milliseconds. */
|
|
162
|
+
readonly start: number;
|
|
163
|
+
/** The time that the move takes, in milliseconds. */
|
|
164
|
+
readonly duration: number;
|
|
165
|
+
}
|
|
166
|
+
/** The view of a camera at one time of a move. */
|
|
167
|
+
interface PictureMoveStep {
|
|
168
|
+
readonly view: PictureView;
|
|
169
|
+
/** This value is true at the end of the move, and after it. */
|
|
170
|
+
readonly done: boolean;
|
|
171
|
+
}
|
|
172
|
+
/**
|
|
173
|
+
* This function gives the view of a camera at the time `now` of a move, in milliseconds.
|
|
174
|
+
* The move has a slow start and a slow end. A move with no duration is at its end immediately.
|
|
175
|
+
*/
|
|
176
|
+
export declare function pictureMoveAt(move: PictureMove, now: number): PictureMoveStep;
|
|
177
|
+
/** What an aim gets: the picture and the screen at the time of the aim. */
|
|
178
|
+
interface AimFrame {
|
|
179
|
+
/** The bounds of the content, in the unit of the picture. */
|
|
180
|
+
readonly bounds: Rect;
|
|
181
|
+
/** The free area of the picture on the screen, in CSS pixels. */
|
|
182
|
+
readonly area: Rect;
|
|
183
|
+
/** The view of the camera before the aim. */
|
|
184
|
+
readonly view: PictureView;
|
|
185
|
+
/** The limits of the zoom. */
|
|
186
|
+
readonly limits: ZoomLimits;
|
|
187
|
+
}
|
|
188
|
+
/**
|
|
189
|
+
* An aim of the camera of a flat picture: a function that gives the view for a picture and a screen.
|
|
190
|
+
* A stage asks the aim again after a change of the size of the picture, so the view stays correct.
|
|
191
|
+
*/
|
|
192
|
+
type PictureAim = (frame: AimFrame) => PictureView;
|
|
193
|
+
/** This function makes the aim that shows all of the picture, as large as the free area permits. */
|
|
194
|
+
export declare function aimAll(options?: FitOptions): PictureAim;
|
|
195
|
+
/**
|
|
196
|
+
* This function makes the aim that shows a group of boxes at a zoom that a person reads.
|
|
197
|
+
* The rectangles are the bounds of the groups, the largest group first: `frameRects` selects one. An empty list keeps the view.
|
|
198
|
+
*/
|
|
199
|
+
export declare function aimRects(rects: readonly Rect[], options: FrameOptions): PictureAim;
|
|
200
|
+
/**
|
|
201
|
+
* This function makes the aim that shows a selection, and keeps the view when the selection is in view.
|
|
202
|
+
* The rectangles are the bounds of the groups of the selection, the largest group first: `revealRects` selects one.
|
|
203
|
+
*/
|
|
204
|
+
export declare function aimReveal(rects: readonly Rect[], options: RevealOptions): PictureAim;
|
|
205
|
+
/** What a key does on a flat picture: it moves the camera to a view, or it shows a view by its name. */
|
|
206
|
+
type PictureKeyAction = {
|
|
207
|
+
readonly type: "move";
|
|
208
|
+
readonly to: PictureView;
|
|
209
|
+
} | {
|
|
210
|
+
readonly type: "view";
|
|
211
|
+
readonly view: string;
|
|
212
|
+
};
|
|
213
|
+
/** The keys of a flat picture. */
|
|
214
|
+
interface PictureKeyOptions {
|
|
215
|
+
/** The name of the view of the keys `Home` and `0`. */
|
|
216
|
+
readonly home: string;
|
|
217
|
+
/** The name of the view of each other key, for example `{ f: "focus" }`. A letter has no case. */
|
|
218
|
+
readonly views?: Readonly<Record<string, string>> | undefined;
|
|
219
|
+
/** The limits of the zoom. The default is `ZOOM_LIMITS`. */
|
|
220
|
+
readonly limits?: ZoomLimits | undefined;
|
|
221
|
+
}
|
|
222
|
+
/**
|
|
223
|
+
* This function gives the action of a key on a flat picture, or `undefined` for a key with no action.
|
|
224
|
+
*
|
|
225
|
+
* `area` is the part of the screen that shows the picture. `freeArea` gives it.
|
|
226
|
+
* An arrow key moves the camera by the part `KEY_PART` of the smaller side of the area.
|
|
227
|
+
* The keys `+` and `-` zoom at the middle of the area, by the factor of one step of a key on a 3D stage.
|
|
228
|
+
* The keys `Home` and `0` show the home view.
|
|
229
|
+
*/
|
|
230
|
+
export declare function pictureKeyAction(key: string, now: PictureView, area: Rect, options: PictureKeyOptions): PictureKeyAction | undefined;
|
|
231
|
+
/** The pointers that are down on a picture: a mouse button, a pen or each finger of a hand. */
|
|
232
|
+
interface Pointers {
|
|
233
|
+
/** The screen position of each pointer that is down, by the id of the pointer. */
|
|
234
|
+
readonly at: ReadonlyMap<number, Point>;
|
|
235
|
+
/** The position where the first pointer went down. */
|
|
236
|
+
readonly start: Point | undefined;
|
|
237
|
+
/** This value is true after a second pointer went down. The pointers then make no click. */
|
|
238
|
+
readonly many: boolean;
|
|
239
|
+
}
|
|
240
|
+
/** The pointers of a picture that no pointer is down on. */
|
|
241
|
+
export declare const NO_POINTERS: Pointers;
|
|
242
|
+
/** A finger moves more than a mouse between down and up. This is the distance of a click for a finger, in CSS pixels. */
|
|
243
|
+
export declare const TOUCH_CLICK_DISTANCE = 10;
|
|
244
|
+
/** This function gives the pointers after a pointer went down. The first pointer starts a possible click. */
|
|
245
|
+
export declare function pointerDown(pointers: Pointers, id: number, at: Point): Pointers;
|
|
246
|
+
/** The result of `pointerMove`: the pointers and the view after the move. */
|
|
247
|
+
interface PointerMoveResult {
|
|
248
|
+
readonly pointers: Pointers;
|
|
249
|
+
readonly view: PictureView;
|
|
250
|
+
}
|
|
251
|
+
/**
|
|
252
|
+
* This function gives the pointers and the view after a pointer moved.
|
|
253
|
+
*
|
|
254
|
+
* One pointer moves the picture, so the point of the picture below the pointer stays there.
|
|
255
|
+
* Two pointers make a pinch: `pinchView` gives the view. Three pointers or more do not change the view.
|
|
256
|
+
* A pointer that is not down changes nothing.
|
|
257
|
+
*/
|
|
258
|
+
export declare function pointerMove(pointers: Pointers, id: number, at: Point, view: PictureView, limits?: ZoomLimits): PointerMoveResult;
|
|
259
|
+
/** The result of `pointerUp`: the pointers that stay down, and the answer if the pointer made a click. */
|
|
260
|
+
interface PointerUpResult {
|
|
261
|
+
readonly pointers: Pointers;
|
|
262
|
+
/** This value is true when one pointer went down and up at almost the same position. */
|
|
263
|
+
readonly click: boolean;
|
|
264
|
+
}
|
|
265
|
+
/**
|
|
266
|
+
* This function gives the pointers after a pointer went up, and tells if the pointer made a click.
|
|
267
|
+
*
|
|
268
|
+
* A click is one pointer that went up not more than `limit` from its start, with no second pointer between.
|
|
269
|
+
* The default of `limit` is `CLICK_DISTANCE`. Use `TOUCH_CLICK_DISTANCE` for a finger.
|
|
270
|
+
*/
|
|
271
|
+
export declare function pointerUp(pointers: Pointers, id: number, at: Point, limit?: number): PointerUpResult;
|
|
272
|
+
/** This function gives the pointers after the browser stopped a pointer, for example for a gesture of the system. It makes no click. */
|
|
273
|
+
export declare function pointerCancel(pointers: Pointers, id: number): Pointers;
|
|
274
|
+
/** The record below the pointer of a flat picture: its name, and the value that the content gives for it. */
|
|
275
|
+
interface PicturePick<P> {
|
|
276
|
+
/** The name of the record. The highlights of the stage use this name. */
|
|
277
|
+
readonly record: string;
|
|
278
|
+
/** The value of the record for the page, for example its kind and its source. */
|
|
279
|
+
readonly value: P;
|
|
280
|
+
}
|
|
281
|
+
/** The position of a pointer on a flat picture, for the pick of a content. */
|
|
282
|
+
interface PickAt {
|
|
283
|
+
/** The point of the picture below the pointer. */
|
|
284
|
+
readonly point: Point;
|
|
285
|
+
/** The position of the pointer on the screen, in CSS pixels from the top left corner of the picture. */
|
|
286
|
+
readonly screen: Point;
|
|
287
|
+
/** The view of the camera. */
|
|
288
|
+
readonly view: PictureView;
|
|
289
|
+
/** The distance from the pointer at which a thin part is below the pointer, in CSS pixels. A finger has a larger distance than a mouse. */
|
|
290
|
+
readonly slack: number;
|
|
291
|
+
}
|
|
292
|
+
/** One picture of a flat stage, for the drawing of its content. */
|
|
293
|
+
interface PictureFrame {
|
|
294
|
+
/** The view of the camera. */
|
|
295
|
+
readonly view: PictureView;
|
|
296
|
+
/** The width of the picture, in CSS pixels. */
|
|
297
|
+
readonly width: number;
|
|
298
|
+
/** The height of the picture, in CSS pixels. */
|
|
299
|
+
readonly height: number;
|
|
300
|
+
/** The part of the picture that the page does not cover, in CSS pixels. */
|
|
301
|
+
readonly area: Rect;
|
|
302
|
+
/** The number of pixels of the canvas for one CSS pixel. */
|
|
303
|
+
readonly pixelRatio: number;
|
|
304
|
+
/** The time since the last picture, in seconds. */
|
|
305
|
+
readonly seconds: number;
|
|
306
|
+
/**
|
|
307
|
+
* This value is true for the first picture of a content, and for a person who asks for less motion.
|
|
308
|
+
* Each change then has no time: the content sets each value to its goal immediately.
|
|
309
|
+
*/
|
|
310
|
+
readonly settle: boolean;
|
|
311
|
+
}
|
|
312
|
+
/**
|
|
313
|
+
* The content of a flat stage: what the stage draws, and what the stage asks of it.
|
|
314
|
+
* `P` is the type of the value of a pick, and `T` is the type of the theme.
|
|
315
|
+
*/
|
|
316
|
+
interface PictureContent<P, T> {
|
|
317
|
+
/** The bounds of the content, in the unit of the picture. The views and the limits of the camera come from them. */
|
|
318
|
+
readonly bounds: Rect;
|
|
319
|
+
/** This function tells if the content has a record with a name. */
|
|
320
|
+
has(record: string): boolean;
|
|
321
|
+
/** This function gives the record below a pointer, or `undefined` for no record. */
|
|
322
|
+
pick(at: PickAt): PicturePick<P> | undefined;
|
|
323
|
+
/**
|
|
324
|
+
* This function draws the content on a clear canvas. The unit of the context is the CSS pixel: the view is in the frame.
|
|
325
|
+
* `highlight` gives the highlight of a record. The function gives true while a part continues to change.
|
|
326
|
+
* The stage then makes the next picture.
|
|
327
|
+
*/
|
|
328
|
+
draw(context: CanvasRenderingContext2D, frame: PictureFrame, theme: T, highlight: (record: string) => Highlight): boolean;
|
|
329
|
+
/** This function releases what the content keeps, for example its images. */
|
|
330
|
+
dispose?(): void;
|
|
331
|
+
}
|
|
332
|
+
/** The options of a flat stage. */
|
|
333
|
+
interface PictureStageOptions<P, T> {
|
|
334
|
+
/** The first content. The stage disposes each content that it gets. */
|
|
335
|
+
readonly content: PictureContent<P, T>;
|
|
336
|
+
readonly theme: T;
|
|
337
|
+
/** The name of the picture for a screen reader. */
|
|
338
|
+
readonly label: string;
|
|
339
|
+
/** The views of the stage, each with a name. The view `all` shows all of the picture, if the options do not give a different one. */
|
|
340
|
+
readonly views?: Readonly<Record<string, PictureAim>> | undefined;
|
|
341
|
+
/** The name of the first view. The keys `Home` and `0` show it. The default is `all`. */
|
|
342
|
+
readonly home?: string | undefined;
|
|
343
|
+
/** The name of the view of a key, for example `{ f: "focus" }`. A letter has no case. */
|
|
344
|
+
readonly keys?: Readonly<Record<string, string>> | undefined;
|
|
345
|
+
/** The limits of the zoom. The default is `ZOOM_LIMITS`. A very large picture gets a smaller least zoom, so a person can show all of it. */
|
|
346
|
+
readonly limits?: ZoomLimits | undefined;
|
|
347
|
+
/** The parts of the picture that the page covers, from each edge, in CSS pixels. */
|
|
348
|
+
readonly insets?: Partial<Insets> | undefined;
|
|
349
|
+
/**
|
|
350
|
+
* When the wheel changes the zoom. With `in-use`, the wheel moves the page until a person uses the picture.
|
|
351
|
+
* With `always`, the wheel changes the zoom at each time. The default is `in-use`. A pinch on a touch pad changes the zoom always.
|
|
352
|
+
*/
|
|
353
|
+
readonly wheel?: "always" | "in-use" | undefined;
|
|
354
|
+
/** The stage starts this function when the pointer goes to a different record, or to no record. */
|
|
355
|
+
readonly onHover?: ((pick: P | undefined) => void) | undefined;
|
|
356
|
+
/** The stage starts this function when a person selects a record with the pointer, or selects no record. */
|
|
357
|
+
readonly onSelect?: ((pick: P | undefined) => void) | undefined;
|
|
358
|
+
/** The stage starts this function after a change of the view, one time for each picture at most. */
|
|
359
|
+
readonly onView?: ((view: PictureView) => void) | undefined;
|
|
360
|
+
}
|
|
361
|
+
/** A flat stage in a page: one canvas with a camera that a person moves, and one content. */
|
|
362
|
+
interface PictureStage<P, T> {
|
|
363
|
+
/** The canvas of the stage. It is in the container. */
|
|
364
|
+
readonly canvas: HTMLCanvasElement;
|
|
365
|
+
/** This function shows a different content, and disposes the old content. The view stays if a person moved it. */
|
|
366
|
+
setContent(content: PictureContent<P, T>): void;
|
|
367
|
+
/** This function changes the colors. */
|
|
368
|
+
setTheme(theme: T): void;
|
|
369
|
+
/** This function moves the camera to a view: a name of the options, or an aim. `animate` has the default true. */
|
|
370
|
+
setView(view: string | PictureAim, animate?: boolean): void;
|
|
371
|
+
/** This function tells the stage which parts of the picture the page covers. The camera goes to its view again if no person moved it. */
|
|
372
|
+
setInsets(insets: Partial<Insets>): void;
|
|
373
|
+
/** This function gives the view of the camera. */
|
|
374
|
+
view(): PictureView;
|
|
375
|
+
/** This function gives the part of the picture that the page does not cover, in CSS pixels. */
|
|
376
|
+
area(): Rect;
|
|
377
|
+
/** This function changes the zoom by a factor, at the middle of the free area. Use it for the buttons of a page. `animate` has the default true. */
|
|
378
|
+
zoomBy(factor: number, animate?: boolean): void;
|
|
379
|
+
/** This function highlights records by their names, as the pointer does. An empty list removes the highlights. */
|
|
380
|
+
highlight(records: readonly string[]): void;
|
|
381
|
+
/** This function selects one record by its name, or no record. It does not start `onSelect`. */
|
|
382
|
+
select(record: string | undefined): void;
|
|
383
|
+
/** This function makes a new picture. Use it after a change of the content. */
|
|
384
|
+
refresh(): void;
|
|
385
|
+
/** This function removes the canvas, and disposes the content. */
|
|
386
|
+
dispose(): void;
|
|
387
|
+
}
|
|
388
|
+
/** The distance from a mouse at which a thin part is below the pointer, in CSS pixels. */
|
|
389
|
+
export declare const PICK_SLACK = 5;
|
|
390
|
+
/** The distance from a finger or a pen at which a thin part is below the pointer, in CSS pixels. */
|
|
391
|
+
export declare const TOUCH_PICK_SLACK = 12;
|
|
392
|
+
/** The factor of the zoom for a double click. */
|
|
393
|
+
export declare const DOUBLE_CLICK_ZOOM = 2;
|
|
394
|
+
/**
|
|
395
|
+
* This function makes a flat stage in a container of a page. The stage fills the container, so give the container a size.
|
|
396
|
+
*
|
|
397
|
+
* A person moves the picture with a drag, and changes the zoom with the wheel, with two fingers or with a double click.
|
|
398
|
+
* A click selects the record below the pointer. With the keyboard, the arrow keys move the camera, `+` and `-` change the zoom,
|
|
399
|
+
* and `Home` shows the first view. The stage makes a picture only after a change.
|
|
400
|
+
*
|
|
401
|
+
* The function gives `undefined` when the browser gives no 2D context for a canvas. It does not throw.
|
|
402
|
+
*/
|
|
403
|
+
export declare function createPictureStage<P, T>(container: HTMLElement, options: PictureStageOptions<P, T>): PictureStage<P, T> | undefined;
|
|
404
|
+
/**
|
|
405
|
+
* This function makes one content from a list of contents, for a flat stage that shows them together.
|
|
406
|
+
* An example is a layer of boxes below a layer of routes and a layer of labels.
|
|
407
|
+
*
|
|
408
|
+
* - The first content gives the bounds: the views and the limits of the camera come from it.
|
|
409
|
+
* - The stack draws the contents in their sequence, so the last content is on top.
|
|
410
|
+
* - A pick asks the last content first. The first record that a content gives is the record.
|
|
411
|
+
* - A record that two contents have is one record: each of them gets its highlight.
|
|
412
|
+
* - A content does not get the state of the canvas of an earlier content: the stack restores it.
|
|
413
|
+
* - The stage disposes the stack, and the stack disposes each content.
|
|
414
|
+
*/
|
|
415
|
+
export declare function stackPictureContents<P, T>(contents: readonly [PictureContent<P, T>, ...PictureContent<P, T>[]]): PictureContent<P, T>;
|
|
416
|
+
export type { AimFrame, FitOptions, FrameOptions, Insets, PickAt, PictureAim, PictureContent, PictureFrame, PictureKeyAction, PictureKeyOptions, PictureMove, PictureMoveStep, PicturePick, PictureStage, PictureStageOptions, PictureView, PointerMoveResult, PointerPair, PointerUpResult, Pointers, RevealOptions, ZoomLimits };
|
|
417
|
+
//# sourceMappingURL=graph.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"graph.d.ts","names":[],"sources":["../src/graph/camera.ts","../src/graph/aim.ts","../src/graph/keys.ts","../src/graph/pointers.ts","../src/graph/stage.ts","../src/graph/stack.ts"],"mappings":"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"}
|