chiitiler 1.12.2 → 1.12.3

package/dist/cache/file.d.ts

@@ -0,0 +1,7 @@
+import { type Cache } from './index.js';
+type fileCacheOptions = {
+    dir: string;
+    ttl: number;
+};
+declare const fileCache: (options: fileCacheOptions) => Cache;
+export { fileCache };

package/dist/cache/file.js

@@ -0,0 +1,33 @@
+import { Cache as FileSystemCache } from 'file-system-cache';
+const fileCache = function (options) {
+    const cache = new FileSystemCache({
+        basePath: options.dir,
+        hash: 'sha1',
+        ttl: options.ttl,
+    });
+    return {
+        name: 'file',
+        set: async function (key, value) {
+            try {
+                await cache.set(key, value.toString('hex'));
+            }
+            catch (e) {
+                console.error(e);
+            }
+        },
+        get: async function (key) {
+            try {
+                const val = await cache.get(key, undefined);
+                if (val === undefined)
+                    return undefined;
+                return Buffer.from(val, 'hex');
+            }
+            catch (e) {
+                console.error(e);
+                cache.remove(key);
+                return undefined;
+            }
+        },
+    };
+};
+export { fileCache };

package/dist/cache/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+import { memoryCache } from './memory.js';
+import { s3Cache } from './s3.js';
+import { fileCache } from './file.js';
+type Value = Buffer;
+type Cache = {
+    name: string;
+    get: (key: string) => Promise<Value | undefined>;
+    set: (key: string, value: Value) => Promise<void>;
+};
+declare const noneCache: () => Cache;
+export { noneCache, memoryCache, s3Cache, fileCache, type Value, type Cache };

package/dist/cache/index.js

@@ -0,0 +1,9 @@
+import { memoryCache } from './memory.js';
+import { s3Cache } from './s3.js';
+import { fileCache } from './file.js';
+const noneCache = () => ({
+    name: 'none',
+    get: async () => undefined,
+    set: async () => undefined,
+});
+export { noneCache, memoryCache, s3Cache, fileCache };

package/dist/cache/memory.d.ts

@@ -0,0 +1,7 @@
+import { type Cache } from './index.js';
+type MemoryCacheOptions = {
+    ttl: number;
+    maxItemCount: number;
+};
+declare const memoryCache: (options: MemoryCacheOptions) => Cache;
+export { memoryCache };

package/dist/cache/memory.js

@@ -0,0 +1,18 @@
+import { LRUCache } from 'lru-cache';
+const memoryCache = function (options) {
+    const MEMORY_CACHE = new LRUCache({
+        max: options.maxItemCount,
+        ttl: options.ttl * 1000,
+    });
+    return {
+        name: 'memory',
+        set: async function (key, value) {
+            MEMORY_CACHE.set(key, value);
+        },
+        get: async function (key) {
+            const item = MEMORY_CACHE.get(key);
+            return item;
+        },
+    };
+};
+export { memoryCache };

package/dist/cache/s3.d.ts

@@ -0,0 +1,8 @@
+import { type Cache } from './index.js';
+type S3CacheOptions = {
+    bucket: string;
+    region: string;
+    endpoint: string | null;
+};
+declare function s3Cache(options: S3CacheOptions): Cache;
+export { s3Cache };

package/dist/cache/s3.js

