@versatiles/style 3.6.0 → 3.6.1

package/README.MD

@@ -125,7 +125,7 @@ interface {
 
 ### Method: `colorful(options)`
 
-<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/6f93c18/src/index.ts#L4">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/516812e/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/6f93c18/src/index.ts#L9">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/516812e/src/index.ts#L9">\[src]</a></sup>
 
 **Parameters:**
 
@@ -145,17 +145,17 @@ interface {
 
 ### Method: `guessStyle(spec)`
 
-<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/6f93c18/src/lib/style_guesser.ts#L12">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/516812e/src/lib/style_guesser.ts#L12">\[src]</a></sup>
 
 **Parameters:**
 
-* <code>spec: [TileJSONSpecification](#type_tilejsonspecification)</code>
+* <code>spec: TileJSONOption</code>
 
 **Returns:** <code>MaplibreStyle</code>
 
 ### Method: `neutrino(options)`
 
-<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/6f93c18/src/index.ts#L14">\[src]</a></sup>
+<sup><a href="https://github.com/versatiles-org/versatiles-style/blob/516812e/src/index.ts#L14">\[src]</a></sup>
 
 **Parameters:**
 

package/dist/index.test.js

@@ -35,28 +35,33 @@ describe('Colorful', () => {
     expect(paint['fill-color']).toBe('#ff0000');
 });
 describe('guessStyle', () => {
+    const tiles = ['https://fancy.map/tiles/{z}/{x}/{y}'];
+    const vector_layers = [{ id: 'hallo', fields: { label: 'String' } }];
     it('should build raster styles', () => {
         const style = builders.guessStyle({
-            type: 'raster',
-            tiles: [],
-            format: 'avif',
+            tiles,
+            format: 'png',
         });
         expect(style).toStrictEqual({
             layers: [{ id: 'raster', source: 'rasterSource', type: 'raster' }],
-            sources: { rasterSource: { format: 'avif', tilejson: '3.0.0', tiles: [], type: 'raster' } },
+            sources: { rasterSource: { format: 'png', tilejson: '3.0.0', tiles, type: 'raster' } },
             version: 8,
         });
     });
     it('should build vector styles', () => {
         const style = builders.guessStyle({
-            type: 'vector',
-            tiles: [],
+            tiles,
             format: 'pbf',
-            vector_layers: [],
+            vector_layers,
         });
         expect(style).toStrictEqual({
-            layers: [{ id: 'background', paint: { 'background-color': '#fff' }, type: 'background' }],
-            sources: { vectorSource: { format: 'pbf', tilejson: '3.0.0', tiles: [], type: 'vector', 'vector_layers': [] } },
+            layers: [
+                { id: 'background', paint: { 'background-color': '#fff' }, type: 'background' },
+                { id: 'vectorSource-hallo-fill', filter: ['==', '$type', 'Polygon'], paint: { 'fill-antialias': true, 'fill-color': 'hsla(14,50%,52%,0.6)', 'fill-opacity': 0.3, 'fill-outline-color': 'hsla(14,50%,52%,0.6)' }, source: 'vectorSource', 'source-layer': 'hallo', type: 'fill' },
+                { id: 'vectorSource-hallo-line', filter: ['==', '$type', 'LineString'], layout: { 'line-cap': 'round', 'line-join': 'round' }, paint: { 'line-color': 'hsla(14,50%,52%,0.6)' }, source: 'vectorSource', 'source-layer': 'hallo', type: 'line' },
+                { id: 'vectorSource-hallo-circle', filter: ['==', '$type', 'Point'], paint: { 'circle-color': 'hsla(14,50%,52%,0.6)', 'circle-radius': 2 }, source: 'vectorSource', 'source-layer': 'hallo', type: 'circle' },
+            ],
+            sources: { vectorSource: { format: 'pbf', tilejson: '3.0.0', tiles, type: 'vector', vector_layers } },
             'version': 8,
         });
     });

package/dist/lib/style_guesser.d.ts

@@ -1,2 +1,2 @@
-import type { MaplibreStyle, TileJSONSpecification } from './types.js';
-export default function guess(spec: TileJSONSpecification): MaplibreStyle;
+import type { MaplibreStyle, TileJSONOption } from './types.js';
+export default function guess(spec: TileJSONOption): MaplibreStyle;

package/dist/lib/style_guesser.js

@@ -4,21 +4,46 @@ import { isTileJSONSpecification } from './types.js';
 import randomColorGenerator from './random_color.js';
 import Colorful from '../style/colorful.js';
 export default function guess(spec) {
-    if (!isTileJSONSpecification(spec))
+    let tilejson;
+    const { format } = spec;
+    switch (format) {
+        case 'avif':
+        case 'jpg':
+        case 'png':
+        case 'webp':
+            tilejson = {
+                tilejson: '3.0.0',
+                type: 'raster',
+                ...spec,
+                format,
+            };
+            break;
+        case 'pbf':
+            const { vector_layers } = spec;
+            if (vector_layers == null) {
+                throw Error('property vector_layers is required for vector tiles');
+            }
+            tilejson = {
+                tilejson: '3.0.0',
+                type: 'vector',
+                ...spec,
+                format,
+                vector_layers,
+            };
+            break;
+    }
+    if (!isTileJSONSpecification(tilejson))
         throw Error();
-    spec.tilejson ??= '3.0.0';
-    switch (spec.type) {
+    switch (tilejson.type) {
+        case 'raster':
+            return getImageStyle(tilejson);
         case 'vector':
-            if (isShortbread(spec)) {
-                return getShortbreadStyle(spec);
+            if (isShortbread(tilejson)) {
+                return getShortbreadStyle(tilejson);
             }
             else {
-                return getInspectorStyle(spec);
+                return getInspectorStyle(tilejson);
             }
-        case 'raster':
-            return getImageStyle(spec);
-        default:
-            throw Error('spec.type must be: "vector" or "raster"');
     }
 }
 function isShortbread(spec) {

package/dist/lib/style_guesser.test.js

@@ -5,7 +5,7 @@ describe('guessStyle', () => {
     it('should build raster styles', () => {
         const type = 'raster';
         const format = 'avif';
-        expect(guessStyle({ type, tiles, format }))
+        expect(guessStyle({ tiles, format }))
             .toStrictEqual({
             version: 8,
             sources: { rasterSource: { format, tilejson: '3.0.0', tiles, type } },
@@ -16,7 +16,7 @@ describe('guessStyle', () => {
         const type = 'vector';
         const format = 'pbf';
         const vector_layers = [{ id: 'geometry', fields: { label: 'String', height: 'Number' } }];
-        expect(guessStyle({ type, tiles, format, vector_layers }))
+        expect(guessStyle({ tiles, format, vector_layers }))
             .toStrictEqual({
             version: 8,
             sources: { vectorSource: { format, tilejson: '3.0.0', tiles, type, vector_layers } },

package/dist/lib/types.d.ts

@@ -12,9 +12,8 @@ export interface VectorLayer {
     minzoom?: number;
     maxzoom?: number;
 }
-export interface TileJSONSpecificationRaster {
+export interface TileJSONSpecificationBasic {
     tilejson?: '3.0.0';
-    type: 'raster';
     attribution?: string;
     tiles: string[];
     scheme?: 'tms' | 'xyz';
@@ -28,14 +27,21 @@ export interface TileJSONSpecificationRaster {
     maxzoom?: number;
     name?: string;
     template?: string;
+}
+export interface TileJSONSpecificationRaster extends TileJSONSpecificationBasic {
+    type: 'raster';
     format: 'avif' | 'jpg' | 'png' | 'webp';
 }
-export interface TileJSONSpecificationVector extends Omit<TileJSONSpecificationRaster, 'format' | 'type'> {
-    vector_layers: VectorLayer[];
-    format: 'pbf';
+export interface TileJSONSpecificationVector extends TileJSONSpecificationBasic {
     type: 'vector';
+    format: 'pbf';
+    vector_layers: VectorLayer[];
 }
 export type TileJSONSpecification = TileJSONSpecificationRaster | TileJSONSpecificationVector;
+export interface TileJSONOption extends TileJSONSpecificationBasic {
+    format: 'avif' | 'jpg' | 'pbf' | 'png' | 'webp';
+    vector_layers?: VectorLayer[];
+}
 export type MaplibreStyleRaster = Omit<StyleSpecification, 'sources'> & {
     'sources': {
         [_: string]: TileJSONSpecificationRaster;

package/dist/lib/types.js

@@ -44,19 +44,19 @@ export function isTileJSONSpecification(obj) {
     if (typeof spec.template !== 'undefined' && typeof spec.template !== 'string') {
         throw Error('spec.template must be a string if present');
     }
+    if (!Array.isArray(spec.tiles) || spec.tiles.length === 0 || spec.tiles.some(url => typeof url !== 'string')) {
+        throw Error('spec.tiles must be an array of strings');
+    }
     if (spec.type === 'raster') {
         if (!['avif', 'jpg', 'png', 'webp'].includes(spec.format)) {
             throw Error('spec.format must be "avif", "jpg", "png", or "webp"');
         }
-        if (!Array.isArray(spec.tiles) || spec.tiles.some(url => typeof url !== 'string')) {
-            throw Error('spec.tiles must be an array of strings');
-        }
     }
     else if (spec.type === 'vector') {
         if (spec.format !== 'pbf') {
             throw Error('spec.format must be "pbf"');
         }
-        if (!Array.isArray(spec.vector_layers) || spec.vector_layers.some(layer => !validateVectorLayer(layer))) {
+        if (!Array.isArray(spec.vector_layers) || spec.vector_layers.length === 0 || spec.vector_layers.some(layer => !validateVectorLayer(layer))) {
             throw Error('spec.vector_layers must be an array of VectorLayer');
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versatiles/style",
-  "version": "3.6.0",
+  "version": "3.6.1",
   "description": "Generate StyleJSON for MapLibre",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",