@vinena/knobs 0.7.1 → 0.7.2
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/CHANGELOG.md +5 -0
- package/dist/{elementsview-mcg6d5zp.js → elementsview-1bar694x.js} +2 -2
- package/dist/{elementsview-mwr1s17z.js → elementsview-p2wc9b0s.js} +2 -2
- package/dist/engine/bandmedia.d.ts +119 -0
- package/dist/engine/browserui.d.ts +3 -1
- package/dist/engine/pageshot.d.ts +24 -4
- package/dist/engine/safaridraw.d.ts +24 -3
- package/dist/engine/underbar.d.ts +26 -7
- package/dist/{framekit-wyppj1se.js → framekit-n57ts9zt.js} +937 -70
- package/dist/{framekit-4v7nc3ea.js → framekit-wqp811a2.js} +937 -70
- package/dist/{index-bgzyc7rz.js → index-b8cnnbpr.js} +3 -3
- package/dist/{index-c1t6knbf.js → index-cfrnrg24.js} +3 -3
- package/dist/{index-82y8x8vv.js → index-j8hrzag1.js} +2 -2
- package/dist/{index-3s4v7gw5.js → index-pvknvvkw.js} +3 -3
- package/dist/{index-cqymjce4.js → index-qz04adp5.js} +3 -3
- package/dist/{index-a23nv5j4.js → index-t7a07nm9.js} +2 -2
- package/dist/index.global.js +183 -166
- package/dist/index.js +7 -7
- package/dist/{react-7tzwahsm.js → react-0tbd51s3.js} +2 -2
- package/dist/{react-ppyj3fg2.js → react-881wvm1z.js} +2 -2
- package/dist/{react-wzd3cfg8.js → react-pf7fc2f3.js} +3 -3
- package/dist/{react-tet7swk2.js → react-zj0dbpdg.js} +3 -3
- package/dist/react.js +7 -7
- package/dist/{storageview-2rvwk0v7.js → storageview-5tvmca8y.js} +3 -3
- package/dist/{storageview-6vq7nz02.js → storageview-ec52x60p.js} +3 -3
- package/package.json +2 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,10 @@
|
|
|
1
1
|
# changelog
|
|
2
2
|
|
|
3
|
+
## 0.7.2
|
|
4
|
+
|
|
5
|
+
- Safari's bottom bar in the phone frame shows the whole host: the address shrinks to fit, then fades at its start, as Safari does, with no "…"
|
|
6
|
+
- the page under Safari's bottom bar shows its pictures and videos, not a blank or cut copy
|
|
7
|
+
|
|
3
8
|
## 0.7.1
|
|
4
9
|
|
|
5
10
|
- new names, beside the old ones, which still work for now:
|
|
@@ -98,10 +98,10 @@ import {
|
|
|
98
98
|
import {
|
|
99
99
|
getState,
|
|
100
100
|
subscribe
|
|
101
|
-
} from "./react-
|
|
101
|
+
} from "./react-881wvm1z.js";
|
|
102
102
|
import {
|
|
103
103
|
isMac
|
|
104
|
-
} from "./react-
|
|
104
|
+
} from "./react-zj0dbpdg.js";
|
|
105
105
|
import {
|
|
106
106
|
comboLabel,
|
|
107
107
|
isDevknobs,
|
|
@@ -97,10 +97,10 @@ import {
|
|
|
97
97
|
import {
|
|
98
98
|
getState,
|
|
99
99
|
subscribe
|
|
100
|
-
} from "./index-
|
|
100
|
+
} from "./index-t7a07nm9.js";
|
|
101
101
|
import {
|
|
102
102
|
isMac
|
|
103
|
-
} from "./index-
|
|
103
|
+
} from "./index-b8cnnbpr.js";
|
|
104
104
|
import {
|
|
105
105
|
comboLabel,
|
|
106
106
|
isDevknobs,
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
import { type FitStyle, type Media } from "./pageshot";
|
|
2
|
+
/** A stretch of the document, from `top` to `bottom`, in its css px. */
|
|
3
|
+
export interface Span {
|
|
4
|
+
top: number;
|
|
5
|
+
bottom: number;
|
|
6
|
+
}
|
|
7
|
+
/** The stretch of the document whose pictures are read: the band `band` px tall under the viewport, and `REACH` past it each way. */
|
|
8
|
+
export declare function bandSpan(scrollY: number, innerHeight: number, band: number): Span;
|
|
9
|
+
/** Is the band, `band` px tall under the viewport, still inside `span`? */
|
|
10
|
+
export declare function inSpan(span: Span, scrollY: number, innerHeight: number, band: number): boolean;
|
|
11
|
+
/** Does a box at `rect` in the viewport, scrolled `scrollY`, meet `span`? Only one with an area does. */
|
|
12
|
+
export declare function meets(rect: {
|
|
13
|
+
top: number;
|
|
14
|
+
bottom: number;
|
|
15
|
+
width: number;
|
|
16
|
+
height: number;
|
|
17
|
+
}, scrollY: number, span: Span): boolean;
|
|
18
|
+
/**
|
|
19
|
+
* The px a picture `media` px as made is read at, to show in a box `wide` by
|
|
20
|
+
* `tall` css px at `ratio` device px each: no more than it has, nor than the
|
|
21
|
+
* box shows of it at most, as it covers the box, nor than `LARGEST`.
|
|
22
|
+
*/
|
|
23
|
+
export declare function readSize(media: {
|
|
24
|
+
width: number;
|
|
25
|
+
height: number;
|
|
26
|
+
}, wide: number, tall: number, ratio: number): {
|
|
27
|
+
width: number;
|
|
28
|
+
height: number;
|
|
29
|
+
};
|
|
30
|
+
/**
|
|
31
|
+
* A picture `width` by `height` px as made, of `data`, stretched over it: it
|
|
32
|
+
* lays out as the page's picture does, however small `data` was read, and
|
|
33
|
+
* stretches as a picture does where the page fills a box of another shape.
|
|
34
|
+
*/
|
|
35
|
+
export declare function sizedPicture(data: string, width: number, height: number, rendering?: string): string;
|
|
36
|
+
/** Let go of the pictures read and of those made to read them by. */
|
|
37
|
+
export declare function forgetPixels(): void;
|
|
38
|
+
/** Is `address`, taken against `base`, of `origin`? A same-origin picture is read as it is, with no CORS to ask for. */
|
|
39
|
+
export declare function sameOrigin(address: string, base: string, origin: string): boolean;
|
|
40
|
+
/** `value`, a list such as computed backgrounds are, cut at the commas outside its brackets. */
|
|
41
|
+
export declare function layersOf(value: string): string[];
|
|
42
|
+
/** The address of a layer that is one `url(...)`, or null for a gradient, `none` or anything else. */
|
|
43
|
+
export declare function urlOf(layer: string): string | null;
|
|
44
|
+
/** A box in the document, in its css px. */
|
|
45
|
+
export interface Box {
|
|
46
|
+
left: number;
|
|
47
|
+
top: number;
|
|
48
|
+
width: number;
|
|
49
|
+
height: number;
|
|
50
|
+
}
|
|
51
|
+
/** A picture the frame may not read, where it shows in the document, fitted by `style`, and the canvas made to draw it from, to let go of once drawn. */
|
|
52
|
+
export interface Unread {
|
|
53
|
+
media: Media;
|
|
54
|
+
rect: Box;
|
|
55
|
+
style: FitStyle;
|
|
56
|
+
made?: HTMLCanvasElement;
|
|
57
|
+
/** The box of what holds it and cuts it off, and the radius of its corners, where something does. */
|
|
58
|
+
clip?: {
|
|
59
|
+
rect: Box;
|
|
60
|
+
radius: number;
|
|
61
|
+
};
|
|
62
|
+
/** Does something else of the page show over it, to draw back over it? */
|
|
63
|
+
covered?: boolean;
|
|
64
|
+
/** The video it is, where it plays, to draw again at each of its frames. */
|
|
65
|
+
live?: HTMLVideoElement;
|
|
66
|
+
}
|
|
67
|
+
/** What goes into the copy of the page near the band, and what is drawn over it. */
|
|
68
|
+
export interface BandMedia {
|
|
69
|
+
/** For each element whose pictures are read: what to set on its copy. */
|
|
70
|
+
fills: Map<Element, (copy: Element) => void>;
|
|
71
|
+
/** What the frame may not read, in the order to draw it. */
|
|
72
|
+
unread: Unread[];
|
|
73
|
+
/** What of the page shows over what the frame may not read, drawn back over it. */
|
|
74
|
+
above: Set<Element>;
|
|
75
|
+
}
|
|
76
|
+
/**
|
|
77
|
+
* The pictures, videos, drawings and background pictures of the page in
|
|
78
|
+
* `doc` that meet `span`, read for its copy, the page scrolled `scrollY`
|
|
79
|
+
* down the copy. `loaded` is told when a background picture comes that was
|
|
80
|
+
* not there yet.
|
|
81
|
+
*/
|
|
82
|
+
export declare function bandMedia(doc: Document, view: Window, span: Span, loaded: () => void, scrollY?: number): BandMedia;
|
|
83
|
+
/** What the frame may not read near the band, or a video that plays there, drawn by hand, and the stretch of the document it covers. */
|
|
84
|
+
export interface Overlay {
|
|
85
|
+
canvas: HTMLCanvasElement;
|
|
86
|
+
span: Span;
|
|
87
|
+
/** The document's width in css px, and the canvas's px to a css px. */
|
|
88
|
+
width: number;
|
|
89
|
+
ratio: number;
|
|
90
|
+
/** The videos on it that play, to draw again at each of their frames. */
|
|
91
|
+
live: Unread[];
|
|
92
|
+
/**
|
|
93
|
+
* What of the page shows over it, to draw back over it once decoded: a
|
|
94
|
+
* drawing of the copy with all else hidden, and the pictures it shows over.
|
|
95
|
+
*/
|
|
96
|
+
above: {
|
|
97
|
+
src: string;
|
|
98
|
+
parts: Unread[];
|
|
99
|
+
} | null;
|
|
100
|
+
}
|
|
101
|
+
/**
|
|
102
|
+
* Draw `unread`, in a document `width` css px wide, on a canvas over `span` of
|
|
103
|
+
* it, `ratio` px to its css px, or null where there is nothing to draw. Only
|
|
104
|
+
* shown, never read, so a picture from another origin draws on it too.
|
|
105
|
+
* `above`, a drawing of what of the page shows over those covered, is drawn
|
|
106
|
+
* back over them with `drawAbove`.
|
|
107
|
+
*/
|
|
108
|
+
export declare function overlayOf(unread: Unread[], span: Span, width: number, ratio: number, above?: string | null): Overlay | null;
|
|
109
|
+
/**
|
|
110
|
+
* `image`, the drawing `overlay.above` names, drawn once on a canvas as large
|
|
111
|
+
* as the overlay, over the same stretch: a video that plays has it drawn back
|
|
112
|
+
* over each of its frames, which the drawing itself is too large to be at
|
|
113
|
+
* that pace. Null where it will not draw.
|
|
114
|
+
*/
|
|
115
|
+
export declare function raiseOf(overlay: Overlay, image: CanvasImageSource): HTMLCanvasElement | null;
|
|
116
|
+
/** Draw `raised`, from `raiseOf`, over the overlay where what it shows covers a picture drawn on it: over `only` alone where given. */
|
|
117
|
+
export declare function drawAbove(overlay: Overlay, raised: CanvasImageSource, only?: Unread): void;
|
|
118
|
+
/** Draw `one`, a video that plays on the overlay, again as it shows now, and `raised`, what shows over it, back over it. */
|
|
119
|
+
export declare function redrawLive(overlay: Overlay, one: Unread, raised: CanvasImageSource | null): void;
|
|
@@ -164,13 +164,15 @@ export interface Shape extends Rect {
|
|
|
164
164
|
marks: Mark[];
|
|
165
165
|
/**
|
|
166
166
|
* Where the shape shows the domain: its center in Safari, its start in
|
|
167
|
-
* Chrome. A pill's width is the domain's advance and `pad`.
|
|
167
|
+
* Chrome. A pill's width is the domain's advance and `pad`. An address's
|
|
168
|
+
* text keeps `clear` from the center of each glyph at its ends.
|
|
168
169
|
*/
|
|
169
170
|
text?: {
|
|
170
171
|
x: number;
|
|
171
172
|
y: number;
|
|
172
173
|
size: number;
|
|
173
174
|
pad?: number;
|
|
175
|
+
clear?: number;
|
|
174
176
|
};
|
|
175
177
|
}
|
|
176
178
|
/**
|
|
@@ -1,9 +1,18 @@
|
|
|
1
|
+
/** The elements of a page that show a picture of their own, which a drawing of the page cannot load and a rough one draws by hand. */
|
|
2
|
+
export declare const MEDIA = "img, video, canvas";
|
|
3
|
+
export type MediaNode = HTMLImageElement | HTMLVideoElement | HTMLCanvasElement;
|
|
1
4
|
/** A picture, video or drawing of the page that can be drawn now, and its size as made, in its own px. */
|
|
2
|
-
interface Media {
|
|
5
|
+
export interface Media {
|
|
3
6
|
source: CanvasImageSource;
|
|
4
7
|
width: number;
|
|
5
8
|
height: number;
|
|
9
|
+
/** How many of the source's px one of its px as made takes, where they differ: 1 where unset. */
|
|
10
|
+
scale?: number;
|
|
6
11
|
}
|
|
12
|
+
/** What `node` shows, where it has it by now: a picture that has loaded, a video with a frame, a drawing with a size. */
|
|
13
|
+
export declare function mediaOf(node: MediaNode): Media | null;
|
|
14
|
+
/** What of an element's computed style fits a picture into its box. */
|
|
15
|
+
export type FitStyle = Pick<CSSStyleDeclaration, "borderLeftWidth" | "borderRightWidth" | "borderTopWidth" | "borderBottomWidth" | "paddingLeft" | "paddingRight" | "paddingTop" | "paddingBottom" | "objectFit" | "objectPosition" | "borderTopLeftRadius" | "borderTopRightRadius" | "borderBottomRightRadius" | "borderBottomLeftRadius" | "imageRendering">;
|
|
7
16
|
/**
|
|
8
17
|
* Draw one of the page's pictures where its element shows it, `rect`, as its
|
|
9
18
|
* `style` fits it in: inside the border and padding, cut and placed as
|
|
@@ -12,7 +21,7 @@ interface Media {
|
|
|
12
21
|
* drawn into the element's box whole is squeezed wherever the page cuts it
|
|
13
22
|
* to cover the box, or leaves room around it.
|
|
14
23
|
*/
|
|
15
|
-
export declare function drawMedia(pen: CanvasRenderingContext2D, media: Media, rect: DOMRect, style:
|
|
24
|
+
export declare function drawMedia(pen: CanvasRenderingContext2D, media: Media, rect: Pick<DOMRect, "left" | "top" | "width" | "height">, style: FitStyle): void;
|
|
16
25
|
/**
|
|
17
26
|
* What the page's pictures show now, which no change to the page tells of: a
|
|
18
27
|
* picture another source was picked for, or one that has loaded since, each
|
|
@@ -101,11 +110,23 @@ export declare function marginPlace(shot: number, padded: number): {
|
|
|
101
110
|
};
|
|
102
111
|
/** A picture of nothing, `width` by `height` px as made, as data: it holds a picture's place and draws none. */
|
|
103
112
|
export declare function blankUrl(width: number, height: number): string;
|
|
113
|
+
/** Does an element with `overflow` on one axis, as it computes, cut off what overflows it there? */
|
|
114
|
+
export declare function cuts(overflow: string): boolean;
|
|
115
|
+
/**
|
|
116
|
+
* The element of the page in `doc` whose overflow the viewport takes: the
|
|
117
|
+
* root, or the body where the root's overflow is visible both ways, or null
|
|
118
|
+
* where it has no body. The page lays that element out as if its overflow
|
|
119
|
+
* were visible. Its copy in a drawing is no document's root, so it would
|
|
120
|
+
* cut off what overflows it, or make a scroll container of it.
|
|
121
|
+
*/
|
|
122
|
+
export declare function viewportOverflow(doc: Document, view: Window): Element | null;
|
|
104
123
|
/**
|
|
105
124
|
* The page in `frame`, copied as it is now for `paintPage`, or null where it
|
|
106
125
|
* is out of reach. What `leave` picks of the page is left out of the copy.
|
|
126
|
+
* `each` is told of each element of the page and its copy, before anything is
|
|
127
|
+
* taken out of the copy.
|
|
107
128
|
*/
|
|
108
|
-
export declare function copyPage(frame: HTMLIFrameElement, leave?: (node: Element) => boolean): Element | null;
|
|
129
|
+
export declare function copyPage(frame: HTMLIFrameElement, leave?: (node: Element) => boolean, each?: (node: Element, copy: Element) => void): Element | null;
|
|
109
130
|
/** `svg` as a data url, any lone half of a pair made U+FFFD first, as encoding one throws. */
|
|
110
131
|
export declare function svgUrl(svg: string): string;
|
|
111
132
|
/**
|
|
@@ -152,4 +173,3 @@ export declare function paintPage(frame: HTMLIFrameElement, glass: HTMLElement,
|
|
|
152
173
|
width: number;
|
|
153
174
|
height: number;
|
|
154
175
|
}, color: string, copy: Element): Promise<HTMLCanvasElement | null>;
|
|
155
|
-
export {};
|
|
@@ -2,6 +2,8 @@ import type { Actions, Look, Painted } from "./browserkit";
|
|
|
2
2
|
import { type Color } from "./color";
|
|
3
3
|
import { type Bars, type Shape } from "./browserui";
|
|
4
4
|
import type { Rect } from "./mock";
|
|
5
|
+
/** The domain's padding above and below, in em: its box then holds the system font's ascent and descent, 1.23 em at most. */
|
|
6
|
+
export declare const DOMAIN_PAD = 0.15;
|
|
5
7
|
export declare const SAFARI_CSS: string;
|
|
6
8
|
/**
|
|
7
9
|
* The status bar's glyphs, measured on the iOS 27.0 simulator in pt, on the
|
|
@@ -130,8 +132,27 @@ export declare const DUO_GLYPHS: {
|
|
|
130
132
|
};
|
|
131
133
|
/** The address as Safari shows it: the host alone, without its port. */
|
|
132
134
|
export declare function domainOf(host: string): string;
|
|
133
|
-
/**
|
|
134
|
-
|
|
135
|
+
/**
|
|
136
|
+
* The room the domain has in `shape`, in px, on a screen `width` wide: in
|
|
137
|
+
* the minimized pill, the domain's advance at the pill's size, or as much as
|
|
138
|
+
* the pill gets PILL_MARGIN in from the screen's sides; in an address, as
|
|
139
|
+
* wide as it goes centered, MARK_CLEAR clear of the glyphs at its ends.
|
|
140
|
+
*/
|
|
141
|
+
export declare function domainRoom(shape: Shape, host: string, width: number): number;
|
|
142
|
+
/** How the domain is shown in a shape: its size, its room, and is its start cut? */
|
|
143
|
+
export interface DomainFit {
|
|
144
|
+
size: number;
|
|
145
|
+
room: number;
|
|
146
|
+
cut: boolean;
|
|
147
|
+
}
|
|
148
|
+
/**
|
|
149
|
+
* How Safari fits the domain in `shape` on a screen `width` wide: the pill at
|
|
150
|
+
* its own size, cut where the screen's sides clamp it; an address at 17, shrunk
|
|
151
|
+
* to its room down to FIELD_LEAST, and cut where it is still too wide there.
|
|
152
|
+
*/
|
|
153
|
+
export declare function domainFit(shape: Shape, host: string, width: number): DomainFit;
|
|
154
|
+
/** The minimized domain pill's box on a screen `width` wide: its domain's room and the pill's either side. */
|
|
155
|
+
export declare function pillBox(pill: Shape, host: string, width: number): Rect;
|
|
135
156
|
/** How Safari's glass looks over a color of the page. */
|
|
136
157
|
export interface Tint {
|
|
137
158
|
/** The glass's color where the page under it is that color all over. */
|
|
@@ -166,7 +187,7 @@ export declare function scrimOver(node: HTMLElement, mini: Bars, look: Look): Co
|
|
|
166
187
|
* Safari's bars, drawn once for both states (the plus to menu morph of
|
|
167
188
|
* transitions.dev). The address capsule, Bottom's card or Top's address bar
|
|
168
189
|
* is one surface that becomes the minimized pill: its box and corners tween,
|
|
169
|
-
* the domain glides and scales from
|
|
190
|
+
* the domain glides and scales from its fitted size to the pill's in it, and the page
|
|
170
191
|
* menu, reload and Bottom's buttons fade out as an icon swap. The capsules
|
|
171
192
|
* beside it fade and drift 10 px.
|
|
172
193
|
*/
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { type Overlay, type Span } from "./bandmedia";
|
|
1
2
|
import { type Look } from "./browserkit";
|
|
2
3
|
import type { Bars } from "./browserui";
|
|
3
4
|
import type { Rect } from "./mock";
|
|
@@ -9,12 +10,16 @@ import type { Rect } from "./mock";
|
|
|
9
10
|
* viewport's bottom edge: one picture of the whole document, drawn by the
|
|
10
11
|
* browser through an svg, which a scroll only moves. It is pictured again
|
|
11
12
|
* when the page changes, at most as often as keeps its cost to a tenth of
|
|
12
|
-
* the time
|
|
13
|
-
*
|
|
14
|
-
*
|
|
15
|
-
*
|
|
13
|
+
* the time, and when the band scrolls past the pictures read for it. The
|
|
14
|
+
* pictures, videos and drawings near the band are in it as they show, which
|
|
15
|
+
* a drawing of the copy could not load (see `bandmedia.ts`). What is pinned
|
|
16
|
+
* to the screen is left out of it, as it stays in the viewport on the phone,
|
|
17
|
+
* and a fixed footer's color is carried down instead, by the screen's fill
|
|
18
|
+
* under the band. A page out of reach shows that fill too. A page that
|
|
19
|
+
* scrolls in its body, not in its document, shows its body's content past
|
|
20
|
+
* the viewport, as far down as the body is scrolled.
|
|
16
21
|
*/
|
|
17
|
-
export declare const UNDERBAR_CSS = "\n.underbar {\n position: absolute;\n overflow: hidden;\n pointer-events: none;\n transform-origin: 0 0;\n}\n.underbar[hidden] { display: none; }\n.underbar > img {\n position: absolute;\n left: 0;\n top: 0;\n max-width: none;\n will-change: transform;\n}\n";
|
|
22
|
+
export declare const UNDERBAR_CSS = "\n.underbar {\n position: absolute;\n overflow: hidden;\n pointer-events: none;\n transform-origin: 0 0;\n}\n.underbar[hidden] { display: none; }\n.underbar > img,\n.underbar > canvas {\n position: absolute;\n left: 0;\n top: 0;\n max-width: none;\n will-change: transform;\n}\n";
|
|
18
23
|
/** The band under the viewport, in the screen's css px, or null where the page reaches the screen's bottom. */
|
|
19
24
|
export declare function bandRect(page: Rect | null, height: number): Rect | null;
|
|
20
25
|
/**
|
|
@@ -35,19 +40,33 @@ export declare function bandShift(scrollY: number, innerHeight: number, scale: n
|
|
|
35
40
|
* whole document, which would stretch them.
|
|
36
41
|
*/
|
|
37
42
|
export declare function viewportUnits(css: string, height: number): string;
|
|
43
|
+
/**
|
|
44
|
+
* The body of the page in `doc`, where the page scrolls in it and not in its
|
|
45
|
+
* document: the root's overflow went to the viewport, so the body keeps its
|
|
46
|
+
* own, which scrolls up and down. Null where the document scrolls.
|
|
47
|
+
*/
|
|
48
|
+
export declare function bodyScroller(doc: Document, view: Window): HTMLElement | null;
|
|
49
|
+
/** How far down the page in `doc` is scrolled, in its document and in a body that scrolls, in css px. */
|
|
50
|
+
export declare function scrollOf(doc: Document, view: Window): number;
|
|
38
51
|
/** The picture of a page as an svg, `width` by `height` css px, and its markup's address. */
|
|
39
52
|
export interface Picture {
|
|
40
53
|
src: string;
|
|
41
54
|
width: number;
|
|
42
55
|
height: number;
|
|
56
|
+
/** The stretch of the document whose pictures it shows, or null where the page has none to show. */
|
|
57
|
+
span: Span | null;
|
|
58
|
+
/** What the frame may not read near the band, drawn by hand over it. */
|
|
59
|
+
overlay: Overlay | null;
|
|
43
60
|
}
|
|
44
61
|
/**
|
|
45
62
|
* The whole page in `frame` as an svg as tall as the document, laid out as
|
|
46
63
|
* the frame lays it out, or null where it is out of reach. Its viewport
|
|
47
64
|
* lengths and the root's height are the frame's, and what is fixed to the
|
|
48
|
-
* screen is left out.
|
|
65
|
+
* screen is left out. The pictures near the band, `band` of the document's
|
|
66
|
+
* css px tall under the viewport, are in it, and `loaded` is told when one
|
|
67
|
+
* comes that was not there yet.
|
|
49
68
|
*/
|
|
50
|
-
export declare function pictureOf(frame: HTMLIFrameElement): Picture | null;
|
|
69
|
+
export declare function pictureOf(frame: HTMLIFrameElement, band?: number, loaded?: () => void): Picture | null;
|
|
51
70
|
export interface Underbar {
|
|
52
71
|
/** Lay the band over `rect` of the screen, at `zoom`, in the page's `look`, or hide it with null. */
|
|
53
72
|
show(rect: Rect | null, zoom: number, look: Look | null): void;
|