chiitiler 1.14.2 → 1.16.0

package/dist/server/routes/clip.js

@@ -0,0 +1,104 @@
+import { Hono } from 'hono';
+import { stream } from 'hono/streaming';
+import { isSupportedFormat, isValidStylejson } from '../utils.js';
+import { getRenderedBbox } from '../../render/index.js';
+function createClipRouter(options) {
+    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);
+        }
+    });
+    return clip;
+}
+export { createClipRouter };

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

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

package/dist/server/routes/tiles.js

@@ -0,0 +1,113 @@
+import { Hono } from 'hono';
+import { stream } from 'hono/streaming';
+import { isSupportedFormat, isValidStylejson } from '../utils.js';
+import { getRenderedTile } from '../../render/index.js';
+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 createTilesRouter(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);
+        }
+    });
+    return tiles;
+}
+export { createTilesRouter };

package/dist/server/utils.d.ts

@@ -0,0 +1,7 @@
+import { type StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { SupportedFormat } from '../render/index.js';
+declare function isValidStylejson(stylejson: any): stylejson is StyleSpecification;
+declare function isValidCamera([, lon, lat, zoom, bearing, pitch]: string[]): boolean;
+declare function isValidDimensions([, width, height]: string[]): boolean;
+declare function isSupportedFormat(ext: string | undefined): ext is SupportedFormat;
+export { isValidStylejson, isValidCamera, isValidDimensions, isSupportedFormat, };

package/dist/server/utils.js

@@ -0,0 +1,28 @@
+import { validateStyleMin, } from '@maplibre/maplibre-gl-style-spec';
+function isValidStylejson(stylejson) {
+    return validateStyleMin(stylejson).length === 0;
+}
+function isValidCamera([, lon, lat, zoom, bearing, pitch]) {
+    if (Number.isNaN(Number(lat)) || Number(lat) < -90 || Number(lat) > 90)
+        return false;
+    if (Number.isNaN(Number(lon)) || Number(lon) < -180 || Number(lon) > 180)
+        return false;
+    if (Number.isNaN(Number(zoom)) || Number(zoom) < 0 || Number(zoom) > 24)
+        return false;
+    if (bearing &&
+        (Number.isNaN(Number(bearing)) ||
+            Number(bearing) < 0 ||
+            Number(bearing) > 360))
+        return false;
+    if (pitch &&
+        (Number.isNaN(Number(pitch)) || Number(pitch) < 0 || Number(pitch) > 180))
+        return false;
+    return true;
+}
+function isValidDimensions([, width, height]) {
+    return !Number.isNaN(Number(width)) && !Number.isNaN(Number(height));
+}
+function isSupportedFormat(ext) {
+    return Boolean(ext && ['png', 'jpeg', 'jpg', 'webp'].includes(ext));
+}
+export { isValidStylejson, isValidCamera, isValidDimensions, isSupportedFormat, };

package/dist/source/gcs.d.ts

@@ -0,0 +1,2 @@
+declare function getGCSSource(uri: string): Promise<Buffer<ArrayBufferLike> | null>;
+export { getGCSSource };

package/dist/source/gcs.js

@@ -0,0 +1,21 @@
+import { getStorageClient } from '../gcs.js';
+async function getGCSSource(uri) {
+    const storageClient = getStorageClient({
+        projectId: process.env.CHIITILER_GCS_PROJECT_ID,
+        keyFilename: process.env.CHIITILER_GCS_KEY_FILENAME,
+        apiEndpoint: process.env.CHIITILER_GCS_API_ENDPOINT,
+    });
+    const bucket = uri.replace('gs://', '').split('/')[0];
+    const path = uri.replace(`gs://${bucket}/`, '');
+    try {
+        const file = storageClient.bucket(bucket).file(path);
+        const [buffer] = await file.download();
+        return buffer;
+    }
+    catch (e) {
+        if (e.code !== 404)
+            console.log(e);
+        return null;
+    }
+}
+export { getGCSSource };

package/dist/source/index.js

@@ -3,6 +3,7 @@ import { getHttpSource } from './http.js';
 import { getPmtilesSource } from './pmtiles.js';
 import { getMbtilesSource } from './mbtiles.js';
 import { getS3Source } from './s3.js';
+import { getGCSSource } from './gcs.js';
 import { getCogSource } from './cog.js';
 import { noneCache } from '../cache/index.js';
 /**
@@ -19,6 +20,8 @@ async function getSource(uri, cache = noneCache()) {
         data = await getFilesystemSource(uri);
     else if (uri.startsWith('s3://'))
         data = await getS3Source(uri);
+    else if (uri.startsWith('gs://'))
+        data = await getGCSSource(uri);
     else if (uri.startsWith('mbtiles://'))
         data = await getMbtilesSource(uri);
     else if (uri.startsWith('pmtiles://'))

package/dist/source/pmtiles.js

@@ -50,8 +50,7 @@ class S3Source {
             }));
         }
         catch (e) {
-            if (e instanceof Error &&
-                e.name === 'PreconditionFailed') {
+            if (e instanceof Error && e.name === 'PreconditionFailed') {
                 throw new Error('etag mismatch');
             }
             throw e;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "chiitiler",
-	"version": "1.14.2",
+	"version": "1.16.0",
 	"description": "Tiny map rendering server for MapLibre Style Spec",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -10,6 +10,7 @@
 	],
 	"scripts": {
 		"build": "npx esbuild --bundle src/main.ts --minify --outfile=build/main.cjs --platform=node --external:@maplibre/maplibre-gl-native --external:sharp",
+		"check": "tsc --noEmit",
 		"dev": "tsx watch src/main.ts tile-server -D",
 		"test:unit": "vitest src",
 		"test:coverage": "vitest src --coverage --coverage.provider=v8",
@@ -19,34 +20,37 @@
 	"keywords": [],
 	"author": "Kanahiro Iguchi",
 	"license": "MIT",
+	"repository": {
+		"url": "https://github.com/Kanahiro/chiitiler"
+	},
 	"devDependencies": {
-		"@tsconfig/node20": "^20.1.4",
-		"@types/better-sqlite3": "^7.6.10",
-		"@types/node": "^20.6.0",
-		"@vitest/coverage-v8": "^1.6.0",
-		"esbuild": "^0.25.0",
+		"@tsconfig/node24": "^24.0.0",
+		"@types/better-sqlite3": "^7.6.13",
+		"@types/node": "^24.0.0",
+		"@vitest/coverage-v8": "^4.0.16",
+		"esbuild": "^0.27.2",
 		"image-size": "^1.1.1",
-		"ts-node": "^10.9.1",
-		"tsx": "^4.7.1",
-		"typescript": "^5.2.2",
-		"vitest": "^1.6.0"
+		"tsx": "^4.21.0",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.16"
 	},
 	"dependencies": {
 		"@aws-sdk/client-s3": "^3.418.0",
-		"@hono/node-server": "^1.12.0",
+		"@google-cloud/storage": "^7.15.2",
+		"@hono/node-server": "^1.19.8",
 		"@mapbox/sphericalmercator": "^1.2.0",
 		"@mapbox/tilebelt": "^1.0.2",
-		"@maplibre/maplibre-gl-native": "^5.4.0",
-		"@maplibre/maplibre-gl-style-spec": "^20.2.0",
-		"better-sqlite3": "^9.6.0",
+		"@maplibre/maplibre-gl-native": "^6.3.0",
+		"@maplibre/maplibre-gl-style-spec": "^24.4.1",
+		"better-sqlite3": "12.6.0",
 		"commander": "^11.0.0",
 		"file-system-cache": "^2.4.4",
 		"higuruma": "^0.1.6",
-		"hono": "^4.5.4",
+		"hono": "^4.11.3",
 		"lightning-pool": "^4.2.2",
 		"lru-cache": "^11.0.0",
-		"maplibre-gl": "^3.3.1",
+		"maplibre-gl": "^5.15.0",
 		"pmtiles": "^3.0.5",
-		"sharp": "^0.32.5"
+		"sharp": "^0.34.5"
 	}
 }