chiitiler 1.14.2 → 1.16.0

package/dist/cli.js

@@ -21,6 +21,14 @@ function parseCacheStrategy(method, options) {
             endpoint: options.s3Endpoint,
             forcePathStyle: options.s3ForcePathStyle,
         });
+    if (method === 'gcs')
+        return caches.gcsCache({
+            bucket: options.gcsCacheBucket,
+            projectId: options.gcsProjectId,
+            keyFilename: options.gcsKeyFilename,
+            prefix: options.gcsCachePrefix,
+            apiEndpoint: options.gcsApiEndpoint,
+        });
     // command-line is not specified -> try to read from env
     const cacheEnv = process.env.CHIITILER_CACHE_METHOD;
     if (cacheEnv === 'memory')
@@ -40,6 +48,14 @@ function parseCacheStrategy(method, options) {
             endpoint: process.env.CHIITILER_S3_ENDPOINT,
             forcePathStyle: process.env.CHIITILER_S3_FORCE_PATH_STYLE === 'true',
         });
+    if (cacheEnv === 'gcs')
+        return caches.gcsCache({
+            bucket: process.env.CHIITILER_GCS_CACHE_BUCKET ?? '',
+            prefix: process.env.CHIITILER_GCS_CACHE_PREFIX,
+            projectId: process.env.CHIITILER_GCS_PROJECT_ID,
+            keyFilename: process.env.CHIITILER_GCS_KEY_FILENAME,
+            apiEndpoint: process.env.CHIITILER_GCS_API_ENDPOINT,
+        });
     // undefined or invalid
     return caches.noneCache();
 }
@@ -88,6 +104,11 @@ export function createProgram() {
         .option('-s3b --s3-cache-bucket <bucket-name>', 's3 cache bucket name', '')
         .option('-s3e --s3-endpoint <url>', 's3 endpoint url', '')
         .option('-3p --s3-force-path-style', 's3 force path style', '')
+        .option('-gcsb --gcs-cache-bucket <bucket-name>', 'gcs cache bucket name', '')
+        .option('-gcsp --gcs-project-id <project-id>', 'gcs project id', '')
+        .option('-gcsk --gcs-key-filename <key-filename>', 'gcs key filename', '')
+        .option('-gcsp --gcs-cache-prefix <prefix>', 'gcs cache prefix', '')
+        .option('-gcse --gcs-api-endpoint <api-endpoint>', 'gcs api endpoint', '')
         .option('-p --port <port>', 'port number')
         .option('-r --stream', 'stream mode')
         .option('-D --debug', 'debug mode')
@@ -101,6 +122,11 @@ export function createProgram() {
                 s3Region: options.s3Region,
                 s3Endpoint: options.s3Endpoint,
                 s3ForcePathStyle: options.s3ForcePathStyle === 'true',
+                gcsCacheBucket: options.gcsCacheBucket,
+                gcsCachePrefix: options.gcsCachePrefix,
+                gcsProjectId: options.gcsProjectId,
+                gcsKeyFilename: options.gcsKeyFilename,
+                gcsApiEndpoint: options.gcsApiEndpoint,
             }),
             port: parsePort(options.port),
             debug: parseDebug(options.debug),

package/dist/gcs.d.ts

@@ -0,0 +1,7 @@
+import { Storage } from '@google-cloud/storage';
+declare const getStorageClient: ({ projectId, keyFilename, apiEndpoint }: {
+    projectId?: string;
+    keyFilename?: string;
+    apiEndpoint?: string;
+}) => Storage;
+export { getStorageClient };

package/dist/gcs.js

@@ -0,0 +1,14 @@
+import { Storage } from '@google-cloud/storage';
+let storageClient; // singleton
+const getStorageClient = function ({ projectId, keyFilename, apiEndpoint }) {
+    if (storageClient !== undefined)
+        return storageClient;
+    const storageOptions = {
+        projectId,
+        keyFilename,
+        apiEndpoint
+    };
+    storageClient = new Storage(storageOptions);
+    return storageClient;
+};
+export { getStorageClient };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import { getRenderedBbox, getRenderedTile, GetRenderedBboxOptions, GetRenderedTileOptions } from './render/index.js';
+import { getRenderedBbox, getRenderedTile, getRenderedImage, GetRenderedBboxOptions, GetRenderedTileOptions, GetRenderedImageOptions } from './render/index.js';
 export declare function getRenderedBboxBuffer(options: GetRenderedBboxOptions): Promise<Buffer>;
 export { getRenderedBbox as getRenderedBboxStream };
