npm - chiitiler - Versions diffs - 1.12.2 → 1.12.3 - Mend

chiitiler 1.12.2 → 1.12.3

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.

Files changed (39) hide show

package/dist/cache/file.d.ts +7 -0
package/dist/cache/file.js +33 -0
package/dist/cache/index.d.ts +12 -0
package/dist/cache/index.js +9 -0
package/dist/cache/memory.d.ts +7 -0
package/dist/cache/memory.js +18 -0
package/dist/cache/s3.d.ts +8 -0
package/dist/cache/s3.js +65 -0
package/dist/cli.d.ts +2 -0
package/dist/cli.js +101 -0
package/dist/index.d.ts +1 -0
package/dist/index.js +1 -0
package/dist/main.d.ts +1 -0
package/dist/main.js +22 -0
package/dist/render/index.d.ts +25 -0
package/dist/render/index.js +146 -0
package/dist/render/pool.d.ts +6 -0
package/dist/render/pool.js +75 -0
package/dist/render/rasterize.d.ts +10 -0
package/dist/render/rasterize.js +66 -0
package/dist/s3.d.ts +6 -0
package/dist/s3.js +24 -0
package/dist/server/debug.d.ts +4 -0
package/dist/server/debug.js +201 -0
package/dist/server/index.d.ts +15 -0
package/dist/server/index.js +187 -0
package/dist/source/fs.d.ts +3 -0
package/dist/source/fs.js +15 -0
package/dist/source/http.d.ts +5 -0
package/dist/source/http.js +25 -0
package/dist/source/index.d.ts +10 -0
package/dist/source/index.js +27 -0
package/dist/source/mbtiles.d.ts +6 -0
package/dist/source/mbtiles.js +39 -0
package/dist/source/pmtiles.d.ts +9 -0
package/dist/source/pmtiles.js +106 -0
package/dist/source/s3.d.ts +3 -0
package/dist/source/s3.js +27 -0
package/package.json +4 -3

package/dist/server/debug.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import { Context } from 'hono';
+declare function getDebugPage(c: Context): Response;
+declare function getEditorgPage(c: Context): Response;
+export { getDebugPage, getEditorgPage };

package/dist/server/debug.js ADDED Viewed

