spacemap 0.1.13 → 0.1.15

package/index.d.ts

@@ -479,6 +479,8 @@ export declare class FlatMap {
     private projectionOptions;
     private view;
     private limits;
+    /** True when the host gave no `maxZoom`. The map then sets its own limit. */
+    private ownMaxZoom;
     /** The reader has moved the view since the last programmatic one, so the
      *  limits apply to it. A {@link setView} lands where it was told. */
     private limitsArmed;
@@ -494,6 +496,10 @@ export declare class FlatMap {
     /** Pictures the export does not have. Remembered, or every pan would ask
      *  for them again and report the same failure. */
     private readonly missing;
+    /** The tile windows of each picture layer that has a pyramid. */
+    private readonly tiles;
+    /** `performance.now()` of the last tile plan. */
+    private plannedAt;
     /** Bumped whenever the map moves to another body, so work started for the
      *  one being left can tell that it is no longer wanted. */
     private generation;
@@ -599,13 +605,15 @@ export declare class FlatMap {
     setView(view: Partial<FlatViewState>): void;
     /**
      * Replace the reader's limits, whole. What the new set leaves out is
-     * unrestricted again, except `maxZoom`, which goes back to 16.
+     * unrestricted again, except `maxZoom`, which goes back to the map's own:
+     * 16, or more where the surface has tiles.
      *
      * Limits gate reader input only: {@link setView} lands where it was told,
      * and the reader's next gesture brings the view back inside.
      */
     setLimits(limits: FlatMapLimits): this;
-    /** The limits as they stand. */
+    /** The limits as they stand. Where the host gave no `maxZoom`, it is the
+     *  map's own for the place in the middle of the frame. */
     getLimits(): FlatMapLimits;
     /** The moment the map is of. Moves the clouds and, on Earth, the season. */
     setTime(jd: number): void;
@@ -661,6 +669,33 @@ export declare class FlatMap {
     private rasterFor;
     /** Release every claim this map holds on the shared pictures. */
     private dropTextures;
+    /** The tiles of a layer, where this host draws them and the pyramid holds
+     *  more than the picture under it. */
+    private tilesOf;
+    /** The first level that holds more than the picture under the tiles. An
+     *  equirectangular map draws that picture whole, and the others sample a
+     *  copy of a limited width. */
+    private firstTileLevel;
+    /** What the tile plan reads of a frame. `density` is the number of drawn
+     *  pixels for each pixel of `viewport`. Undefined when the middle of the
+     *  frame is off the world. */
+    private frameSample;
+    /** Ask for the tile windows of the frame, layer by layer. */
+    private planTiles;
+    /** Whether the reader can move the map. */
+    private moves;
+    private dropTiles;
+    /**
+     * How far in the reader can go when the host gives no limit. Where tiles
+     * serve, it is the zoom that draws the finest tiles under the middle of the
+     * frame at `MAX_TILE_STRETCH`.
+     */
+    private pictureMaxZoom;
+    /** The limits that hold the view. Where tiles serve, the map's own zoom
+     *  limit changes from place to place. It then only stops the way in, and
+     *  does not pull back a view that is past it. */
+    private heldLimits;
+    /* Excluded from this release type: tileStepDeg */
     private viewport;
     /** Draw on the next frame. Repeated calls in one frame draw once. */
     render(): void;
@@ -736,6 +771,7 @@ export declare type FlatMapGesture = 'dragPan' | 'scrollZoom';
 export declare interface FlatMapLimits {
     /** 1 is the whole world; the reader may not go under it either way. */
     minZoom?: number;
+    /** Left out, the map sets its own: 16, or more where the surface has tiles. */
     maxZoom?: number;
     /** The band of the surface the middle of the frame may sit in. A longitude
      *  band may run through the antimeridian: 170 to −170 is the twenty degrees
@@ -974,8 +1010,8 @@ export declare type Interpolation =
 *  track means by a straight line. */
 | 'geodesic';
 
-/** Whether a stop has a sphere to open, as against a place on the traverse:
- *  one exists, and this host's terms reach it. */
+/** True when the terms of this host allow the sphere of the stop, so the view
+ *  can open it. */
 export declare function isViewable(entry: PanoramaEntry): boolean;
 
 /** Convert a Julian Date to a JS Date. */
@@ -1319,9 +1355,8 @@ export declare interface PanoramaEntry {
     altitude_m?: number;
     title?: string;
     /** Image azimuth of true north, degrees clockwise from the left edge.
-     *  Zero, and meaningless, where `orientation` is `unknown`; absent with
-     *  the rest of the sphere's geometry where the imagery is withheld. */
-    north_offset_deg?: number;
+     *  Zero, and meaningless, where `orientation` is `unknown`. */
+    north_offset_deg: number;
     /** How north was established, absent where the archive itself states it.
      *  `unknown` means the sphere sits at an arbitrary azimuth, so nothing
      *  may be drawn or written as a heading. The full set `export/panoramas.py`
@@ -1344,9 +1379,6 @@ export declare interface PanoramaEntry {
     credit?: string;
     credit_url?: string;
     source_url?: string;
-    /** `withheld` where the release's reuse terms are unsettled: the stop is
-     *  published as a place and a date, and no texture exists to fetch. */
-    imagery?: 'withheld';
     /** How far down the host's texture ladder this sphere may be drawn; absent
      *  where its terms allow any use. */
     distribution?: TextureDistribution;
@@ -1361,9 +1393,6 @@ export declare interface PanoramaMissionSummary {
     count: number;
     first_time: string;
     last_time: string;
-    /** False where no stop on the traverse publishes a sphere: the places are
-     *  on the map, and there is nothing to open. */
-    imagery?: boolean;
 }
 
 export declare class PanoramaView {
@@ -1927,6 +1956,15 @@ export declare class SpaceMap {
      *  body not loaded, and until the map has read how it spins, which it does
      *  once the camera is on the body or its system. */
     getSubsolarPoint(id: string): LonLat | null;
+    /** Whether this map draws surface tiles at all. False where no tile host is
+     *  set, and on a device short of memory: every body then shows its
+     *  whole-globe maps alone, and close up they go soft. */
+    tilesEnabled(): boolean;
+    /** Whether tiles sharpen `id`'s surface up close. False for a body without
+     *  a tile pyramid this embed may draw, one that is a shape model up close,
+     *  and one whose tiles the tile host has failed. Read from the body's own
+     *  data, so the answer does not wait for the camera to get there. */
+    hasTiles(id: string): Promise<boolean>;
     /* Excluded from this release type: load */
     /* Excluded from this release type: open */
     private openOnce;