+export declare function getRenderedImageBuffer(options: GetRenderedImageOptions): Promise<Buffer>;
+export { getRenderedImage as getRenderedImageStream };
 export declare function getRenderedTileBuffer(options: GetRenderedTileOptions): Promise<Buffer>;
 export { getRenderedTile as getRenderedTileStream };
 export * as ChiitilerCache from './cache/index.js';

package/dist/index.js

@@ -1,9 +1,14 @@
-import { getRenderedBbox, getRenderedTile, } from './render/index.js';
+import { getRenderedBbox, getRenderedTile, getRenderedImage, } from './render/index.js';
 export async function getRenderedBboxBuffer(options) {
     const sharp = await getRenderedBbox(options);
     return sharp.toBuffer();
 }
 export { getRenderedBbox as getRenderedBboxStream };
+export async function getRenderedImageBuffer(options) {
+    const sharp = await getRenderedImage(options);
+    return sharp.toBuffer();
+}
+export { getRenderedImage as getRenderedImageStream };
 export async function getRenderedTileBuffer(options) {
     const sharp = await getRenderedTile(options);
     return sharp.toBuffer();

package/dist/render/index.d.ts

@@ -23,4 +23,17 @@ type GetRenderedBboxOptions = {
     quality: number;
 };
 declare function getRenderedBbox({ stylejson, bbox, size, cache, ext, quality, }: GetRenderedBboxOptions): Promise<sharp.Sharp>;
-export { getRenderedTile, getRenderedBbox, type GetRenderedBboxOptions, type GetRenderedTileOptions, type SupportedFormat, };
+type GetRenderedImageOptions = {
+    stylejson: string | StyleSpecification;
+    cache: Cache;
+    ext: SupportedFormat;
+    quality: number;
+    bearing: number;
+    pitch: number;
+    zoom: number;
+    center: [number, number];
+    height: number;
+    width: number;
+};
+declare function getRenderedImage(options: GetRenderedImageOptions): Promise<sharp.Sharp>;
+export { getRenderedTile, getRenderedBbox, getRenderedImage, type GetRenderedBboxOptions, type GetRenderedTileOptions, type GetRenderedImageOptions, type SupportedFormat, };

package/dist/render/index.js

@@ -121,7 +121,7 @@ async function getRenderedBbox({ stylejson, bbox, size, cache, ext, quality, })
         height,
         center,
     }, cache, 'static');
-    let _sharp = sharp(pixels, {
+    const _sharp = sharp(pixels, {
         raw: {
             width,
             height,
@@ -138,4 +138,31 @@ async function getRenderedBbox({ stylejson, bbox, size, cache, ext, quality, })
             return _sharp.webp({ quality, effort: 0 });
     }
 }
-export { getRenderedTile, getRenderedBbox, };
+async function getRenderedImage(options) {
+    const style = await loadStyle(options.stylejson, options.cache);
+    const pixels = await render(style, {
+        center: options.center,
+        height: options.height,
+        width: options.width,
+        zoom: options.zoom,
+        bearing: options.bearing,
+        pitch: options.pitch,
+    }, options.cache, 'static');
+    const _sharp = sharp(pixels, {
+        raw: {
+            width: options.width,
+            height: options.height,
+            channels: 4,
+        },
+    });
+    switch (options.ext) {
+        case 'png':
+            return _sharp.png();
+        case 'jpeg':
+        case 'jpg':
+            return _sharp.jpeg({ quality: options.quality });
+        case 'webp':
+            return _sharp.webp({ quality: options.quality, effort: 0 });
+    }
+}
+export { getRenderedTile, getRenderedBbox, getRenderedImage, };

package/dist/server/index.d.ts

@@ -8,8 +8,6 @@ type InitServerOptions = {
 };
 type InitializedServer = {
     app: Hono;
-    tiles: Hono;
-    clip: Hono;
     start: () => void;
 };
 declare function initServer(options: InitServerOptions): InitializedServer;

package/dist/server/index.js

@@ -1,230 +1,43 @@
 import { Hono } from 'hono/quick';
-import { stream } from 'hono/streaming';
 import { serve } from '@hono/node-server';
-import { validateStyleMin, } from '@maplibre/maplibre-gl-style-spec';
 import { getDebugPage, getEditorgPage } from './debug.js';
-import { getRenderedTile, getRenderedBbox, } 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);
-}
+import { createClipRouter } from './routes/clip.js';
+import { createTilesRouter } from './routes/tiles.js';
+import { createCameraRouter } from './routes/camera.js';
 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);
