(refs #469) refactor tile choosing function

src/lib/geolonia-map.test.ts

@@ -0,0 +1,136 @@
+'use strict';
+
+import assert from 'assert';
+import {
+  transformGeoloniaApiSource,
+  transformGeoloniaTileSource,
+  transformGeoloniaSprite,
+} from './transform-request';
+
+describe('transformGeoloniaApiSource', () => {
+  const sourcesUrl = new URL('https://api.geolonia.com/sources?key=test-key&sessionId=abc123');
+
+  it('should redirect api.geolonia.com URLs to sourcesUrl', () => {
+    const result = transformGeoloniaApiSource(
+      'https://api.geolonia.com/some/path',
+      sourcesUrl,
+    );
+    assert.deepStrictEqual(result, { url: sourcesUrl.toString() });
+  });
+
+  it('should return null for non-Geolonia URLs', () => {
+    const result = transformGeoloniaApiSource(
+      'https://example.com/tiles',
+      sourcesUrl,
+    );
+    assert.strictEqual(result, null);
+  });
+});
+
+describe('transformGeoloniaTileSource', () => {
+  const atts = { key: 'test-key', stage: 'v1' };
+  const sessionId = 'session123';
+
+  it('should transform geolonia:// tile URLs and inject key/sessionId', () => {
+    const result = transformGeoloniaTileSource(
+      'geolonia://tiles/myuser/my-tileset',
+      atts,
+      sessionId,
+    );
+    assert.ok(result);
+    const url = new URL(result.url);
+    assert.strictEqual(url.hostname, 'tileserver.geolonia.com');
+    assert.strictEqual(url.pathname, '/customtiles/my-tileset/tiles.json');
+    assert.strictEqual(url.searchParams.get('key'), 'test-key');
+    assert.strictEqual(url.searchParams.get('sessionId'), 'session123');
+  });
+
+  it('should inject key/sessionId into Geolonia tiles host URLs', () => {
+    const result = transformGeoloniaTileSource(
+      'https://tileserver.geolonia.com/some/path',
+      atts,
+      sessionId,
+    );
+    assert.ok(result);
+    const url = new URL(result.url);
+    assert.strictEqual(url.searchParams.get('key'), 'test-key');
+    assert.strictEqual(url.searchParams.get('sessionId'), 'session123');
+  });
+
+  it('should switch to dev hostname when stage is dev', () => {
+    const devAtts = { key: 'test-key', stage: 'dev' };
+    const result = transformGeoloniaTileSource(
+      'https://tileserver.geolonia.com/some/path',
+      devAtts,
+      sessionId,
+    );
+    assert.ok(result);
+    const url = new URL(result.url);
+    assert.strictEqual(url.hostname, 'tileserver-dev.geolonia.com');
+  });
+
+  it('should return null for non-Geolonia URLs', () => {
+    const result = transformGeoloniaTileSource(
+      'https://example.com/tiles',
+      atts,
+      sessionId,
+    );
+    assert.strictEqual(result, null);
+  });
+
+  it('should handle *.tiles.geolonia.com hosts', () => {
+    const result = transformGeoloniaTileSource(
+      'https://foo.tiles.geolonia.com/path',
+      atts,
+      sessionId,
+    );
+    assert.ok(result);
+    const url = new URL(result.url);
+    assert.strictEqual(url.searchParams.get('key'), 'test-key');
+  });
+});
+
+describe('transformGeoloniaSprite', () => {
+  const atts = { key: 'test-key', stage: 'v1' };
+
+  it('should inject key and correct stage into Geolonia sprite URLs', () => {
+    const result = transformGeoloniaSprite(
+      'https://api.geolonia.com/dev/sprites/basic-v2/sprite',
+      atts,
+    );
+    assert.ok(result);
+    const url = new URL(result.url);
+    assert.strictEqual(url.pathname, '/v1/sprites/basic-v2/sprite');
+    assert.strictEqual(url.searchParams.get('key'), 'test-key');
+  });
+
+  it('should handle v1 stage in URL', () => {
+    const result = transformGeoloniaSprite(
+      'https://api.geolonia.com/v1/sprites/basic-v2/sprite',
+      atts,
+    );
+    assert.ok(result);
+    const url = new URL(result.url);
+    assert.strictEqual(url.pathname, '/v1/sprites/basic-v2/sprite');
+    assert.strictEqual(url.searchParams.get('key'), 'test-key');
+  });
+
+  it('should return null for non-Geolonia sprite URLs', () => {
+    const result = transformGeoloniaSprite(
+      'https://example.com/sprites/basic/sprite.json',
+      atts,
+    );
+    assert.strictEqual(result, null);
+  });
+
+  it('should switch stage from v1 to dev when atts.stage is dev', () => {
+    const devAtts = { key: 'test-key', stage: 'dev' };
+    const result = transformGeoloniaSprite(
+      'https://api.geolonia.com/v1/sprites/basic-v2/sprite',
+      devAtts,
+    );
+    assert.ok(result);
+    const url = new URL(result.url);
+    assert.strictEqual(url.pathname, '/dev/sprites/basic-v2/sprite');
+  });
+});

src/lib/geolonia-map.ts

@@ -32,8 +32,12 @@ import {
   handleErrorMode,
   loadImageCompatibility,
   GetImageCallback,
-  isGeoloniaTilesHost,
 } from './util';
+import {
+  transformGeoloniaApiSource,
+  transformGeoloniaTileSource,
+  transformGeoloniaSprite,
+} from './transform-request';
 
 export type GeoloniaMapOptions = MapOptions & { interactive?: boolean };
 
@@ -126,63 +130,28 @@ export default class GeoloniaMap extends maplibregl.Map {
     // Pass API key and requested tile version to `/sources` (tile json).
     const _transformRequest = options.transformRequest;
     options.transformRequest = (url, resourceType) => {
-      if (
-        resourceType === 'Source' &&
-        url.startsWith('https://api.geolonia.com')
-      ) {
-        return {
-          url: sourcesUrl.toString(),
-        };
-      }
-
-      let transformedUrl = url;
-      if (url.startsWith('geolonia://')) {
-        const tilesMatch = url.match(
-          /^geolonia:\/\/tiles\/(?<username>.+)\/(?<customtileId>.+)/,
+      if (resourceType === 'Source') {
+        return (
+          transformGeoloniaApiSource(url, sourcesUrl) ??
+          transformGeoloniaTileSource(url, atts, sessionId) ??
+          (typeof _transformRequest === 'function'
+            ? _transformRequest(url, resourceType)
+            : undefined)
         );
-        if (tilesMatch) {
-          transformedUrl = `https://tileserver.geolonia.com/customtiles/${tilesMatch.groups.customtileId}/tiles.json`;
-        }
       }
 
-      const transformedUrlObj = new URL(transformedUrl);
-      const geoloniaTilesHost = isGeoloniaTilesHost(transformedUrlObj);
-
-      // Geolonia ドメインのみに API キーを付与（外部 URL には付与しない）
-      if (
-        resourceType === 'Source' &&
-        geoloniaTilesHost
-      ) {
-        if (atts.stage === 'dev') {
-          transformedUrlObj.hostname = 'tileserver-dev.geolonia.com';
-        }
-        transformedUrlObj.searchParams.set('sessionId', sessionId);
-        transformedUrlObj.searchParams.set('key', atts.key);
-        return {
-          url: transformedUrlObj.toString(),
-        };
-      } else if (
-        (resourceType === 'SpriteJSON' || resourceType === 'SpriteImage') &&
-        transformedUrl.match(
-          /^https:\/\/api\.geolonia\.com\/(dev|v1)\/sprites\//,
-        )
-      ) {
-        const pathParts = transformedUrlObj.pathname.split('/');
-        pathParts[1] = String(atts.stage);
-        transformedUrlObj.pathname = pathParts.join('/');
-        transformedUrlObj.searchParams.set('key', atts.key);
-        return {
-          url: transformedUrlObj.toString(),
-        };
+      if (resourceType === 'SpriteJSON' || resourceType === 'SpriteImage') {
+        return (
+          transformGeoloniaSprite(url, atts) ??
+          (typeof _transformRequest === 'function'
+            ? _transformRequest(url, resourceType)
+            : undefined)
+        );
       }
 
-      let request;
-      // Additional transformation
       if (typeof _transformRequest === 'function') {
-        request = _transformRequest(transformedUrl, resourceType);
+        return _transformRequest(url, resourceType);
       }
-
-      return request;
     };
 
     try {

src/lib/transform-request.ts

@@ -0,0 +1,61 @@
+import { isGeoloniaTilesHost } from './util';
+
+type RequestParameters = { url: string };
+type TransformAtts = { key: string; stage: string };
+
+/** Redirect Geolonia API source requests (style JSON sources) to the sourcesUrl */
+export function transformGeoloniaApiSource(
+  url: string,
+  sourcesUrl: URL,
+): RequestParameters | null {
+  if (url.startsWith('https://api.geolonia.com')) {
+    return { url: sourcesUrl.toString() };
+  }
+  return null;
+}
+
+/** Transform geolonia:// scheme and inject key/sessionId into Geolonia tile server sources */
+export function transformGeoloniaTileSource(
+  url: string,
+  atts: TransformAtts,
+  sessionId: string,
+): RequestParameters | null {
+  let transformedUrl = url;
+
+  if (url.startsWith('geolonia://')) {
+    const tilesMatch = url.match(
+      /^geolonia:\/\/tiles\/(?<username>.+)\/(?<customtileId>.+)/,
+    );
+    if (tilesMatch) {
+      transformedUrl = `https://tileserver.geolonia.com/customtiles/${tilesMatch.groups.customtileId}/tiles.json`;
+    }
+  }
+
+  const transformedUrlObj = new URL(transformedUrl);
+  if (!isGeoloniaTilesHost(transformedUrlObj)) {
+    return null;
+  }
+
+  if (atts.stage === 'dev') {
+    transformedUrlObj.hostname = 'tileserver-dev.geolonia.com';
+  }
+  transformedUrlObj.searchParams.set('sessionId', sessionId);
+  transformedUrlObj.searchParams.set('key', atts.key);
+  return { url: transformedUrlObj.toString() };
+}
+
+/** Inject key and correct stage into Geolonia sprite requests */
+export function transformGeoloniaSprite(
+  url: string,
+  atts: TransformAtts,
+): RequestParameters | null {
+  if (!url.match(/^https:\/\/api\.geolonia\.com\/(dev|v1)\/sprites\//)) {
+    return null;
+  }
+  const urlObj = new URL(url);
+  const pathParts = urlObj.pathname.split('/');
+  pathParts[1] = String(atts.stage);
+  urlObj.pathname = pathParts.join('/');
+  urlObj.searchParams.set('key', atts.key);
+  return { url: urlObj.toString() };
+}

src/types.ts

@@ -26,6 +26,7 @@ export type EmbedAttributes = {
   plugin: string;
   key: string;
   apiUrl: string;
+  stage: string;
   loader: string;
   minZoom: string | number;
   maxZoom: string | number;