@@ -0,0 +1,201 @@
+function getDebugPage(c) {
+    //demo tile
+    const url = c.req.query('url') ?? 'https://demotiles.maplibre.org/style.json';
+    const margin = Number(c.req.query('margin') ?? 0);
+    const quality = Number(c.req.query('quality') ?? 100);
+    const tileSize = Number(c.req.query('tileSize') ?? 512);
+    // show tile in MapLibre GL JS
+    return c.html(`<!DOCTYPE html>
+    <html>
+        <head>
+            <meta charset="utf-8" />
+            <title>MapLibre GL JS</title>
+            <!-- maplibre gl js-->
+            <script src="https://unpkg.com/maplibre-gl@^4.0/dist/maplibre-gl.js"></script>
+            <link
+                rel="stylesheet"
+                href="https://unpkg.com/maplibre-gl@^4.0/dist/maplibre-gl.css"
+            />
+            <style>
+                body {
+                    margin: 0;
+                    padding: 0;
+                }
+                #map {
+                    position: absolute;
+                    top: 0;
+                    bottom: 0;
+                    width: 100%;
+                }
+            </style>
+        </head>
+        <body>
+            <div id="map" style="height: 100vh"></div>
+            <script>
+                // hostname
+                const tileUrl = window.location.origin + '/tiles/{z}/{x}/{y}.webp?url=${url}&quality=${quality}&margin=${margin}&tileSize=${tileSize}';
+                const map = new maplibregl.Map({
+                    hash: true,
+                    container: 'map', // container id
+                    style: {
+                        version: 8,
+                        sources: {
+                            chiitiler: {
+                                type: 'raster',
+                                tiles: [tileUrl],
+                                tileSize: ${tileSize},
+                            }
+                        },
+                        layers: [
+                            {
+                                id: 'chiitiler',
+                                type: 'raster',
+                                source: 'chiitiler',
+                                minzoom: 0,
+                                maxzoom: 22,
+                            }
+                        ],
+                    },
+                    center: [0, 0], // starting position [lng, lat]
+                    zoom: 1, // starting zoom
+                });
+            </script>
+        </body>
+    </html>`);
+}
+function getEditorgPage(c) {
+    return c.html(`<!DOCTYPE html>
+    <html>
+        <head>
+            <meta charset="utf-8" />
+            <title>MapLibre GL JS</title>
+            <!-- maplibre gl js-->
+            <script src="https://unpkg.com/maplibre-gl@^4.0/dist/maplibre-gl.js"></script>
+            <link
+                rel="stylesheet"
+                href="https://unpkg.com/maplibre-gl@^4.0/dist/maplibre-gl.css"
+            />
+            <link href="https://cdnjs.cloudflare.com/ajax/libs/jsoneditor/10.0.3/jsoneditor.css" rel="stylesheet" type="text/css">
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/jsoneditor/10.0.3/jsoneditor.min.js"></script>
+            <style>
+                body {
+                    margin: 0;
+                    padding: 0;
+                }
+            </style>
+        </head>
+        <body>
+            <div id="map" style="height: 50vh"></div>
+            <div id="jsoneditor" style="height: 50vh"></div>
+            <script>
+                const container = document.getElementById("jsoneditor")
+                const editor = new JSONEditor(container, {
+                    mode: 'code',
+                    onChange: function() {
+                        reloadStyle()
+                        localStorage.setItem('style', JSON.stringify(editor.get()))
+                    }
+                })
+                const initialStyle = localStorage.getItem('style') ? JSON.parse(localStorage.getItem('style')) : {
+                    version: 8,
+                    sources: {
+                        osm: {
+                            type: 'raster',
+                            tiles: ['https://a.tile.openstreetmap.org/{z}/{x}/{y}.png'],
+                            tileSize: 256,
+                        },
+                        point: {
+                            type: 'geojson',
+                            data: {
+                                type: 'FeatureCollection',
+                                features: [
+                                    {
+                                        type: 'Feature',
+                                        properties: {},
+                                        geometry: {
+                                            type: 'Point',
+                                            coordinates: [140, 40],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                    layers: [
+                        {
+                            id: 'osm',
+                            type: 'raster',
+                            source: 'osm',
+                            minzoom: 0,
+                            maxzoom: 22,
+                        },
+                        {
+                            id: 'geojson',
+                            type: 'circle',
+                            source: 'point',
+                            paint: {
+                                'circle-radius': 10,
+                                'circle-color': '#f00',
+                            },
+                        },
+                    ],
+                };
+                editor.set(initialStyle);
+                maplibregl.addProtocol('post', async (params, abortController) => {
+                    const imageUrl = params.url.replace('post://', '');
+                    const style = editor.get()
+                    const png = await fetch(imageUrl, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ style }),
+                    }).then((res) => res.arrayBuffer());
+                    return { data: png };
+                });
+                const style = {
+                    version: 8,
+                    sources: {
+                        chiitiler: {
+                            type: 'raster',
+                            tiles: ['post://' + window.location.origin + '/tiles/{z}/{x}/{y}.png'],
+                        }
+                    },
+                    layers: [
+                        {
+                            id: 'chiitiler',
+                            type: 'raster',
+                            source: 'chiitiler',
+                            minzoom: 0,
+                            maxzoom: 22,
+                        }
+                    ],
+                };
+                const map = new maplibregl.Map({
+                    hash: true,
+                    container: 'map', // container id
+                    style,
+                    center: [0, 0], // starting position [lng, lat]
+                    zoom: 1, // starting zoom
+                });
+                // reload button
+                function reloadStyle() {
+                    map.setStyle({
+                        version: 8,
+                        sources: {},
+                        layers: [],
+                    });
+                    map.setStyle(style);
+                }
+            </script>
+        </body>
+    </html>`);
+}
+export { getDebugPage, getEditorgPage };

package/dist/server/index.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import { Hono } from 'hono/quick';
+import { type Cache } from '../cache/index.js';
+type InitServerOptions = {
+    cache: Cache;
+    port: number;
+    debug: boolean;
+};
+type InitializedServer = {
+    app: Hono;
+    tiles: Hono;
+    clip: Hono;
+    start: () => void;
+};
+declare function initServer(options: InitServerOptions): InitializedServer;
+export { initServer, type InitServerOptions };

