@reearth/ezu 0.5.0 → 0.6.0

package/bundler/ezu.d.ts

@@ -76,9 +76,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      */

package/bundler/ezu_bg.js

@@ -142,9 +142,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      * @param {string} name

package/nodejs/ezu.d.ts

@@ -76,9 +76,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      */

package/nodejs/ezu.js

@@ -145,9 +145,28 @@ class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      * @param {string} name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reearth/ezu",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Painterly map renderer — WebAssembly bindings",
   "license": "MIT OR Apache-2.0",
   "repository": {

package/simd/bundler/ezu.d.ts

@@ -76,9 +76,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      */

package/simd/bundler/ezu_bg.js

@@ -142,9 +142,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      * @param {string} name

package/simd/nodejs/ezu.d.ts

@@ -76,9 +76,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      */

package/simd/nodejs/ezu.js

@@ -145,9 +145,28 @@ class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      * @param {string} name

package/simd/web/ezu.d.ts

@@ -76,9 +76,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      */

package/simd/web/ezu.js

@@ -144,9 +144,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      * @param {string} name

package/web/ezu.d.ts

@@ -76,9 +76,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      */

package/web/ezu.js

@@ -144,9 +144,28 @@ export class Renderer {
      * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
      *   projected per tile (and neighbour) at render time.
      *
-     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
-     * `UnknownSource` if `name` doesn't match any entry in the style's
-     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `opts` is a JS object: `{ coord?: [dx, dy], sourceZoom?: number }`.
+     *
+     * `sourceZoom` declares that MVT bytes are natively encoded at a
+     * *shallower* zoom than the tile being rendered — a vector source
+     * that stops at its `maxzoom` while the host serves deeper tiles.
+     * The renderer then reprojects each payload from its own ancestor
+     * into the tile's frame before rendering (MVT "overzoom"), which is
+     * what a client would otherwise do by scaling a raster up. The
+     * ancestor is derived, not supplied: for a tile at zoom `z`, the
+     * ancestor at `sourceZoom` is unique, so a host that binds the
+     * `maxzoom` tile it fetched has nothing further to compute — and
+     * each neighbour resolves against its own ancestor, which for a 3×3
+     * window may be a different parent than the centre's.
+     *
+     * `sourceZoom` equal to the rendered zoom is accepted and does
+     * nothing, so a host can pass its source's `maxzoom` unconditionally
+     * and let shallow tiles take the ordinary path. Deeper than the
+     * rendered zoom throws `UnknownSource`: there is no way to invent
+     * detail the bytes do not carry.
+     *
+     * Throws `UnknownSource` if `name` doesn't match any entry in the
+     * style's `sources` block, `MvtDecode` if MVT bytes don't parse, and
      * `DemDecode` for non-image DEM bytes (the decode itself runs at
      * render time, but obvious cases are caught here).
      * @param {string} name