@@ -0,0 +1,65 @@
+import { PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+import { getS3Client } from '../s3.js';
+function s3Cache(options) {
+    const s3Client = getS3Client({
+        region: options.region,
+        endpoint: options.endpoint,
+    });
+    return {
+        name: 's3',
+        set: async function (key, value) {
+            try {
+                const cmd = new PutObjectCommand({
+                    Bucket: options.bucket,
+                    Key: escapeFileName(key),
+                    Body: value,
+                });
+                await s3Client.send(cmd);
+            }
+            catch (e) {
+                console.log(`[error]: ${e}`);
+            }
+        },
+        get: async function (key) {
+            const cmd = new GetObjectCommand({
+                Bucket: options.bucket,
+                Key: escapeFileName(key),
+            });
+            try {
+                const obj = await s3Client.send(cmd);
+                if (obj.Body === undefined)
+                    return undefined;
+                const buf = Buffer.from(await obj.Body.transformToByteArray());
+                return buf;
+            }
+            catch {
+                // miss or any error
+                return undefined;
+            }
+        },
+    };
+}
+function escapeFileName(url) {
+    return url
+        .replace(/\//g, '_') // replace slashes with underscores
+        .replace(/\?/g, '-') // replace question marks with dashes
+        .replace(/&/g, '-') // replace ampersands with dashes
+        .replace(/=/g, '-') // replace equals signs with dashes
+        .replace(/%/g, '-') // replace percent signs with dashes
+        .replace(/#/g, '-') // replace hash signs with dashes
+        .replace(/:/g, '-') // replace colons with dashes
+        .replace(/\+/g, '-') // replace plus signs with dashes
+        .replace(/ /g, '-') // replace spaces with dashes
+        .replace(/</g, '-') // replace less than signs with dashes
+        .replace(/>/g, '-') // replace greater than signs with dashes
+        .replace(/\*/g, '-') // replace asterisks with dashes
+        .replace(/\|/g, '-') // replace vertical bars with dashes
+        .replace(/"/g, '-') // replace double quotes with dashes
+        .replace(/'/g, '-') // replace single quotes with dashes
+        .replace(/\?/g, '-') // replace question marks with dashes
+        .replace(/\./g, '-') // replace dots with dashes
+        .replace(/,/g, '-') // replace commas with dashes
+        .replace(/;/g, '-') // replace semicolons with dashes
+        .replace(/\\/g, '-'); // replace backslashes with dashes
+}
+export { s3Cache };

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createProgram(): Command;

package/dist/cli.js

@@ -0,0 +1,101 @@
+import process from 'node:process';
+import { Command } from 'commander';
+import { initServer } from './server/index.js';
+import * as caches from './cache/index.js';
+function parseCacheStrategy(method, options) {
+    // command-line option
+    if (method === 'memory')
+        return caches.memoryCache({
+            ttl: options.cacheTtl,
+            maxItemCount: options.memoryCacheMaxItemCount,
+        });
+    if (method === 'file')
+        return caches.fileCache({
+            dir: options.fileCacheDir,
+            ttl: options.cacheTtl,
+        });
+    if (method === 's3')
+        return caches.s3Cache({
+            bucket: options.s3CacheBucket,
+            region: options.s3Region,
+            endpoint: options.s3Endpoint,
+        });
+    // command-line is not specified -> try to read from env
+    const cacheEnv = process.env.CHIITILER_CACHE_METHOD;
+    if (cacheEnv === 'memory')
+        return caches.memoryCache({
+            ttl: Number(process.env.CHIITILER_CACHE_TTL_SEC ?? '3600'),
+            maxItemCount: Number(process.env.CHIITILER_MEMORYCACHE_MAXITEMCOUNT ?? '1000'),
+        });
+    if (cacheEnv === 'file')
+        return caches.fileCache({
+            dir: process.env.CHIITILER_FILECACHE_DIR ?? './.cache',
+            ttl: Number(process.env.CHIITILER_CACHE_TTL_SEC ?? '3600'),
+        });
+    if (cacheEnv === 's3')
+        return caches.s3Cache({
+            bucket: process.env.CHIITILER_S3CACHE_BUCKET ?? '',
+            region: process.env.CHIITILER_S3_REGION ?? 'us-east1',
+            endpoint: process.env.CHIITILER_S3_ENDPOINT ?? null,
+        });
+    // undefined or invalid
+    return caches.noneCache();
+}
+function parsePort(port) {
+    // command-line option
+    if (port !== undefined)
+        return Number(port);
+    // command-line is not specified -> try to read from env
+    const portEnv = process.env.CHIITILER_PORT;
+    if (portEnv !== undefined)
+        return Number(portEnv);
+    // undefined or invalid
+    return 3000;
+}
+function parseDebug(debug) {
+    // command-line option
+    if (debug)
+        return true;
+    // command-line is not specified or false -> try to read from env
+    const debugEnv = process.env.CHIITILER_DEBUG;
+    if (debugEnv !== undefined)
+        return debugEnv === 'true';
+    // undefined or invalid
+    return false;
+}
+export function createProgram() {
+    const program = new Command();
+    program
+        .command('tile-server')
+        .option('-c, --cache <type>', 'cache type', 'none')
+        .option('-ctl --cache-ttl', 'cache ttl', '3600')
+        .option('-mci --memory-cache-max-item-count', 'memory cache max item count', '1000')
+        .option('-fcd --file-cache-dir <dir>', 'file cache directory', './.cache')
+        .option('-s3r --s3-region <region-name>', 's3 bucket region for get/put', 'us-east1')
+        .option('-s3b --s3-cache-bucket <bucket-name>', 's3 cache bucket name', '')
+        .option('-s3e --s3-endpoint <url>', 's3 endpoint url', '')
+        .option('-p --port <port>', 'port number')
+        .option('-D --debug', 'debug mode')
+        .action((options) => {
+        const serverOptions = {
+            cache: parseCacheStrategy(options.cache, {
+                cacheTtl: Number(options.cacheTtl),
+                memoryCacheMaxItemCount: Number(options.memoryCacheMaxItemCount),
+                fileCacheDir: options.fileCacheDir,
+                s3CacheBucket: options.s3CacheBucket,
+                s3Region: options.s3Region,
+                s3Endpoint: options.s3Endpoint,
+            }),
+            port: parsePort(options.port),
+            debug: parseDebug(options.debug),
+        };
+        if (serverOptions.debug) {
+            console.log(`running server: http://localhost:${serverOptions.port}`);
+            console.log(`cache method: ${serverOptions.cache.name}`);
+            console.log(`debug page: http://localhost:${serverOptions.port}/debug`);
+        }
+        const { start } = initServer(serverOptions);
+        start();
+    });
+    return program;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { initServer, type InitServerOptions } from './server/index.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { initServer } from './server/index.js';

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main.js

@@ -0,0 +1,22 @@
+import cluster from 'node:cluster';
+import { availableParallelism } from 'node:os';
+import process from 'node:process';
+import { createProgram } from './cli.js';
+const program = createProgram();
+const numProcesses = (() => {
+    if (process.env.CHIITILER_PROCESSES === undefined)
+        return 1;
+    const processesEnv = Number(process.env.CHIITILER_PROCESSES);
+    if (processesEnv === 0)
+        return availableParallelism();
+    else
+        return processesEnv;
+})();
+if (cluster.isPrimary && numProcesses !== 1) {
+    // Fork workers.
+    for (let i = 0; i < numProcesses; i++)
+        cluster.fork();
+}
+else {
+    program.parse(process.argv);
+}

package/dist/render/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { Cache } from '../cache/index.js';
+type RenderTilePipelineOptions = {
+    stylejson: string | StyleSpecification;
+    z: number;
+    x: number;
+    y: number;
+    tileSize: number;
+    cache: Cache;
+    margin: number;
+    ext: SupportedFormat;
+    quality: number;
+};
+type SupportedFormat = 'png' | 'jpeg' | 'jpg' | 'webp';
+declare function getRenderedTileBuffer({ stylejson, z, x, y, tileSize, cache, margin, ext, quality, }: RenderTilePipelineOptions): Promise<Buffer>;
+declare function getRenderedBboxBuffer({ stylejson, bbox, size, cache, ext, quality, }: {
+    stylejson: string | StyleSpecification;
+    bbox: [number, number, number, number];
+    size: number;
+    cache: Cache;
+    ext: SupportedFormat;
+    quality: number;
+}): Promise<Buffer>;
+export { getRenderedTileBuffer, getRenderedBboxBuffer, type SupportedFormat };

package/dist/render/index.js

@@ -0,0 +1,146 @@
+import sharp from 'sharp';
+// @ts-ignore
+import SphericalMercator from '@mapbox/sphericalmercator';
+const mercator = new SphericalMercator();
+import { LRUCache } from 'lru-cache';
+import { renderTile, render } from './rasterize.js';
+import { getSource } from '../source/index.js';
+const styleCache = new LRUCache({
+    max: 5,
+});
+async function loadStyle(stylejson, cache) {
+    let style;
+    if (typeof stylejson === 'string') {
+        // url
+        const cachedStyle = styleCache.get(stylejson);
+        if (cachedStyle !== undefined) {
+            // hit-cache
+            style = cachedStyle;
+        }
+        else {
+            const styleJsonBuf = await getSource(stylejson, cache);
+            if (styleJsonBuf === null) {
+                throw new Error('style not found');
+            }
+            style = JSON.parse(styleJsonBuf.toString());
+            styleCache.set(stylejson, style);
+        }
+    }
+    else {
+        // as stylejson object
+        style = stylejson;
+    }
+    return style;
+}
+async function getRenderedTileBuffer({ stylejson, z, x, y, tileSize, cache, margin, ext, quality, }) {
+    const style = await loadStyle(stylejson, cache);
+    let pixels;
+    pixels = await renderTile(style, z, x, y, {
+        tileSize,
+        cache,
+        margin,
+    });
+    // hack: tile-margin clip area
+    // maplibre-native won't render outer area of meractor
+    // so top-end and bottom-end clipped area is special
+    const isTopEnd = y === 0;
+    const isBottomEnd = y === 2 ** z - 1;
+    const topMargin = isTopEnd ? 0 : isBottomEnd ? margin : margin / 2;
+    let _sharp;
+    if (tileSize === 256 && z === 0) {
+        // hack: when tileSize=256, z=0
+        // pixlels will be 512x512 so we need to resize to 256x256
+        _sharp = sharp(pixels, {
+            raw: {
+                width: 512,
+                height: 512,
+                channels: 4,
+            },
+        }).resize(256, 256);
+    }
+    else if (margin === 0) {
+        _sharp = sharp(pixels, {
+            raw: {
+                width: tileSize,
+                height: tileSize,
+                channels: 4,
+            },
+        });
+    }
+    else {
+        _sharp = sharp(pixels, {
+            raw: {
+                width: tileSize + margin,
+                height: tileSize + margin,
+                channels: 4,
+            },
+        })
+            .extract({
+            left: margin / 2,
+            top: topMargin,
+            width: tileSize,
+            height: tileSize,
+        })
+            .resize(tileSize, tileSize);
+    }
+    let buf;
+    switch (ext) {
+        case 'png':
+            buf = await _sharp.png().toBuffer();
+            break;
+        case 'jpeg':
+        case 'jpg':
+            buf = await _sharp.jpeg({ quality }).toBuffer();
+            break;
+        case 'webp':
+            buf = await _sharp.webp({ quality, effort: 0 }).toBuffer();
+            break;
+    }
+    return buf;
+}
+const calcRenderingParams = (bbox, size) => {
+    // reference: https://github.com/maptiler/tileserver-gl/blob/cc4b8f7954069fd0e1db731ff07f5349f7b9c8cd/src/serve_rendered.js#L346
+    // very hacky and it might be wrong
+    let zoom = 25;
+    const minCorner = mercator.px([bbox[0], bbox[3]], zoom);
+    const maxCorner = mercator.px([bbox[2], bbox[1]], zoom);
+    const dx = maxCorner[0] - minCorner[0];
+    const dy = maxCorner[1] - minCorner[1];
+    zoom -= Math.max(Math.log(dx / size), Math.log(dy / size)) / Math.LN2;
+    zoom = Math.max(Math.log(size / 256) / Math.LN2, Math.min(25, zoom)) - 1;
+    const width = dx > dy ? size : Math.ceil((dx / dy) * size);
+    const height = dx > dy ? Math.ceil((dy / dx) * size) : size;
+    const mercCenter = [
+        (maxCorner[0] + minCorner[0]) / 2,
+        (maxCorner[1] + minCorner[1]) / 2,
+    ];
+    const center = mercator.ll(mercCenter, 25); // latlon
+    return { zoom, width, height, center };
+};
+async function getRenderedBboxBuffer({ stylejson, bbox, size, cache, ext, quality, }) {
+    const style = await loadStyle(stylejson, cache);
+    const { zoom, width, height, center } = calcRenderingParams(bbox, size);
+    const pixels = await render(style, {
+        zoom,
+        width,
+        height,
+        center,
+    }, cache, 'static');
+    let _sharp = sharp(pixels, {
+        raw: {
+            width,
+            height,
+            channels: 4,
+        },
+    });
+    switch (ext) {
+        case 'png':
+            return await _sharp.png().toBuffer();
+        case 'jpeg':
+        case 'jpg':
+            return await _sharp.jpeg({ quality }).toBuffer();
+        case 'webp':
+            return await _sharp.webp({ quality, effort: 0 }).toBuffer();
+    }
+}
+export { getRenderedTileBuffer, getRenderedBboxBuffer };

package/dist/render/pool.d.ts

@@ -0,0 +1,6 @@
+import mbgl from '@maplibre/maplibre-gl-native';
+import { Pool } from 'lightning-pool';
+import type { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { Cache } from '../cache/index.js';
+declare function getRenderPool(style: StyleSpecification, cache: Cache, mode: 'tile' | 'static'): Promise<Pool<mbgl.Map>>;
+export { getRenderPool };

package/dist/render/pool.js

@@ -0,0 +1,75 @@
+import * as path from 'path';
+import mbgl from '@maplibre/maplibre-gl-native';
+import { Pool } from 'lightning-pool';
+import { LRUCache } from 'lru-cache';
+import { getSource } from '../source/index.js';
+const EMPTY_BUFFER = Buffer.alloc(0);
+const TRANSPARENT_BUFFER = {
+    // 1x1 transparent images
+    png: Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4//8/AwAI/AL+p5qgoAAAAABJRU5ErkJggg==', 'base64'),
+    webp: Buffer.from('UklGRkAAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAIAAAAAAFZQOCAYAAAAMAEAnQEqAQABAAFAJiWkAANwAP789AAA', 'base64'),
+    jpeg: Buffer.from('/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiigD//2Q=='),
+};
+function handleFileExt(uri) {
+    // extract extension only, take into account query string or hash
+    const basename = path.basename(uri).split(/[?#]/)[0];
+    const ext = basename.split('.').pop();
+    if (ext === undefined)
+        return null;
+    const l = ext.toLowerCase();
+    if (l === 'jpeg')
+        return 'jpg';
+    return l;
+}
+const mapPoolCache = new LRUCache({
+    max: 10,
+    dispose: (pool, key) => {
+        pool.close();
+    },
+});
+async function getRenderPool(style, cache, mode) {
+    const cacheKey = JSON.stringify(style);
+    const pool = mapPoolCache.get(cacheKey);
+    if (pool !== undefined)
+        return pool;
+    const newPool = new Pool({
+        create: () => {
+            const map = new mbgl.Map({
+                request: function (req, callback) {
+                    const ext = handleFileExt(req.url);
+                    getSource(req.url, cache)
+                        .then((buf) => {
+                        if (buf) {
+                            callback(undefined, { data: buf });
+                        }
+                        else if (ext && TRANSPARENT_BUFFER[ext])
+                            callback(undefined, {
+                                data: TRANSPARENT_BUFFER[ext],
+                            });
+                        else
+                            callback(undefined, { data: EMPTY_BUFFER });
+                    })
+                        .catch(() => {
+                        if (ext && TRANSPARENT_BUFFER[ext])
+                            callback(undefined, {
+                                data: TRANSPARENT_BUFFER[ext],
+                            });
+                        else
+                            callback(undefined, { data: EMPTY_BUFFER });
+                    });
+                },
+                ratio: 1,
+                // @ts-ignore
+                mode,
+            });
+            map.load(style);
+            return map;
+        },
+        destroy: (map) => {
+            map.release();
+        },
+    });
+    mapPoolCache.set(cacheKey, newPool);
+    return newPool;
+}
+export { getRenderPool };

package/dist/render/rasterize.d.ts

@@ -0,0 +1,10 @@
+import type { RenderOptions } from '@maplibre/maplibre-gl-native';
+import type { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { Cache } from '../cache/index.js';
+declare function render(style: StyleSpecification, renderOptions: RenderOptions, cache: Cache, mode: 'tile' | 'static'): Promise<Uint8Array>;
+declare function renderTile(style: StyleSpecification, z: number, x: number, y: number, options: {
+    tileSize: number;
+    cache: Cache;
+    margin?: number;
+}): Promise<Uint8Array>;
+export { renderTile, render };

package/dist/render/rasterize.js

@@ -0,0 +1,66 @@
+// @ts-ignore
+import SphericalMercator from '@mapbox/sphericalmercator';
+import { getRenderPool } from './pool.js';
+function getTileCenter(z, x, y, tileSize = 256) {
+    const mercator = new SphericalMercator({
+        size: tileSize,
+    });
+    const px = tileSize / 2 + x * tileSize;
+    const py = tileSize / 2 + y * tileSize;
+    const tileCenter = mercator.ll([px, py], z);
+    return tileCenter;
+}
+async function render(style, renderOptions, cache, mode) {
+    const pool = await getRenderPool(style, cache, mode);
+    const worker = await pool.acquire();
+    const rendered = new Promise((resolve, reject) => {
+        worker.render(renderOptions, function (err, buffer) {
+            pool.release(worker);
+            if (err) {
+                reject(err);
+                return;
+            }
+            if (buffer === undefined) {
+                reject('buffer is undefined');
+                return;
+            }
+            resolve(buffer);
+        });
+    });
+    return rendered;
+}
+async function renderTile(style, z, x, y, options) {
+    /**
+     * zoom(renderingOptions): tileSize=256 -> z-1, 512 -> z, 1024 -> z+1...
+     * width, height(renderingOptions): equal to tileSize but:
+     * when zoom=0, entire globe is rendered in 512x512
+     * even when tilesize=256, entire globe is rendered in "512x512 at zoom=0"
+     * so we have to set 512 when tilesize=256 and zoom=0, and adjust ratio
+     */
+    const renderingParams = options.tileSize === 256 && z === 0
+        ? {
+            zoom: 0,
+            height: 512,
+            width: 512,
+            ratio: 0.5,
+        }
+        : {
+            // offset = 128 -> -1, 256 -> 0, 512 -> 1, 1024 -> 2...
+            zoom: z - 1 + Math.log2(options.tileSize / 256),
+            height: options.tileSize,
+            width: options.tileSize,
+            ratio: 1,
+        };
+    const tileMode = options.margin === 0 &&
+        (options.tileSize === 256 || options.tileSize === 512); // mode=tile supports only 256 and 512
+    const rendered = await render(style, {
+        zoom: renderingParams.zoom,
+        width: renderingParams.width + (options.margin ?? 0),
+        height: renderingParams.height + (options.margin ?? 0),
+        center: getTileCenter(z, x, y, options.tileSize),
+        bearing: 0,
+        pitch: 0,
+    }, options.cache, tileMode ? 'tile' : 'static');
+    return rendered;
+}
+export { renderTile, render };

package/dist/s3.d.ts

@@ -0,0 +1,6 @@
+import { S3Client } from '@aws-sdk/client-s3';
+declare const getS3Client: ({ region, endpoint, }: {
+    region: string;
+    endpoint: string | null;
+}) => S3Client;
+export { getS3Client };

package/dist/s3.js

@@ -0,0 +1,24 @@
+import { S3Client } from '@aws-sdk/client-s3';
+let s3Client; // singleton
+const getS3Client = function ({ region, endpoint, }) {
+    if (s3Client !== undefined)
+        return s3Client;
+    let s3ClientConfig = {
+        region,
+        endpoint: endpoint ?? undefined,
+    };
+    if (process.env.NODE_ENV === 'development') {
+        s3ClientConfig = {
+            region,
+            credentials: {
+                accessKeyId: 'minioadmin',
+                secretAccessKey: 'minioadmin',
+            },
+            forcePathStyle: true,
+            endpoint: 'http://minio:9000',
+        };
+    }
+    s3Client = new S3Client(s3ClientConfig);
+    return s3Client;
+};
+export { getS3Client };