package/dist/server/index.js ADDED Viewed

@@ -0,0 +1,187 @@
+import { Hono } from 'hono/quick';
+import { serve } from '@hono/node-server';
+import { validateStyleMin, } from '@maplibre/maplibre-gl-style-spec';
+import { getDebugPage, getEditorgPage } from './debug.js';
+import { getRenderedTileBuffer, getRenderedBboxBuffer, } from '../render/index.js';
+function isValidStylejson(stylejson) {
+    return validateStyleMin(stylejson).length === 0;
+}
+function isValidXyz(x, y, z) {
+    if (x < 0 || y < 0 || z < 0)
+        return false;
+    if (x >= 2 ** z || y >= 2 ** z)
+        return false;
+    return true;
+}
+function isSupportedFormat(ext) {
+    return ['png', 'jpeg', 'jpg', 'webp'].includes(ext);
+}
+function initServer(options) {
+    const tiles = new Hono()
+        .get('/:z/:x/:y_ext', async (c) => {
+        const url = c.req.query('url');
+        if (url === undefined)
+            return c.body('url is required', 400);
+        // path params
+        const z = Number(c.req.param('z'));
+        const x = Number(c.req.param('x'));
+        let [_y, ext] = c.req.param('y_ext').split('.');
+        const y = Number(_y);
+        if (!isValidXyz(x, y, z))
+            return c.body('invalid xyz', 400);
+        if (!isSupportedFormat(ext))
+            return c.body('invalid format', 400);
+        // query params
+        const tileSize = Number(c.req.query('tileSize') ?? 512);
+        const quality = Number(c.req.query('quality') ?? 100);
+        const margin = Number(c.req.query('margin') ?? 0);
+        let buf;
+        try {
+            buf = await getRenderedTileBuffer({
+                stylejson: url,
+                z,
+                x,
+                y,
+                tileSize,
+                cache: options.cache,
+                margin,
+                ext,
+                quality,
+            });
+        }
+        catch (e) {
+            console.error(`render error: ${e}`);
+            return c.body('failed to render tile', 400);
+        }
+        c.header('Content-Type', `image/${ext}`);
+        return c.body(buf);
+    })
+        .post('/:z/:x/:y_ext', async (c) => {
+        // body
+        const { style } = await c.req.json();
+        if (!isValidStylejson(style))
+            return c.body('invalid stylejson', 400);
+        // path params
+        const z = Number(c.req.param('z'));
+        const x = Number(c.req.param('x'));
+        let [_y, ext] = c.req.param('y_ext').split('.');
+        const y = Number(_y);
+        if (!isValidXyz(x, y, z))
+            return c.body('invalid xyz', 400);
+        if (!isSupportedFormat(ext))
+            return c.body('invalid format', 400);
+        // query params
+        const tileSize = Number(c.req.query('tileSize') ?? 512);
+        const quality = Number(c.req.query('quality') ?? 100);
+        const margin = Number(c.req.query('margin') ?? 0);
+        let buf;
+        try {
+            buf = await getRenderedTileBuffer({
+                stylejson: style,
+                z,
+                x,
+                y,
+                tileSize,
+                cache: options.cache,
+                margin,
+                ext,
+                quality,
+            });
+        }
+        catch (e) {
+            console.error(`render error: ${e}`);
+            return c.body('failed to render tile', 400);
+        }
+        c.header('Content-Type', `image/${ext}`);
+        return c.body(buf);
+    });
+    const clip = new Hono()
+        .get('/:filename_ext', async (c) => {
+        // path params
+        const [filename, ext] = c.req.param('filename_ext').split('.');
+        if (filename !== 'clip')
+            return c.body('not found', 404);
+        if (!isSupportedFormat(ext))
+            return c.body('invalid format', 400);
+        // query params
+        const bbox = c.req.query('bbox'); // ?bbox=minx,miny,maxx,maxy
+        if (bbox === undefined)
+            return c.body('bbox is required', 400);
+        const [minx, miny, maxx, maxy] = bbox.split(',').map(Number);
+        if (minx >= maxx || miny >= maxy)
+            return c.body('invalid bbox', 400);
+        const url = c.req.query('url');
+        if (url === undefined)
+            return c.body('url is required', 400);
+        const quality = Number(c.req.query('quality') ?? 100);
+        const size = Number(c.req.query('size') ?? 1024);
+        try {
+            const buf = await getRenderedBboxBuffer({
+                stylejson: url,
+                bbox: [minx, miny, maxx, maxy],
+                size,
+                cache: options.cache,
+                ext,
+                quality,
+            });
+            c.header('Content-Type', `image/${ext}`);
+            return c.body(buf);
+        }
+        catch (e) {
+            console.error(`render error: ${e}`);
+            return c.body('failed to render bbox', 400);
+        }
+    })
+        .post('/:filename_ext', async (c) => {
+        // body
+        const { style } = await c.req.json();
+        if (!isValidStylejson(style))
+            return c.body('invalid stylejson', 400);
+        // path params
+        const [filename, ext] = c.req.param('filename_ext').split('.');
+        if (filename !== 'clip')
+            return c.body('not found', 404);
+        if (!isSupportedFormat(ext))
+            return c.body('invalid format', 400);
+        // query params
+        const bbox = c.req.query('bbox'); // ?bbox=minx,miny,maxx,maxy
+        if (bbox === undefined)
+            return c.body('bbox is required', 400);
+        const [minx, miny, maxx, maxy] = bbox.split(',').map(Number);
+        if (minx >= maxx || miny >= maxy)
+            return c.body('invalid bbox', 400);
+        const quality = Number(c.req.query('quality') ?? 100);
+        const size = Number(c.req.query('size') ?? 1024);
+        try {
+            const buf = await getRenderedBboxBuffer({
+                stylejson: style,
+                bbox: [minx, miny, maxx, maxy],
+                size,
+                cache: options.cache,
+                ext,
+                quality,
+            });
+            c.header('Content-Type', `image/${ext}`);
+            return c.body(buf);
+        }
+        catch (e) {
+            console.error(`render error: ${e}`);
+            return c.body('failed to render bbox', 400);
+        }
+    });
+    const hono = new Hono();
+    if (options.debug) {
+        hono.get('/debug', getDebugPage);
+        hono.get('/editor', getEditorgPage);
+    }
+    hono.get('/health', (c) => c.text('OK'));
+    hono.route('/tiles', tiles);
+    hono.route('/', clip);
+    return {
+        app: hono,
+        tiles,
+        clip,
+        start: () => serve({ port: options.port, fetch: hono.fetch }),
+    };
+}
+export { initServer };

