@versatiles/style 3.7.0 → 3.8.1

package/README.MD

@@ -125,7 +125,7 @@ interface {
 
 ### Method: `colorful(options)`
 
-<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/c839905/src/index.ts#L4">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/be6dcfe/src/index.ts#L4">\[src]</a></sup>
 
 **Parameters:**
 
@@ -135,7 +135,7 @@ interface {
 
 ### Method: `graybeard(options)`
 
-<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/c839905/src/index.ts#L9">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/be6dcfe/src/index.ts#L9">\[src]</a></sup>
 
 **Parameters:**
 
@@ -145,7 +145,7 @@ interface {
 
 ### Method: `guessStyle(opt)`
 
-<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/c839905/src/lib/style_guesser.ts#L12">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/be6dcfe/src/lib/style_guesser.ts#L13">\[src]</a></sup>
 
 **Parameters:**
 
@@ -155,7 +155,7 @@ interface {
 
 ### Method: `neutrino(options)`
 
-<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/c839905/src/index.ts#L14">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/be6dcfe/src/index.ts#L14">\[src]</a></sup>
 
 **Parameters:**
 

package/dist/lib/shortbread/template.js

@@ -12,6 +12,7 @@ export default function getTemplate() {
         sprite: 'https://tiles.versatiles.org/sprites/sprites',
         sources: {
             'versatiles-shortbread': {
+                tilejson: '3.0.0',
                 attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
                 tiles: [
                     'https://tiles.versatiles.org/tiles/osm/{z}/{x}/{y}',

package/dist/lib/style_builder.js

@@ -3,7 +3,7 @@ import getShortbreadTemplate from './shortbread/template.js';
 import getShortbreadLayers from './shortbread/layers.js';
 import { decorate } from './decorator.js';
 import { getDefaultRecolorFlags, recolor } from './recolor.js';
-import { deepClone } from './utils.js';
+import { deepClone, resolveUrl } from './utils.js';
 // Stylemaker class definition
 export default class StyleBuilder {
     #sourceName = 'versatiles-shortbread';
@@ -70,14 +70,6 @@ export default class StyleBuilder {
         if ('tiles' in source)
             source.tiles = tiles.map(url => resolveUrl(baseUrl, url));
         return style;
-        function resolveUrl(base, url) {
-            if (!Boolean(base))
-                return url;
-            url = new URL(url, base).href;
-            url = url.replace(/%7B/gi, '{');
-            url = url.replace(/%7D/gi, '}');
-            return url;
-        }
     }
     getColors(colors) {
         const entriesString = Object.entries(colors);

package/dist/lib/style_guesser.js

@@ -3,6 +3,7 @@
 import { isTileJSONSpecification } from './types.js';
 import randomColorGenerator from './random_color.js';
 import Colorful from '../style/colorful.js';
+import { resolveUrl } from './utils.js';
 export default function guess(opt) {
     const { format } = opt;
     const tilejsonBasic = {
@@ -21,6 +22,10 @@ export default function guess(opt) {
         name: opt.name,
         template: opt.template,
     };
+    const { baseUrl } = opt;
+    if (typeof baseUrl === 'string') {
+        tilejsonBasic.tiles = tilejsonBasic.tiles.map(url => resolveUrl(baseUrl, url));
+    }
     let k;
     for (k in tilejsonBasic) {
         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
@@ -45,17 +50,29 @@ export default function guess(opt) {
     }
     if (!isTileJSONSpecification(tilejson))
         throw Error();
+    let style;
     switch (tilejson.type) {
         case 'raster':
-            return getImageStyle(tilejson);
+            style = getImageStyle(tilejson);
+            break;
         case 'vector':
             if (isShortbread(tilejson)) {
-                return getShortbreadStyle(tilejson, { baseUrl: opt.baseUrl, glyphs: opt.glyphs, sprite: opt.sprite });
+                style = getShortbreadStyle(tilejson, opt);
             }
             else {
-                return getInspectorStyle(tilejson);
+                style = getInspectorStyle(tilejson);
             }
     }
+    if (opt.minzoom ?? 0)
+        style.zoom ??= opt.minzoom;
+    if (opt.bounds)
+        style.center ??= [
+            (opt.bounds[0] + opt.bounds[2]) / 2,
+            (opt.bounds[1] + opt.bounds[3]) / 2,
+        ];
+    if (opt.center)
+        style.center = opt.center;
+    return style;
 }
 function isShortbread(spec) {
     if (typeof spec !== 'object')
@@ -69,14 +86,13 @@ function isShortbread(spec) {
     return shortbreadIds.every(id => layerIds.has(id));
 }
 function getShortbreadStyle(spec, builderOption) {
-    const style = new Colorful().build({
+    return new Colorful().build({
         hideLabels: true,
         tiles: spec.tiles,
         baseUrl: builderOption.baseUrl,
         glyphs: builderOption.glyphs,
         sprite: builderOption.sprite,
     });
-    return style;
 }
 function getInspectorStyle(spec) {
     const sourceName = 'vectorSource';

package/dist/lib/style_guesser.test.js

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/naming-convention */
+import getTemplate from './shortbread/template.js';
 import guessStyle from './style_guesser.js';
 describe('guessStyle', () => {
     const tiles = ['https://example.com/tiles/{z}/{x}/{y}'];
+    const vectorLayersSomething = [{ id: 'geometry', fields: { label: 'String', height: 'Number' } }];
+    const vectorLayersShortbread = getTemplate().sources['versatiles-shortbread'].vector_layers;
     it('should build raster styles', () => {
         const type = 'raster';
         const format = 'avif';
@@ -12,14 +15,13 @@ describe('guessStyle', () => {
             layers: [{ id: 'raster', source: 'rasterSource', type }],
         });
     });
-    it('should build vector styles', () => {
+    it('should build vector inspector styles', () => {
         const type = 'vector';
         const format = 'pbf';
-        const vectorLayers = [{ id: 'geometry', fields: { label: 'String', height: 'Number' } }];
-        expect(guessStyle({ tiles, format, vectorLayers }))
+        expect(guessStyle({ tiles, format, vectorLayers: vectorLayersSomething }))
             .toStrictEqual({
             version: 8,
-            sources: { vectorSource: { format, tilejson: '3.0.0', tiles, type, vector_layers: vectorLayers } },
+            sources: { vectorSource: { format, tilejson: '3.0.0', tiles, type, vector_layers: vectorLayersSomething } },
             layers: [
                 {
                     id: 'background',
@@ -54,4 +56,69 @@ describe('guessStyle', () => {
             ],
         });
     });
+    it('should build shortbread vector styles', () => {
+        const type = 'vector';
+        const format = 'pbf';
+        const style = guessStyle({ tiles, format, vectorLayers: vectorLayersShortbread, baseUrl: 'http://example.com' });
+        expect(style.layers.length).toBe(236);
+        style.layers = [];
+        expect(style).toStrictEqual({
+            glyphs: 'http://example.com/assets/fonts/{fontstack}/{range}.pbf',
+            metadata: {
+                license: 'https://creativecommons.org/publicdomain/zero/1.0/',
+                'maputnik:renderer': 'mbgljs',
+            },
+            name: 'versatiles-colorful',
+            sprite: 'http://example.com/assets/sprites/sprites',
+            layers: [],
+            sources: {
+                'versatiles-shortbread': {
+                    attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
+                    bounds: [-180, -85.0511287798066, 180, 85.0511287798066],
+                    format,
+                    maxzoom: 14,
+                    minzoom: 0,
+                    scheme: 'xyz',
+                    tilejson: '3.0.0',
+                    tiles,
+                    type,
+                    vector_layers: vectorLayersShortbread,
+                },
+            },
+            version: 8,
+        });
+    });
+    const cases = [
+        { type: 'image', options: { tiles, format: 'png' } },
+        { type: 'inspector', options: { tiles, format: 'pbf', vectorLayers: vectorLayersSomething } },
+        { type: 'shortbread', options: { tiles, format: 'pbf', vectorLayers: vectorLayersShortbread } },
+    ];
+    describe('minzoom sets zoom', () => {
+        cases.forEach(({ type, options }) => {
+            it(type, () => {
+                expect(guessStyle({ ...options, minzoom: 5 })).toHaveProperty('zoom', 5);
+            });
+        });
+    });
+    describe('bounds sets center', () => {
+        cases.forEach(({ type, options }) => {
+            it(type, () => {
+                expect(guessStyle({ ...options, bounds: [1, 2, 3, 4] })).toHaveProperty('center', [2, 3]);
+            });
+        });
+    });
+    describe('center sets center', () => {
+        cases.forEach(({ type, options }) => {
+            it(type, () => {
+                expect(guessStyle({ ...options, center: [12, 34] })).toHaveProperty('center', [12, 34]);
+            });
+        });
+    });
+    describe('center overrides bounds', () => {
+        cases.forEach(({ type, options }) => {
+            it(type, () => {
+                expect(guessStyle({ ...options, bounds: [1, 2, 3, 4], center: [12, 34] })).toHaveProperty('center', [12, 34]);
+            });
+        });
+    });
 });

package/dist/lib/utils.d.ts

@@ -2,3 +2,4 @@ export declare function deepClone<T>(obj: T): T;
 export declare function isSimpleObject(item: unknown): boolean;
 export declare function isBasicType(item: unknown): boolean;
 export declare function deepMerge<T extends object>(source0: T, ...sources: T[]): T;
+export declare function resolveUrl(base: string, url: string): string;

package/dist/lib/utils.js

@@ -104,3 +104,11 @@ export function deepMerge(source0, ...sources) {
     }
     return target;
 }
+export function resolveUrl(base, url) {
+    if (!Boolean(base))
+        return url;
+    url = new URL(url, base).href;
+    url = url.replace(/%7B/gi, '{');
+    url = url.replace(/%7D/gi, '}');
+    return url;
+}

package/dist/lib/utils.test.js

@@ -1,97 +1,115 @@
-import { deepClone, isSimpleObject, isBasicType, deepMerge } from './utils.js';
+import { deepClone, isSimpleObject, isBasicType, deepMerge, resolveUrl } from './utils.js';
 import Color from 'color';
-describe('Utilities tests', () => {
-    describe('deepClone', () => {
-        it('clones primitive types correctly', () => {
-            expect(deepClone(10)).toBe(10);
-            expect(deepClone(true)).toBe(true);
-            expect(deepClone('string')).toBe('string');
-        });
-        it('clones an array correctly', () => {
-            const array = [1, 2, { a: 'b' }];
-            const clonedArray = deepClone(array);
-            expect(clonedArray).toEqual(array);
-            expect(clonedArray).not.toBe(array);
-        });
-        it('clones a simple object correctly', () => {
-            const obj = { a: 'b', c: 1, d: true };
-            const clonedObj = deepClone(obj);
-            expect(clonedObj).toEqual(obj);
-            expect(clonedObj).not.toBe(obj);
-        });
-        it('clones a Color instance correctly', () => {
-            const color = new Color('#FF5733');
-            const clonedColor = deepClone(color);
-            expect(clonedColor.hex()).toBe(color.hex());
-        });
-        it('throws an error for non-implemented types', () => {
-            const func = () => true;
-            expect(() => deepClone(func)).toThrow('Not implemented yet: "function" case');
-        });
-    });
-    describe('isSimpleObject', () => {
-        it('identifies simple objects correctly', () => {
-            expect(isSimpleObject({ a: 1 })).toBe(true);
-        });
-        it('rejects non-objects', () => {
-            expect(isSimpleObject(1)).toBe(false);
-            expect(isSimpleObject('a')).toBe(false);
-            expect(isSimpleObject(true)).toBe(false);
-        });
-        it('rejects arrays', () => {
-            expect(isSimpleObject([1, 2, 3])).toBe(false);
-        });
-        it('rejects objects with prototype properties', () => {
-            class MyClass {
-                #property = true;
-            }
-            expect(isSimpleObject(new MyClass())).toBe(false);
-        });
-    });
-    describe('isBasicType', () => {
-        it('returns true for basic types', () => {
-            expect(isBasicType(1)).toBe(true);
-            expect(isBasicType('string')).toBe(true);
-            expect(isBasicType(true)).toBe(true);
-            expect(isBasicType(undefined)).toBe(true);
-        });
-        it('returns false for objects', () => {
-            expect(isBasicType({})).toBe(false);
-            expect(isBasicType([])).toBe(false);
-        });
-        it('throws error for functions', () => {
-            expect(() => isBasicType(() => true)).toThrow();
-        });
-    });
-    describe('deepMerge', () => {
-        it('merges simple objects correctly', () => {
-            const target = { a: 1, b: 2 };
-            const source = { b: 3, c: 4 };
-            const result = deepMerge(target, source);
-            expect(result).toEqual({ a: 1, b: 3, c: 4 });
-        });
-        it('merges nested objects correctly', () => {
-            const target = { a: { d: 4 }, b: 2 };
-            const source = { a: { e: 5 }, b: 3 };
-            const result = deepMerge(target, source);
-            expect(result).toEqual({ a: { d: 4, e: 5 }, b: 3 });
-        });
-        it('overrides primitives with object types', () => {
-            const target = { a: 1, b: 2 };
-            const source = { a: { d: 4 }, b: { e: 5 } };
-            const result = deepMerge(target, source);
-            expect(result).toEqual({ a: { d: 4 }, b: { e: 5 } });
-        });
-        it('merges Color instances correctly', () => {
-            const target = { color: new Color('#FF5733') };
-            const source = { color: new Color('#33FF57') };
-            const result = deepMerge(target, source);
-            expect(result.color.hex()).toBe(source.color.hex());
-        });
-        it('throws error for unpredicted cases', () => {
-            const target = { a: () => false };
-            const source = { a: { b: 1 } };
-            expect(() => deepMerge(target, source)).toThrow('Not implemented yet: "function" case');
-        });
+describe('deepClone', () => {
+    it('clones primitive types correctly', () => {
+        expect(deepClone(10)).toBe(10);
+        expect(deepClone(true)).toBe(true);
+        expect(deepClone('string')).toBe('string');
+    });
+    it('clones an array correctly', () => {
+        const array = [1, 2, { a: 'b' }];
+        const clonedArray = deepClone(array);
+        expect(clonedArray).toEqual(array);
+        expect(clonedArray).not.toBe(array);
+    });
+    it('clones a simple object correctly', () => {
+        const obj = { a: 'b', c: 1, d: true };
+        const clonedObj = deepClone(obj);
+        expect(clonedObj).toEqual(obj);
+        expect(clonedObj).not.toBe(obj);
+    });
+    it('clones a Color instance correctly', () => {
+        const color = new Color('#FF5733');
+        const clonedColor = deepClone(color);
+        expect(clonedColor.hex()).toBe(color.hex());
+    });
+    it('throws an error for non-implemented types', () => {
+        const func = () => true;
+        expect(() => deepClone(func)).toThrow('Not implemented yet: "function" case');
+    });
+});
+describe('isSimpleObject', () => {
+    it('identifies simple objects correctly', () => {
+        expect(isSimpleObject({ a: 1 })).toBe(true);
+    });
+    it('rejects non-objects', () => {
+        expect(isSimpleObject(1)).toBe(false);
+        expect(isSimpleObject('a')).toBe(false);
+        expect(isSimpleObject(true)).toBe(false);
+    });
+    it('rejects arrays', () => {
+        expect(isSimpleObject([1, 2, 3])).toBe(false);
+    });
+    it('rejects objects with prototype properties', () => {
+        class MyClass {
+            #property = true;
+        }
+        expect(isSimpleObject(new MyClass())).toBe(false);
+    });
+});
+describe('isBasicType', () => {
+    it('returns true for basic types', () => {
+        expect(isBasicType(1)).toBe(true);
+        expect(isBasicType('string')).toBe(true);
+        expect(isBasicType(true)).toBe(true);
+        expect(isBasicType(undefined)).toBe(true);
+    });
+    it('returns false for objects', () => {
+        expect(isBasicType({})).toBe(false);
+        expect(isBasicType([])).toBe(false);
+    });
+    it('throws error for functions', () => {
+        expect(() => isBasicType(() => true)).toThrow();
+    });
+});
+describe('deepMerge', () => {
+    it('merges simple objects correctly', () => {
+        const target = { a: 1, b: 2 };
+        const source = { b: 3, c: 4 };
+        const result = deepMerge(target, source);
+        expect(result).toEqual({ a: 1, b: 3, c: 4 });
+    });
+    it('merges nested objects correctly', () => {
+        const target = { a: { d: 4 }, b: 2 };
+        const source = { a: { e: 5 }, b: 3 };
+        const result = deepMerge(target, source);
+        expect(result).toEqual({ a: { d: 4, e: 5 }, b: 3 });
+    });
+    it('overrides primitives with object types', () => {
+        const target = { a: 1, b: 2 };
+        const source = { a: { d: 4 }, b: { e: 5 } };
+        const result = deepMerge(target, source);
+        expect(result).toEqual({ a: { d: 4 }, b: { e: 5 } });
+    });
+    it('merges Color instances correctly', () => {
+        const target = { color: new Color('#FF5733') };
+        const source = { color: new Color('#33FF57') };
+        const result = deepMerge(target, source);
+        expect(result.color.hex()).toBe(source.color.hex());
+    });
+    it('throws error for unpredicted cases', () => {
+        const target = { a: () => false };
+        const source = { a: { b: 1 } };
+        expect(() => deepMerge(target, source)).toThrow('Not implemented yet: "function" case');
+    });
+});
+describe('resolveUrl', () => {
+    test('should correctly resolve a relative URL with a base URL', () => {
+        expect(resolveUrl('http://example.com/', 'path/page')).toBe('http://example.com/path/page');
+    });
+    test('should return the same URL if base URL is empty', () => {
+        expect(resolveUrl('', 'http://example.com/path/page')).toBe('http://example.com/path/page');
+    });
+    test('should return the correct URL if absolute URL is used', () => {
+        expect(resolveUrl('http://example1.com', 'http://example.com/path/page')).toBe('http://example.com/path/page');
+    });
+    test('should handle URLs with special characters', () => {
+        expect(resolveUrl('http://example.com/', 'path/{param}')).toBe('http://example.com/path/{param}');
+    });
+    test('should handle URLs already containing encoded special characters', () => {
+        expect(resolveUrl('http://example.com/', 'path/%7Bparam%7D')).toBe('http://example.com/path/{param}');
+    });
+    test('should throw error for invalid base URL', () => {
+        expect(() => resolveUrl('invalid-base', 'path/page')).toThrow('Invalid URL');
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versatiles/style",
-  "version": "3.7.0",
+  "version": "3.8.1",
   "description": "Generate StyleJSON for MapLibre",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,22 +44,22 @@
     "@rollup/plugin-typescript": "^11.1.5",
     "@types/brace-expansion": "^1.1.2",
     "@types/inquirer": "^9.0.7",
-    "@types/jest": "^29.5.10",
-    "@types/node": "^20.10.0",
-    "@typescript-eslint/eslint-plugin": "^6.13.0",
-    "@typescript-eslint/parser": "^6.13.0",
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.6",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
     "@versatiles/release-tool": "^1.0.3",
-    "eslint": "^8.54.0",
+    "eslint": "^8.56.0",
     "inquirer": "^9.2.12",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "jest-ts-webcompat-resolver": "^1.0.0",
-    "npm-check-updates": "^16.14.11",
-    "rollup": "^4.6.0",
+    "npm-check-updates": "^16.14.12",
+    "rollup": "^4.9.3",
     "rollup-plugin-dts": "^6.1.0",
     "ts-jest": "^29.1.1",
-    "ts-node": "^10.9.1",
-    "tsx": "^4.5.0",
-    "typescript": "^5.3.2"
+    "ts-node": "^10.9.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
   }
 }