chiitiler 1.25.2 → 1.25.3

package/README.md

@@ -14,7 +14,7 @@ Point it at any `style.json` and get back PNG / WebP / JPEG tiles, static images
 [![codecov](https://codecov.io/gh/Kanahiro/chiitiler/graph/badge.svg?token=9RVLAJG126)](https://codecov.io/gh/Kanahiro/chiitiler)
 [![License](https://img.shields.io/github/license/Kanahiro/chiitiler?color=blue)](./LICENSE)
 
-[Quickstart](#quickstart) · [HTTP API](#http-api) · [Library](#library-usage) · [Deployment](#deployment)
+[Live Demo](https://spatialty-io.github.io/chiitiler-demo/) · [Quickstart](#quickstart) · [HTTP API](#http-api) · [Library](#library-usage) · [Deployment](#deployment)
 
 </div>
 
@@ -36,10 +36,10 @@ http://localhost:3000/tiles/0/0/0.png?url=https://tile.openstreetmap.jp/styles/o
 
 You're done. That same endpoint works as an XYZ tile source for Leaflet, MapLibre, OpenLayers, QGIS, Cesium, or anywhere else that speaks `{z}/{x}/{y}`.
 
-> **No Docker?** `npx tsx` works too:
+> **No Docker?** Run it from source with [pnpm](https://pnpm.io):
 > ```bash
-> git clone https://github.com/Kanahiro/chiitiler && cd chiitiler && npm i
-> npx tsx src/main.ts tile-server --debug
+> git clone https://github.com/Kanahiro/chiitiler && cd chiitiler && pnpm install
+> pnpm tsx src/main.ts tile-server --debug
 > ```
 > Then visit `http://localhost:3000/debug` to preview styles interactively.
 
@@ -230,17 +230,18 @@ const cache = ChiitilerCache.withMemoryCache(
 
 ## Develop
 
-Requires Node.js 24.12+ and `sharp` system deps (see [Dockerfile](./Dockerfile)).
+Requires Node.js 24.22.1+, pnpm (`corepack enable`) and `sharp` system deps (see [Dockerfile](./Dockerfile)).
 
 ```bash
 git clone https://github.com/Kanahiro/chiitiler.git
 cd chiitiler
-npm install
-npm run dev              # tsx watch mode
-npm run test:unit        # vitest
-npm run test:integration # end-to-end
-npm run test:benchmark   # see bench/BENCHMARK.md
-npm run build            # bundle to build/main.cjs
+pnpm install
+pnpm dev              # tsx watch mode
+pnpm lint             # biome lint + format check
+pnpm test:unit        # vitest
+pnpm test:integration # end-to-end
+pnpm test:benchmark   # see bench/BENCHMARK.md
+pnpm build            # bundle to build/main.cjs
 ```
 
 ## Architecture

package/dist/cache/file.d.ts

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

package/dist/cache/file.js

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

package/dist/cache/front.js

@@ -37,12 +37,15 @@ export function withMemoryCache(backing, { ttlSeconds = 10, maxBytes = 64 * 1024
             const pending = reads.get(key);
             if (pending !== undefined)
                 return pending;
-            const read = backing.get(key).then((value) => {
+            const read = backing
+                .get(key)
+                .then((value) => {
                 // A newer write must not be overwritten by an older read.
                 if (value !== undefined && reads.get(key) === read)
                     memory.set(key, value);
                 return value;
-            }).finally(() => {
+            })
+                .finally(() => {
                 if (reads.get(key) === read)
                     reads.delete(key);
             });

package/dist/cache/gcs.d.ts

@@ -1,4 +1,4 @@
-import { type Cache } from './index.js';
+import type { Cache } from './index.js';
 type GCSCacheOptions = {
     bucket: string;
     prefix?: string;
@@ -7,4 +7,4 @@ type GCSCacheOptions = {
     apiEndpoint?: string;
 };
 declare function gcsCache(options: GCSCacheOptions): Cache;
-export { gcsCache };
+export { gcsCache, type GCSCacheOptions };

package/dist/cache/gcs.js

@@ -11,12 +11,14 @@ function gcsCache(options) {
     const bucket = storageClient.bucket(options.bucket);
     function bucketFile(key) {
         const name = escapeFileName(key);
-        const nameWithPrefix = options.prefix ? `${options.prefix}/${name}` : name;
+        const nameWithPrefix = options.prefix
+            ? `${options.prefix}/${name}`
+            : name;
         return bucket.file(nameWithPrefix);
     }
     return {
         name: 'gcs',
-        set: async function (key, value) {
+        set: async (key, value) => {
             const file = bucketFile(key);
             try {
                 await file.save(value, {
@@ -27,7 +29,7 @@ function gcsCache(options) {
                 console.log(`[error]: ${e}`);
             }
         },
-        get: async function (key) {
+        get: async (key) => {
             const file = bucketFile(key);
             try {
                 const [content] = await file.download();

package/dist/cache/index.d.ts

@@ -3,6 +3,10 @@ import { s3Cache } from './s3.js';
 import { gcsCache } from './gcs.js';
 import { fileCache } from './file.js';
 export { withMemoryCache } from './front.js';
+export type { MemoryCacheOptions } from './memory.js';
+export type { S3CacheOptions } from './s3.js';
+export type { GCSCacheOptions } from './gcs.js';
+export type { fileCacheOptions } from './file.js';
 type Value = Buffer;
 type Cache = {
     name: string;
@@ -12,4 +16,4 @@ type Cache = {
     memory?: Cache;
 };
 declare const noneCache: () => Cache;
-export { noneCache, memoryCache, s3Cache, gcsCache, fileCache, type Value, type Cache };
+export { noneCache, memoryCache, s3Cache, gcsCache, fileCache, type Value, type Cache, };

package/dist/cache/index.js

@@ -8,4 +8,4 @@ const noneCache = () => ({
     get: async () => undefined,
     set: async () => undefined,
 });
-export { noneCache, memoryCache, s3Cache, gcsCache, fileCache };
+export { noneCache, memoryCache, s3Cache, gcsCache, fileCache, };

package/dist/cache/memory.d.ts

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

package/dist/cache/memory.js

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

package/dist/cache/s3.d.ts

@@ -1,4 +1,4 @@
-import { type Cache } from './index.js';
+import type { Cache } from './index.js';
 type S3CacheOptions = {
     bucket: string;
     region: string;
@@ -6,4 +6,4 @@ type S3CacheOptions = {
     forcePathStyle?: boolean;
 };
 declare function s3Cache(options: S3CacheOptions): Cache;
-export { s3Cache };
+export { s3Cache, type S3CacheOptions };

package/dist/cache/s3.js

@@ -8,7 +8,7 @@ function s3Cache(options) {
     });
     return {
         name: 's3',
-        set: async function (key, value) {
+        set: async (key, value) => {
             try {
                 const cmd = new PutObjectCommand({
                     Bucket: options.bucket,
@@ -21,7 +21,7 @@ function s3Cache(options) {
                 console.log(`[error]: ${e}`);
             }
         },
-        get: async function (key) {
+        get: async (key) => {
             const cmd = new GetObjectCommand({
                 Bucket: options.bucket,
                 Key: escapeFileName(key),

package/dist/cli.js

@@ -112,16 +112,21 @@ export function createProgram() {
         .option('-p, --port <port>', 'port number')
         .option('--user-agent <user-agent>', 'User-Agent header for outbound HTTP requests')
         .addOption(new Option('--prewarm [boolean]', 'startup renderer warmup')
-        .choices(['true', 'false']).preset('true').env('CHIITILER_PREWARM').default('true'))
+        .choices(['true', 'false'])
+        .preset('true')
+        .env('CHIITILER_PREWARM')
+        .default('true'))
         .addOption(new Option('--processes <n>', 'worker processes (0 for all CPUs)')
-        .env('CHIITILER_PROCESSES').argParser(parseProcesses).default(1))
-        .addOption(new Option('--front-cache-ttl-sec <seconds>', 'memory front cache TTL (0 to disable)')
-        .env('CHIITILER_FRONT_CACHE_TTL_SEC'))
-        .addOption(new Option('--front-cache-max-bytes <bytes>', 'memory front cache byte limit (0 to disable)')
-        .env('CHIITILER_FRONT_CACHE_MAX_BYTES'))
+        .env('CHIITILER_PROCESSES')
+        .argParser(parseProcesses)
+        .default(1))
+        .addOption(new Option('--front-cache-ttl-sec <seconds>', 'memory front cache TTL (0 to disable)').env('CHIITILER_FRONT_CACHE_TTL_SEC'))
+        .addOption(new Option('--front-cache-max-bytes <bytes>', 'memory front cache byte limit (0 to disable)').env('CHIITILER_FRONT_CACHE_MAX_BYTES'))
         .option('-D, --debug', 'debug mode')
         .action(async (options) => {
-        const numProcesses = options.processes === 0 ? availableParallelism() : options.processes;
+        const numProcesses = options.processes === 0
+            ? availableParallelism()
+            : options.processes;
         if (cluster.isPrimary && numProcesses !== 1) {
             // Workers inherit argv and env, and initialize their own renderer and cache.
             for (let i = 0; i < numProcesses; i++)
@@ -154,8 +159,12 @@ export function createProgram() {
             const ttl = options.frontCacheTtlSec;
             const size = options.frontCacheMaxBytes;
             serverOptions.cache = caches.withMemoryCache(serverOptions.cache, {
-                ttlSeconds: ttl === undefined ? undefined : Number(ttl.trim() || NaN),
-                maxBytes: size === undefined ? undefined : Number(size.trim() || NaN),
+                ttlSeconds: ttl === undefined
+                    ? undefined
+                    : Number(ttl.trim() || NaN),
+                maxBytes: size === undefined
+                    ? undefined
+                    : Number(size.trim() || NaN),
             });
         }
         if (serverOptions.debug) {

package/dist/gcs.d.ts

@@ -1,5 +1,5 @@
 import { Storage } from '@google-cloud/storage';
-declare const getStorageClient: ({ projectId, keyFilename, apiEndpoint }: {
+declare const getStorageClient: ({ projectId, keyFilename, apiEndpoint, }: {
     projectId?: string;
     keyFilename?: string;
     apiEndpoint?: string;

package/dist/gcs.js

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

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { getRenderedClip, getRenderedTile, getRenderedCamera, GetRenderedClipOptions, GetRenderedTileOptions, GetRenderedCameraOptions } from './render/index.js';
+import { getRenderedClip, getRenderedTile, getRenderedCamera, type GetRenderedClipOptions, type GetRenderedTileOptions, type GetRenderedCameraOptions } from './render/index.js';
 export declare function getRenderedClipBuffer(options: GetRenderedClipOptions): Promise<Buffer>;
 export { getRenderedClip as getRenderedClipStream };
 export declare function getRenderedCameraBuffer(options: GetRenderedCameraOptions): Promise<Buffer>;

package/dist/main.js

@@ -1,6 +1,8 @@
 import process from 'node:process';
 import { createProgram } from './cli.js';
-createProgram().parseAsync(process.argv).catch((error) => {
+createProgram()
+    .parseAsync(process.argv)
+    .catch((error) => {
     console.error(error);
     process.exitCode = 1;
 });

package/dist/render/pool.js

@@ -20,7 +20,7 @@ async function getRenderPool(style, cache, mode) {
     const newPool = new Pool({
         create: () => {
             const map = new mbgl.Map({
-                request: function (req, callback) {
+                request: (req, callback) => {
                     getSource(req.url, cache)
                         .then((buf) => {
                         if (buf !== null && buf.length > 0) {
@@ -41,7 +41,7 @@ async function getRenderPool(style, cache, mode) {
                     });
                 },
                 ratio: 1,
-                // @ts-ignore
+                // @ts-expect-error
                 mode,
             });
             map.load(style);

package/dist/render/rasterize.js

@@ -10,7 +10,7 @@ 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) {
+        worker.render(renderOptions, (err, buffer) => {
             pool.release(worker);
             if (err) {
                 reject(err);

package/dist/s3.js

@@ -1,6 +1,6 @@
 import { S3Client } from '@aws-sdk/client-s3';
 let s3Client; // singleton
-const getS3Client = function ({ region, endpoint, forcePathStyle, }) {
+const getS3Client = ({ region, endpoint, forcePathStyle, }) => {
     if (s3Client !== undefined)
         return s3Client;
     const s3ClientConfig = {

package/dist/server/debug.d.ts

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

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import { Hono } from 'hono/quick';
-import { type Cache } from '../cache/index.js';
+import type { Cache } from '../cache/index.js';
 type InitServerOptions = {
     cache: Cache;
     port: number;

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

@@ -1,4 +1,4 @@
-import { Cache } from '../../cache/index.js';
+import type { Cache } from '../../cache/index.js';
 declare function createCameraRouter(options: {
     cache: Cache;
 }): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {

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

@@ -1,4 +1,4 @@
-import { Cache } from '../../cache/index.js';
+import type { Cache } from '../../cache/index.js';
 declare function createClipRouter(options: {
     cache: Cache;
 }): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {

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

@@ -1,4 +1,4 @@
-import { Cache } from '../../cache/index.js';
+import type { Cache } from '../../cache/index.js';
 declare function createTilesRouter(options: {
     cache: Cache;
 }): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {

package/dist/server/routes/tiles.js

@@ -17,7 +17,7 @@ function createTilesRouter(options) {
         // 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, ext] = c.req.param('y_ext').split('.');
         const y = Number(_y);
         if (!isValidXyz(x, y, z))
             return c.body('invalid xyz', 400);
@@ -59,7 +59,7 @@ function createTilesRouter(options) {
         // 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, ext] = c.req.param('y_ext').split('.');
         const y = Number(_y);
         if (!isValidXyz(x, y, z))
             return c.body('invalid xyz', 400);

package/dist/source/index.d.ts

@@ -1,4 +1,4 @@
-import { Cache } from '../cache/index.js';
+import { type Cache } from '../cache/index.js';
 /**
  * retrieve sources from the uri.
  * Concurrent requests for the same uri share a single in-flight fetch

package/dist/source/mbtiles.js

@@ -26,7 +26,7 @@ async function getMbtilesSource(uri) {
     const [z, x, y] = uri
         .replace(`mbtiles://${mbtilesFilepath}/`, '')
         .split('/');
-    const ty = Math.pow(2, Number(z)) - 1 - Number(y);
+    const ty = 2 ** Number(z) - 1 - Number(y);
     const row = statement.get(z, x, ty);
     if (!row)
         return null;

package/dist/source/pmtiles.js

@@ -51,7 +51,8 @@ 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;
@@ -111,7 +112,9 @@ async function getPmtilesSource(uri, cache = noneCache()) {
         }
     }
     const [z, x, y] = uri.replace(`pmtiles://${pmtilesUri}/`, '').split('/');
-    const tile = await pmtiles.getZxy(Number(z), Number(x), Number(y)).catch((err) => {
+    const tile = await pmtiles
+        .getZxy(Number(z), Number(x), Number(y))
+        .catch((err) => {
         // SharedPromiseCache retains rejected metadata promises. Rebuild after a
         // failure, without evicting a replacement created by a newer request.
         if (pmtilesCache.get(pmtilesUri) === pmtiles)

package/package.json

@@ -1,21 +1,27 @@
 {
   "type": "module",
   "name": "chiitiler",
-  "version": "1.25.2",
+  "version": "1.25.3",
   "description": "Tiny map rendering server for MapLibre Style Spec",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=24.22.1"
+  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "npx esbuild --bundle src/main.ts --minify --outfile=build/main.cjs --platform=node --external:@maplibre/maplibre-gl-native --external:sharp",
+    "build": "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",
     "test:integration": "vitest tests/integration.test.ts",
-    "test:benchmark": "tsx tests/benchmark.ts"
+    "test:benchmark": "tsx tests/benchmark.ts",
+    "docs": "typedoc src/index.ts --out docs --includeVersion",
+    "lint": "biome check .",
+    "format": "biome check --write ."
   },
   "keywords": [],
   "author": "Kanahiro Iguchi",
@@ -24,6 +30,7 @@
     "url": "https://github.com/Kanahiro/chiitiler"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.6.6",
     "@tsconfig/node24": "^24.0.5",
     "@types/autocannon": "^7.12.7",
     "@types/node": "^25.9.6",
@@ -32,6 +39,7 @@
     "esbuild": "^0.28.2",
     "image-size": "^2.0.2",
     "tsx": "^4.23.13",
+    "typedoc": "^0.28.20",
     "typescript": "^6.0.3",
     "vitest": "^4.1.4"
   },
@@ -50,5 +58,6 @@
     "lru-cache": "^11.5.2",
     "pmtiles": "^4.5.0",
     "sharp": "^0.35.4"
-  }
+  },
+  "packageManager": "pnpm@12.18.0"
 }