package/dist/source/fs.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+declare function getFilesystemSource(uri: string): Promise<Buffer | null>;
+export { getFilesystemSource };

package/dist/source/fs.js ADDED Viewed

@@ -0,0 +1,15 @@
+import fs from 'fs';
+function getFilesystemSource(uri) {
+    return new Promise((resolve, _) => {
+        fs.readFile(uri.replace('file://', ''), (err, data) => {
+            if (err) {
+                console.error(`[ERROR]: ${err}`);
+                resolve(null);
+            }
+            else {
+                resolve(data);
+            }
+        });
+    });
+}
+export { getFilesystemSource };

package/dist/source/http.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference lib="dom" />
+import { type Cache } from '../cache/index.js';
+declare function getHttpSource(uri: string, cache?: Cache): Promise<Buffer | null>;
+export { getHttpSource };

package/dist/source/http.js ADDED Viewed

@@ -0,0 +1,25 @@
+/// <reference lib="dom" />
+// for using native fetch in TypeScript
+import { noneCache } from '../cache/index.js';
+async function getHttpSource(uri, cache = noneCache()) {
+    // use cache only for http(s) sources
+    const val = await cache.get(uri);
+    if (val !== undefined)
+        return val; // hit
+    // miss
+    try {
+        const res = await fetch(uri);
+        if (!res.ok) {
+            console.log(`failed to fetch ${uri}`);
+            return null;
+        }
+        const buf = Buffer.from(await res.arrayBuffer());
+        cache.set(uri, buf);
+        return buf;
+    }
+    catch (e) {
+        console.error(`[ERROR] ${e}`);
+        return null;
+    }
+}
+export { getHttpSource };