-        c.header('Content-Type', `image/${ext}`);
-        try {
-            const sharp = await getRenderedTile({
-                stylejson: url,
-                z,
-                x,
-                y,
-                tileSize,
-                cache: options.cache,
-                margin,
-                ext,
-                quality,
-            });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
-        }
-        catch (e) {
-            console.error(`render error: ${e}`);
-            return c.body('failed to render tile', 400);
-        }
-    })
-        .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);
-        c.header('Content-Type', `image/${ext}`);
-        try {
-            const sharp = await getRenderedTile({
-                stylejson: style,
-                z,
-                x,
-                y,
-                tileSize,
-                cache: options.cache,
-                margin,
-                ext,
-                quality,
-            });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
-        }
-        catch (e) {
-            console.error(`render error: ${e}`);
-            return c.body('failed to render tile', 400);
-        }
-    });
-    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);
-        c.header('Content-Type', `image/${ext}`);
-        try {
-            const sharp = await getRenderedBbox({
-                stylejson: url,
-                bbox: [minx, miny, maxx, maxy],
-                size,
-                cache: options.cache,
-                ext,
-                quality,
-            });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
-        }
-        catch (e) {
-            console.error(`render error: ${e}`);
-            return c.body('failed to render tile', 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);
-        c.header('Content-Type', `image/${ext}`);
-        try {
-            const sharp = await getRenderedBbox({
-                stylejson: style,
-                bbox: [minx, miny, maxx, maxy],
-                size,
-                cache: options.cache,
-                ext,
-                quality,
-            });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
-        }
-        catch (e) {
-            console.error(`render error: ${e}`);
-            return c.body('failed to render tile', 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);
+    hono.route('/static', createCameraRouter({
+        cache: options.cache,
+        stream: options.stream,
+    }));
+    hono.route('/tiles', createTilesRouter({
+        cache: options.cache,
+        stream: options.stream,
+    }));
+    hono.route('/', createClipRouter({
+        cache: options.cache,
+        stream: options.stream,
+    }));
     return {
         app: hono,
-        tiles,
-        clip,
-        start: () => serve({ port: options.port, fetch: hono.fetch }),
+        start: () => {
+            const server = serve({ port: options.port, fetch: hono.fetch });
+            process.on('SIGINT', () => {
+                console.log('shutting down server...');
+                server.close();
+                process.exit(0);
+            });
+            process.on('SIGTERM', () => {
+                console.log('shutting down server...');
+                server.close();
+                process.exit(0);
+            });
+        },
     };
 }
 export { initServer };

package/dist/server/routes/camera.d.ts

@@ -0,0 +1,36 @@
+import { Cache } from '../../cache/index.js';
+declare function createCameraRouter(options: {
+    cache: Cache;
+    stream: boolean;
+}): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {
+    "/:camera/:dimensions_ext": {
+        $get: {
+            input: {
+                param: {
+                    camera: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    "/:camera/:dimensions_ext": {
+        $post: {
+            input: {
+                param: {
+                    camera: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+}, "/", "/:camera/:dimensions_ext">;
+export { createCameraRouter };

package/dist/server/routes/camera.js

@@ -0,0 +1,128 @@
+import { Hono } from 'hono';
+import { stream } from 'hono/streaming';
+import { isSupportedFormat, isValidCamera, isValidDimensions, isValidStylejson, } from '../utils.js';
+import { getRenderedImage } from '../../render/index.js';
+function createCameraRouter(options) {
+    const camera = new Hono()
+        .get('/:camera/:dimensions_ext', async (c) => {
+        // path params
+        const camera = c.req
+            .param('camera')
+            .match(/([\d.]+),([\d.]+),([\d.]+)(?:@(\d+)(?:,(\d+))?)?/);
+        const [_dimensions, ext] = c.req.param('dimensions_ext').split('.');
+        const dimensions = _dimensions.match(/(\d+)x(\d+)?/);
+        if (!camera || !isValidCamera(camera))
+            return c.body('invalid camera', 400);
+        if (!dimensions || !isValidDimensions(dimensions))
+            return c.body('invalid dimensions', 400);
+        if (!isSupportedFormat(ext))
+            return c.body('invalid format', 400);
+        const [, _lon, _lat, _zoom, _bearing, _pitch] = camera;
+        const [, _width, _height] = dimensions;
+        const lat = Number(_lat);
+        const lon = Number(_lon);
+        const zoom = Number(_zoom);
+        const bearing = Number(_bearing ?? 0);
+        const pitch = Number(_pitch ?? 0);
+        const height = Number(_height);
+        const width = Number(_width);
+        // query params
+        const url = c.req.query('url');
+        if (url === undefined)
+            return c.body('url is required', 400);
+        const quality = Number(c.req.query('quality') ?? 100);
+        c.header('Content-Type', `image/${ext}`);
+        try {
+            const sharp = await getRenderedImage({
+                stylejson: url,
+                cache: options.cache,
+                ext,
+                quality,
+                center: [lon, lat],
+                zoom,
+                bearing,
+                pitch,
+                height,
+                width,
+            });
+            if (options.stream) {
+                // stream mode
+                return stream(c, async (stream) => {
+                    for await (const chunk of sharp) {
+                        stream.write(chunk);
+                    }
+                });
+            }
+            else {
+                const buf = await sharp.toBuffer();
+                return c.body(buf);
+            }
+        }
+        catch (e) {
+            console.error(`render error: ${e}`);
+            return c.body('failed to render static image', 400);
+        }
+    })
+        .post('/:camera/:dimensions_ext', async (c) => {
+        // body
+        const { style } = await c.req.json();
+        if (!isValidStylejson(style))
+            return c.body('invalid stylejson', 400);
+        // path params
+        const camera = c.req
+            .param('camera')
+            .match(/([\d.]+),([\d.]+),([\d.]+)(?:@(\d+)(?:,(\d+))?)?/);
+        const [_dimensions, ext] = c.req.param('dimensions_ext').split('.');
+        const dimensions = _dimensions.match(/(\d+)x(\d+)?/);
+        if (!camera || !isValidCamera(camera))
+            return c.body('invalid camera', 400);
+        if (!dimensions || !isValidDimensions(dimensions))
+            return c.body('invalid dimensions', 400);
+        if (!isSupportedFormat(ext))
+            return c.body('invalid format', 400);
+        const [, _lon, _lat, _zoom, _bearing, _pitch] = camera;
+        const [, _width, _height] = dimensions;
+        const lat = Number(_lat);
+        const lon = Number(_lon);
+        const zoom = Number(_zoom);
+        const bearing = Number(_bearing ?? 0);
+        const pitch = Number(_pitch ?? 0);
+        const height = Number(_height);
+        const width = Number(_width);
+        // query params
+        const quality = Number(c.req.query('quality') ?? 100);
+        c.header('Content-Type', `image/${ext}`);
+        try {
+            const sharp = await getRenderedImage({
+                stylejson: style,
+                cache: options.cache,
+                ext,
+                quality,
+                center: [lon, lat],
+                zoom,
+                bearing,
+                pitch,
+                height,
+                width,
+            });
+            if (options.stream) {
+                // stream mode
+                return stream(c, async (stream) => {
+                    for await (const chunk of sharp) {
+                        stream.write(chunk);
+                    }
+                });
+            }
+            else {
+                const buf = await sharp.toBuffer();
+                return c.body(buf);
+            }
+        }
+        catch (e) {
+            console.error(`render error: ${e}`);
+            return c.body('failed to render static image', 400);
+        }
+    });
+    return camera;
+}
+export { createCameraRouter };

package/dist/server/routes/clip.d.ts

@@ -0,0 +1,32 @@
+import { Cache } from '../../cache/index.js';
+declare function createClipRouter(options: {
+    cache: Cache;
+    stream: boolean;
+}): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {
+    "/:filename_ext": {
+        $get: {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    "/:filename_ext": {
+        $post: {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+}, "/", "/:filename_ext">;
+export { createClipRouter };