package/dist/source/index.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Cache } from '../cache/index.js';
+/**
+ * retrieve sources from the uri
+ * @param uri
+ * @param cache {Cache} - Cache Strategy. Affect only for http(s) sources.
+ * @returns
+ */
+declare function getSource(uri: string, cache?: Cache): Promise<Buffer | null>;
+export { getSource };

package/dist/source/index.js ADDED Viewed

@@ -0,0 +1,27 @@
+import { getFilesystemSource } from './fs.js';
+import { getHttpSource } from './http.js';
+import { getPmtilesSoruce } from './pmtiles.js';
+import { getMbtilesSource } from './mbtiles.js';
+import { getS3Source } from './s3.js';
+import { noneCache } from '../cache/index.js';
+/**
+ * retrieve sources from the uri
+ * @param uri
+ * @param cache {Cache} - Cache Strategy. Affect only for http(s) sources.
+ * @returns
+ */
+async function getSource(uri, cache = noneCache()) {
+    let data = null;
+    if (uri.startsWith('http://') || uri.startsWith('https://'))
+        data = await getHttpSource(uri, cache);
+    else if (uri.startsWith('file://'))
+        data = await getFilesystemSource(uri);
+    else if (uri.startsWith('s3://'))
+        data = await getS3Source(uri);
+    else if (uri.startsWith('mbtiles://'))
+        data = await getMbtilesSource(uri);
+    else if (uri.startsWith('pmtiles://'))
+        data = await getPmtilesSoruce(uri, cache);
+    return data;
+}
+export { getSource };

package/dist/source/mbtiles.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * uri = mbtiles://path/to/file.mbtiles/{z}/{x}/{y}
+ */
+declare function getMbtilesSource(uri: string): Promise<Buffer | null>;
+export { getMbtilesSource };

package/dist/source/mbtiles.js ADDED Viewed

@@ -0,0 +1,39 @@
+import Database from 'better-sqlite3';
+import { unzip } from 'zlib';
+import { LRUCache } from 'lru-cache';
+const mbtilesCache = new LRUCache({
+    max: 20,
+});
+/**
+ * uri = mbtiles://path/to/file.mbtiles/{z}/{x}/{y}
+ */
+async function getMbtilesSource(uri) {
+    const mbtilesFilepath = uri
+        .replace('mbtiles://', '')
+        .replace(/\/\d+\/\d+\/\d+$/, '');
+    let statement = mbtilesCache.get(mbtilesFilepath);
+    if (statement === undefined) {
+        const db = new Database(mbtilesFilepath, { readonly: true });
+        statement = db.prepare('SELECT tile_data FROM tiles WHERE zoom_level = ? AND tile_column = ? AND tile_row = ?');
+        mbtilesCache.set(mbtilesFilepath, statement);
+    }
+    const [z, x, y] = uri
+        .replace(`mbtiles://${mbtilesFilepath}/`, '')
+        .split('/');
+    const ty = Math.pow(2, Number(z)) - 1 - Number(y);
+    const row = statement.get(z, x, ty);
+    if (!row)
+        return null;
+    const unzipped = await new Promise((resolve, _) => {
+        unzip(row.tile_data, (err, buffer) => {
+            if (err) {
+                console.error(`[ERROR]: ${err}`);
+                resolve(null);
+            }
+            else
+                resolve(buffer);
+        });
+    });
+    return unzipped;
+}
+export { getMbtilesSource };

package/dist/source/pmtiles.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type Cache } from '../cache/index.js';
+/**
+ * uri = pmtiles://path/to/file.pmtiles/{z}/{x}/{y}
+ * uri = pmtiles://http://url/to/file.pmtiles/{z}/{x}/{y}
+ * uri = pmtiles://s3://bucket/key/to/file.pmtiles/{z}/{x}/{y}
+ */
+declare function getPmtilesSoruce(uri: string, cache?: Cache): Promise<Buffer | null>;
+export { getPmtilesSoruce };

package/dist/source/pmtiles.js ADDED Viewed

@@ -0,0 +1,106 @@
+import * as fs from 'fs';
+import { PMTiles } from 'pmtiles';
+import { GetObjectCommand } from '@aws-sdk/client-s3';
+import { LRUCache } from 'lru-cache';
+import { getS3Client } from '../s3.js';
+import { noneCache } from '../cache/index.js';
+const pmtilesCache = new LRUCache({
+    max: 50,
+});
+class FilesystemSource {
+    filepath;
+    fileHandle;
+    constructor(filepath) {
+        this.filepath = filepath;
+        this.fileHandle = fs.promises.open(filepath, 'r');
+    }
+    getKey() {
+        return this.filepath;
+    }
+    async getBytes(offset, length) {
+        const buf = Buffer.alloc(length);
+        await (await this.fileHandle).read(buf, 0, length, offset);
+        return { data: buf.buffer };
+    }
+}
+class S3Source {
+    bucket;
+    key;
+    s3Client;
+    constructor(bucket, key) {
+        this.bucket = bucket;
+        this.key = key;
+        this.s3Client = getS3Client({
+            region: process.env.CHIITILER_S3_REGION ?? 'us-east1',
+            endpoint: process.env.CHIITILER_S3_ENDPOINT ?? null,
+        });
+    }
+    getKey() {
+        return `s3://${this.bucket}/${this.key}`;
+    }
+    async getBytes(offset, length) {
+        const cmd = new GetObjectCommand({
+            Bucket: this.bucket,
+            Key: this.key,
+            Range: `bytes=${offset}-${offset + length - 1}`,
+        });
+        try {
+            const obj = await this.s3Client.send(cmd);
+            if (obj.Body === undefined)
+                return { data: Buffer.alloc(0).buffer };
+            const buf = Buffer.from(await obj.Body.transformToByteArray());
+            return { data: buf.buffer };
+        }
+        catch (e) {
+            if (e.name !== 'NoSuchKey')
+                console.log(e);
+            return { data: Buffer.alloc(0).buffer };
+        }
+    }
+}
+/**
+ * uri = pmtiles://path/to/file.pmtiles/{z}/{x}/{y}
+ * uri = pmtiles://http://url/to/file.pmtiles/{z}/{x}/{y}
+ * uri = pmtiles://s3://bucket/key/to/file.pmtiles/{z}/{x}/{y}
+ */
+async function getPmtilesSoruce(uri, cache = noneCache()) {
+    const pmtilesUri = uri
+        .replace('pmtiles://', '')
+        .replace(/\/\d+\/\d+\/\d+$/, '');
+    let pmtiles = pmtilesCache.get(pmtilesUri);
+    const isHttpSource = pmtilesUri.startsWith('http://') || pmtilesUri.startsWith('https://');
+    if (isHttpSource) {
+        const val = await cache.get(uri);
+        if (val !== undefined)
+            return val; // hit
+        if (pmtiles === undefined) {
+            pmtiles = new PMTiles(pmtilesUri);
+            pmtilesCache.set(pmtilesUri, pmtiles);
+        }
+    }
+    else if (pmtilesUri.startsWith('s3://')) {
+        if (pmtiles === undefined) {
+            const bucket = pmtilesUri.replace('s3://', '').split('/')[0];
+            const key = pmtilesUri.replace(`s3://${bucket}/`, '');
+            const s3Source = new S3Source(bucket, key);
+            pmtiles = new PMTiles(s3Source);
+            pmtilesCache.set(pmtilesUri, pmtiles);
+        }
+    }
+    else {
+        if (pmtiles === undefined) {
+            const fileSource = new FilesystemSource(pmtilesUri);
+            pmtiles = new PMTiles(fileSource);
+            pmtilesCache.set(pmtilesUri, pmtiles);
+        }
+    }
+    const [z, x, y] = uri.replace(`pmtiles://${pmtilesUri}/`, '').split('/');
+    const tile = await pmtiles.getZxy(Number(z), Number(x), Number(y));
+    if (!tile)
+        return null;
+    const buf = Buffer.from(tile.data);
+    if (isHttpSource)
+        cache.set(uri, buf);
+    return buf;
+}
+export { getPmtilesSoruce };

package/dist/source/s3.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+declare function getS3Source(uri: string): Promise<Buffer | null>;
+export { getS3Source };