@versatiles/style 5.8.3 → 5.9.0

package/src/styles/satellite.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from 'vitest';
+import { buildSatelliteStyle } from './satellite.js';
+
+describe('satellite style', () => {
+	it('should create a satellite style with default options', () => {
+		const style = buildSatelliteStyle();
+
+		expect(style.name).toBe('versatiles-satellite');
+		expect(style.sources.satellite).toBeDefined();
+		expect(style.sources.satellite).toMatchObject({
+			type: 'raster',
+			tiles: ['https://tiles.versatiles.org/tiles/satellite/{z}/{x}/{y}'],
+			tileSize: 512,
+			maxzoom: 17,
+		});
+
+		// Raster layer should be the first layer
+		expect(style.layers[0]).toMatchObject({
+			id: 'satellite',
+			type: 'raster',
+			source: 'satellite',
+		});
+	});
+
+	it('should include vector overlay by default', () => {
+		const style = buildSatelliteStyle();
+
+		// Should have more than just the raster layer
+		expect(style.layers.length).toBeGreaterThan(1);
+
+		// Should have the vector source
+		expect(style.sources['versatiles-shortbread']).toBeDefined();
+
+		// Should not contain background layer
+		expect(style.layers.find((l) => l.id === 'background')).toBeUndefined();
+
+		// Should not contain fill layers
+		expect(style.layers.filter((l) => l.type === 'fill')).toHaveLength(0);
+
+		// Should not contain land-*, water-*, site-*, airport-*, tunnel-* layers
+		const unwanted = style.layers.filter((l) => /^(land|water|site|airport|tunnel)-/.test(l.id));
+		expect(unwanted).toHaveLength(0);
+	});
+
+	it('should modify symbol layers for satellite overlay', () => {
+		const style = buildSatelliteStyle();
+
+		const symbolLayers = style.layers.filter((l) => l.type === 'symbol');
+		expect(symbolLayers.length).toBeGreaterThan(0);
+
+		for (const layer of symbolLayers) {
+			if (layer.type !== 'symbol') continue;
+			if (layer.paint) {
+				expect(layer.paint['text-color']).toBe('#fff');
+				expect(layer.paint['text-halo-color']).toBe('#000');
+			}
+			if (layer.layout?.['text-font']) {
+				expect(layer.layout['text-font']).toEqual(['noto_sans_bold']);
+			}
+		}
+	});
+
+	it('should reduce line layer opacity', () => {
+		const style = buildSatelliteStyle();
+
+		const lineLayers = style.layers.filter((l) => l.type === 'line');
+		expect(lineLayers.length).toBeGreaterThan(0);
+
+		for (const layer of lineLayers) {
+			if (layer.type !== 'line' || !layer.paint) continue;
+			const opacity = layer.paint['line-opacity'];
+			if (typeof opacity === 'number') {
+				expect(opacity).toBeLessThanOrEqual(0.2);
+			}
+		}
+	});
+
+	it('should create minimal style when overlay is false', () => {
+		const style = buildSatelliteStyle({ overlay: false });
+
+		expect(style.name).toBe('versatiles-satellite');
+		// Should only have the raster layer
+		expect(style.layers).toHaveLength(1);
+		expect(style.layers[0]).toMatchObject({
+			id: 'satellite',
+			type: 'raster',
+			source: 'satellite',
+		});
+
+		// Should only have the raster source
+		expect(Object.keys(style.sources)).toEqual(['satellite']);
+	});
+
+	it('should accept custom raster tiles', () => {
+		const customTiles = ['https://example.com/tiles/{z}/{x}/{y}'];
+		const style = buildSatelliteStyle({ rasterTiles: customTiles });
+
+		const source = style.sources.satellite as { tiles: string[] };
+		expect(source.tiles).toEqual(customTiles);
+	});
+
+	it('should accept custom baseUrl', () => {
+		const style = buildSatelliteStyle({ baseUrl: 'https://example.org' });
+
+		expect(style.glyphs).toBe('https://example.org/assets/glyphs/{fontstack}/{range}.pbf');
+	});
+
+	it('should apply raster paint properties', () => {
+		const style = buildSatelliteStyle({
+			overlay: false,
+			rasterOpacity: 0.8,
+			rasterHueRotate: 45,
+			rasterBrightnessMin: 0.1,
+			rasterBrightnessMax: 0.9,
+			rasterSaturation: 0.5,
+			rasterContrast: -0.3,
+		});
+
+		const rasterLayer = style.layers[0];
+		expect(rasterLayer).toMatchObject({
+			paint: {
+				'raster-opacity': 0.8,
+				'raster-hue-rotate': 45,
+				'raster-brightness-min': 0.1,
+				'raster-brightness-max': 0.9,
+				'raster-saturation': 0.5,
+				'raster-contrast': -0.3,
+			},
+		});
+	});
+
+	it('should not include raster paint when no raster options set', () => {
+		const style = buildSatelliteStyle({ overlay: false });
+
+		const rasterLayer = style.layers[0];
+		expect(rasterLayer).not.toHaveProperty('paint');
+	});
+
+	it('should accept language option', () => {
+		const style = buildSatelliteStyle({ language: 'de' });
+
+		// Style should still be valid
+		expect(style.name).toBe('versatiles-satellite');
+		expect(style.layers.length).toBeGreaterThan(1);
+	});
+});

package/src/styles/satellite.ts

@@ -0,0 +1,106 @@
+import Graybeard from './graybeard.js';
+import type { StyleSpecification } from '../types/maplibre.js';
+import type { Language } from '../style_builder/types.js';
+
+export interface SatelliteStyleOptions {
+	baseUrl?: string;
+	rasterTiles?: string[];
+	overlayTiles?: string[];
+	overlay?: boolean;
+	language?: Language;
+	rasterOpacity?: number;
+	rasterHueRotate?: number;
+	rasterBrightnessMin?: number;
+	rasterBrightnessMax?: number;
+	rasterSaturation?: number;
+	rasterContrast?: number;
+}
+
+export function buildSatelliteStyle(options?: SatelliteStyleOptions): StyleSpecification {
+	options ??= {};
+	const baseUrl = options.baseUrl ?? 'https://tiles.versatiles.org';
+	const rasterTiles = options.rasterTiles ?? [`${baseUrl}/tiles/satellite/{z}/{x}/{y}`];
+	const overlay = options.overlay ?? true;
+
+	let style: StyleSpecification;
+
+	if (overlay) {
+		// Generate graybeard style for overlay
+		style = new Graybeard().build({
+			baseUrl,
+			tiles: options.overlayTiles,
+			language: options.language,
+		});
+
+		// Filter out background, fill layers, and unwanted layer groups
+		style.layers = style.layers.filter(
+			(l) => l.id !== 'background' && l.type !== 'fill' && !/^(land|water|site|airport|tunnel)-/.test(l.id)
+		);
+
+		// Modify remaining layers
+		for (const layer of style.layers) {
+			if (layer.type === 'symbol') {
+				// Bold font, white text, black halo
+				if (layer.layout?.['text-font']) {
+					layer.layout['text-font'] = ['noto_sans_bold'];
+				}
+				if (layer.paint) {
+					layer.paint['text-color'] = '#fff';
+					layer.paint['text-halo-color'] = '#000';
+					if ('text-halo-blur' in layer.paint) layer.paint['text-halo-blur'] = 0;
+					if ('text-halo-width' in layer.paint) layer.paint['text-halo-width'] = 1;
+				}
+			}
+
+			if (layer.type === 'line' && layer.paint) {
+				// Multiply existing opacity by 0.2
+				const v = layer.paint['line-opacity'];
+				if (v == null) {
+					layer.paint['line-opacity'] = 0.2;
+				} else if (typeof v === 'number') {
+					layer.paint['line-opacity'] = v * 0.2;
+				} else if (typeof v === 'object' && 'stops' in v) {
+					(v as { stops: [number, number][] }).stops = (v as { stops: [number, number][] }).stops.map(
+						(s: [number, number]): [number, number] => [s[0], s[1] * 0.2]
+					);
+				}
+			}
+		}
+	} else {
+		// Minimal style with no overlay
+		style = { version: 8, sources: {}, layers: [] } as unknown as StyleSpecification;
+	}
+
+	// Build raster paint properties
+	const rasterPaint: Record<string, number> = {};
+	if (options.rasterOpacity != null) rasterPaint['raster-opacity'] = options.rasterOpacity;
+	if (options.rasterHueRotate != null) rasterPaint['raster-hue-rotate'] = options.rasterHueRotate;
+	if (options.rasterBrightnessMin != null) rasterPaint['raster-brightness-min'] = options.rasterBrightnessMin;
+	if (options.rasterBrightnessMax != null) rasterPaint['raster-brightness-max'] = options.rasterBrightnessMax;
+	if (options.rasterSaturation != null) rasterPaint['raster-saturation'] = options.rasterSaturation;
+	if (options.rasterContrast != null) rasterPaint['raster-contrast'] = options.rasterContrast;
+
+	// Add raster source
+	style.sources.satellite = {
+		type: 'raster',
+		tiles: rasterTiles,
+		tileSize: 512,
+		attribution: "<a href='https://versatiles.org/sources/'>VersaTiles sources</a>",
+		bounds: [-178.187256, -21.401934, 55.846252, 58.061897],
+		minzoom: 0,
+		maxzoom: 17,
+	};
+
+	// Add raster layer at bottom
+	style.layers.unshift({
+		id: 'satellite',
+		type: 'raster',
+		source: 'satellite',
+		minzoom: 0,
+		...(Object.keys(rasterPaint).length > 0 ? { paint: rasterPaint } : {}),
+	} as StyleSpecification['layers'][number]);
+
+	style.name = 'versatiles-satellite';
+
+	return style;
+}

package/src/styles/shadow.ts

@@ -6,6 +6,6 @@ export default class Shadow extends Colorful {
 	public constructor() {
 		super();
 
-		this.transformDefaultColors(color => color.saturate(-1).invert().brightness(0.2));
+		this.transformDefaultColors((color) => color.saturate(-1).invert().brightness(0.2));
 	}
-}
+}

package/src/types/index.ts

@@ -1,4 +1,3 @@
-
 export type { MaplibreLayerDefinition, MaplibreLayer } from './maplibre.js';
 export type { VectorLayer } from './vector_layer.js';
 export { isTileJSONSpecification } from './tilejson.js';

package/src/types/maplibre.ts

@@ -1,11 +1,25 @@
-import type { BackgroundLayerSpecification, FillLayerSpecification, FilterSpecification, LineLayerSpecification, SymbolLayerSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type {
+	BackgroundLayerSpecification,
+	FillLayerSpecification,
+	FilterSpecification,
+	LineLayerSpecification,
+	SymbolLayerSpecification,
+} from '@maplibre/maplibre-gl-style-spec';
 export type { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
 
 /** Type for Maplibre layers, including background, fill, line, and symbol specifications. */
-export type MaplibreLayer = BackgroundLayerSpecification | FillLayerSpecification | LineLayerSpecification | SymbolLayerSpecification;
+export type MaplibreLayer =
+	| BackgroundLayerSpecification
+	| FillLayerSpecification
+	| LineLayerSpecification
+	| SymbolLayerSpecification;
 
 /** Defines the structure of Maplibre layer definitions, omitting the 'source' property for fill, line, and symbol specifications. */
-export type MaplibreLayerDefinition = BackgroundLayerSpecification | Omit<FillLayerSpecification, 'source'> | Omit<LineLayerSpecification, 'source'> | Omit<SymbolLayerSpecification, 'source'>;
+export type MaplibreLayerDefinition =
+	| BackgroundLayerSpecification
+	| Omit<FillLayerSpecification, 'source'>
+	| Omit<LineLayerSpecification, 'source'>
+	| Omit<SymbolLayerSpecification, 'source'>;
 
 /** Represents a filter specification in Maplibre styles. */
 export type MaplibreFilter = FilterSpecification;

package/src/types/tilejson.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'; 
+import { describe, expect, it } from 'vitest';
 import { isTileJSONSpecification } from './tilejson.js';
 
 describe('isTileJSONSpecification', () => {
@@ -30,15 +30,17 @@ describe('isTileJSONSpecification', () => {
 	});
 
 	it('should throw an error if the tiles property is missing', () => {
-		expect(() => isTileJSONSpecification({ ...validRasterSpec, tiles: undefined })).toThrow('spec.tiles must be an array of strings');
+		expect(() => isTileJSONSpecification({ ...validRasterSpec, tiles: undefined })).toThrow(
+			'spec.tiles must be a non-empty array of strings'
+		);
 	});
 
 	it('should throw an error if the bounds property is invalid', () => {
 		[
-			{ bounds: [-181, -90, 180, 90], errorMessage: 'spec.bounds[0] must be between -180 and 180' },
-			{ bounds: [-180, -91, 180, 90], errorMessage: 'spec.bounds[1] must be between -90 and 90' },
-			{ bounds: [-180, -90, 181, 90], errorMessage: 'spec.bounds[2] must be between -180 and 180' },
-			{ bounds: [-180, -90, 180, 91], errorMessage: 'spec.bounds[3] must be between -90 and 90' },
+			{ bounds: [-181, -90, 180, 90], errorMessage: 'spec.bounds[0]' },
+			{ bounds: [-180, -91, 180, 90], errorMessage: 'spec.bounds[1]' },
+			{ bounds: [-180, -90, 181, 90], errorMessage: 'spec.bounds[2]' },
+			{ bounds: [-180, -90, 180, 91], errorMessage: 'spec.bounds[3]' },
 			{ bounds: [180, -90, -180, 90], errorMessage: 'spec.bounds[0] must be smaller than spec.bounds[2]' },
 			{ bounds: [-180, 90, 180, -90], errorMessage: 'spec.bounds[1] must be smaller than spec.bounds[3]' },
 		].forEach(({ bounds, errorMessage }) => {
@@ -48,10 +50,10 @@ describe('isTileJSONSpecification', () => {
 
 	it('should throw an error if the center property is invalid', () => {
 		[
-			{ center: [-181, 0], errorMessage: 'spec.center[0] must be between -180 and 180' },
-			{ center: [181, 0], errorMessage: 'spec.center[0] must be between -180 and 180' },
-			{ center: [0, -91], errorMessage: 'spec.center[1] must be between -90 and 90' },
-			{ center: [0, 91], errorMessage: 'spec.center[1] must be between -90 and 90' },
+			{ center: [-181, 0], errorMessage: 'spec.center[0]' },
+			{ center: [181, 0], errorMessage: 'spec.center[0]' },
+			{ center: [0, -91], errorMessage: 'spec.center[1]' },
+			{ center: [0, 91], errorMessage: 'spec.center[1]' },
 		].forEach(({ center, errorMessage }) => {
 			expect(() => isTileJSONSpecification({ ...validVectorSpec, center })).toThrow(errorMessage);
 		});
@@ -59,7 +61,7 @@ describe('isTileJSONSpecification', () => {
 
 	describe('check every property', () => {
 		[
-			['tiles', 'an array of strings', ['url'], 'url', [], [1], 1],
+			['tiles', 'a non-empty array of strings', ['url'], 'url', [], [1], 1],
 			['attribution', 'a string if present', 'valid', 1],
 			['bounds', 'an array of four numbers if present', [1, 2, 3, 4], ['1', '2', '3', '4'], [1, 2, 3], [], 'invalid'],
 			['center', 'an array of two numbers if present', [1, 2], ['1', '2'], [1, 2, 3], [], 'invalid'],
@@ -73,7 +75,7 @@ describe('isTileJSONSpecification', () => {
 			['name', 'a string if present', 'valid', 1],
 			['scheme', '"tms" or "xyz" if present', 'xyz', 'invalid', 1],
 			['template', 'a string if present', 'valid', 1],
-		].forEach(test => {
+		].forEach((test) => {
 			const key = test[0] as string;
 			const errorMessage = test[1] as string;
 			const values = test.slice(2) as unknown[];
@@ -83,8 +85,9 @@ describe('isTileJSONSpecification', () => {
 					if (i === 0) {
 						expect(isTileJSONSpecification({ ...validVectorSpec, [key]: value })).toBe(true);
 					} else {
-						expect(() => isTileJSONSpecification({ ...validVectorSpec, [key]: value }))
-							.toThrow(`spec.${key} must be ${errorMessage}`);
+						expect(() => isTileJSONSpecification({ ...validVectorSpec, [key]: value })).toThrow(
+							`spec.${key} must be ${errorMessage}`
+						);
 					}
 				}
 			});

package/src/types/tilejson.ts

@@ -29,90 +29,112 @@ export interface TileJSONSpecificationVector extends TileJSONSpecificationRaster
 /** Represents a TileJSON specification, which can be either raster or vector. */
 export type TileJSONSpecification = TileJSONSpecificationRaster | TileJSONSpecificationVector;
 
-/** 
-* Checks if an object adheres to the TileJSON specification. 
-* Throws errors if the object does not conform to the expected structure or types.
-*/
+/**
+ * Checks if an object adheres to the TileJSON specification.
+ * Throws errors if the object does not conform to the expected structure or types.
+ */
 export function isTileJSONSpecification(spec: unknown): spec is TileJSONSpecification {
 	if (typeof spec !== 'object' || spec === null) {
-		throw Error('spec must be an object');
+		throw new Error(`TileJSON validation: spec must be an object, but got ${typeof spec}`);
 	}
 
 	const obj = spec as Record<string, unknown>;
 
 	// Common property validation
 	if (obj.data != null && obj.tilejson !== '3.0.0') {
-		throw Error('spec.tilejson must be "3.0.0"');
+		throw new Error(`TileJSON validation: spec.tilejson must be "3.0.0", but got "${obj.tilejson}"`);
 	}
 
 	if (obj.attribution != null && typeof obj.attribution !== 'string') {
-		throw Error('spec.attribution must be a string if present');
+		throw new Error(
+			`TileJSON validation: spec.attribution must be a string if present, but got ${typeof obj.attribution}`
+		);
 	}
 
 	if (obj.bounds != null) {
-		if (!Array.isArray(obj.bounds) || obj.bounds.length !== 4 || obj.bounds.some(num => typeof num !== 'number')) {
-			throw Error('spec.bounds must be an array of four numbers if present');
+		if (!Array.isArray(obj.bounds) || obj.bounds.length !== 4 || obj.bounds.some((num) => typeof num !== 'number')) {
+			throw new Error(
+				`TileJSON validation: spec.bounds must be an array of four numbers if present, but got ${JSON.stringify(obj.bounds)}`
+			);
 		}
 		const a = obj.bounds as [number, number, number, number];
-		if (a[0] < -180 || a[0] > 180) throw Error('spec.bounds[0] must be between -180 and 180');
-		if (a[1] < -90 || a[1] > 90) throw Error('spec.bounds[1] must be between -90 and 90');
-		if (a[2] < -180 || a[2] > 180) throw Error('spec.bounds[2] must be between -180 and 180');
-		if (a[3] < -90 || a[3] > 90) throw Error('spec.bounds[3] must be between -90 and 90');
-		if (a[0] > a[2]) throw Error('spec.bounds[0] must be smaller than spec.bounds[2]');
-		if (a[1] > a[3]) throw Error('spec.bounds[1] must be smaller than spec.bounds[3]');
+		if (a[0] < -180 || a[0] > 180)
+			throw new Error(`TileJSON validation: spec.bounds[0] (longitude) must be between -180 and 180, but got ${a[0]}`);
+		if (a[1] < -90 || a[1] > 90)
+			throw new Error(`TileJSON validation: spec.bounds[1] (latitude) must be between -90 and 90, but got ${a[1]}`);
+		if (a[2] < -180 || a[2] > 180)
+			throw new Error(`TileJSON validation: spec.bounds[2] (longitude) must be between -180 and 180, but got ${a[2]}`);
+		if (a[3] < -90 || a[3] > 90)
+			throw new Error(`TileJSON validation: spec.bounds[3] (latitude) must be between -90 and 90, but got ${a[3]}`);
+		if (a[0] > a[2])
+			throw new Error(
+				`TileJSON validation: spec.bounds[0] must be smaller than spec.bounds[2] (min longitude < max longitude), but got [${a[0]}, ${a[2]}]`
+			);
+		if (a[1] > a[3])
+			throw new Error(
+				`TileJSON validation: spec.bounds[1] must be smaller than spec.bounds[3] (min latitude < max latitude), but got [${a[1]}, ${a[3]}]`
+			);
 	}
 
 	if (obj.center != null) {
-		if (!Array.isArray(obj.center) || obj.center.length !== 2 || obj.center.some(num => typeof num !== 'number')) {
-			throw Error('spec.center must be an array of two numbers if present');
+		if (!Array.isArray(obj.center) || obj.center.length !== 2 || obj.center.some((num) => typeof num !== 'number')) {
+			throw new Error(
+				`TileJSON validation: spec.center must be an array of two numbers if present, but got ${JSON.stringify(obj.center)}`
+			);
 		}
 		const a = obj.center as [number, number];
-		if (a[0] < -180 || a[0] > 180) throw Error('spec.center[0] must be between -180 and 180');
-		if (a[1] < -90 || a[1] > 90) throw Error('spec.center[1] must be between -90 and 90');
+		if (a[0] < -180 || a[0] > 180)
+			throw new Error(`TileJSON validation: spec.center[0] (longitude) must be between -180 and 180, but got ${a[0]}`);
+		if (a[1] < -90 || a[1] > 90)
+			throw new Error(`TileJSON validation: spec.center[1] (latitude) must be between -90 and 90, but got ${a[1]}`);
 	}
 
-	if (obj.data != null && (!Array.isArray(obj.data) || obj.data.some(url => typeof url !== 'string'))) {
-		throw Error('spec.data must be an array of strings if present');
+	if (obj.data != null && (!Array.isArray(obj.data) || obj.data.some((url) => typeof url !== 'string'))) {
+		throw new Error('TileJSON validation: spec.data must be an array of strings if present');
 	}
 
 	if (obj.description != null && typeof obj.description !== 'string') {
-		throw Error('spec.description must be a string if present');
+		throw new Error(
+			`TileJSON validation: spec.description must be a string if present, but got ${typeof obj.description}`
+		);
 	}
 
-	if (obj.fillzoom != null && (typeof obj.fillzoom !== 'number' || (obj.fillzoom < 0))) {
-		throw Error('spec.fillzoom must be a positive integer if present');
+	if (obj.fillzoom != null && (typeof obj.fillzoom !== 'number' || obj.fillzoom < 0)) {
+		throw new Error(
+			`TileJSON validation: spec.fillzoom must be a positive integer if present, but got ${obj.fillzoom}`
+		);
 	}
 
-	if (obj.grids != null && (!Array.isArray(obj.grids) || obj.grids.some(url => typeof url !== 'string'))) {
-		throw Error('spec.grids must be an array of strings if present');
+	if (obj.grids != null && (!Array.isArray(obj.grids) || obj.grids.some((url) => typeof url !== 'string'))) {
+		throw new Error('TileJSON validation: spec.grids must be an array of strings if present');
 	}
 
 	if (obj.legend != null && typeof obj.legend !== 'string') {
-		throw Error('spec.legend must be a string if present');
+		throw new Error(`TileJSON validation: spec.legend must be a string if present, but got ${typeof obj.legend}`);
 	}
 
-	if (obj.minzoom != null && (typeof obj.minzoom !== 'number' || (obj.minzoom < 0))) {
-		throw Error('spec.minzoom must be a positive integer if present');
+	if (obj.minzoom != null && (typeof obj.minzoom !== 'number' || obj.minzoom < 0)) {
+		throw new Error(`TileJSON validation: spec.minzoom must be a positive integer if present, but got ${obj.minzoom}`);
 	}
 
-	if (obj.maxzoom != null && (typeof obj.maxzoom !== 'number' || (obj.maxzoom < 0))) {
-		throw Error('spec.maxzoom must be a positive integer if present');
+	if (obj.maxzoom != null && (typeof obj.maxzoom !== 'number' || obj.maxzoom < 0)) {
+		throw new Error(`TileJSON validation: spec.maxzoom must be a positive integer if present, but got ${obj.maxzoom}`);
 	}
 
 	if (obj.name != null && typeof obj.name !== 'string') {
-		throw Error('spec.name must be a string if present');
+		throw new Error(`TileJSON validation: spec.name must be a string if present, but got ${typeof obj.name}`);
 	}
 
 	if (obj.scheme != null && obj.scheme !== 'xyz' && obj.scheme !== 'tms') {
-		throw Error('spec.scheme must be "tms" or "xyz" if present');
+		throw new Error(`TileJSON validation: spec.scheme must be "tms" or "xyz" if present, but got "${obj.scheme}"`);
 	}
 
 	if (obj.template != null && typeof obj.template !== 'string') {
-		throw Error('spec.template must be a string if present');
+		throw new Error(`TileJSON validation: spec.template must be a string if present, but got ${typeof obj.template}`);
 	}
 
-	if (!Array.isArray(obj.tiles) || obj.tiles.length === 0 || obj.tiles.some(url => typeof url !== 'string')) {
-		throw Error('spec.tiles must be an array of strings');
+	if (!Array.isArray(obj.tiles) || obj.tiles.length === 0 || obj.tiles.some((url) => typeof url !== 'string')) {
+		throw new Error('TileJSON validation: spec.tiles must be a non-empty array of strings');
 	}
 
 	return true;
@@ -120,6 +142,6 @@ export function isTileJSONSpecification(spec: unknown): spec is TileJSONSpecific
 
 export function isRasterTileJSONSpecification(spec: unknown): spec is TileJSONSpecificationRaster {
 	if (!isTileJSONSpecification(spec)) return false;
-	if (('vector_layers' in spec) && (spec.vector_layers != null)) return false;
+	if ('vector_layers' in spec && spec.vector_layers != null) return false;
 	return true;
 }

package/src/types/vector_layer.test.ts

@@ -20,7 +20,10 @@ describe('isVectorLayer', () => {
 
 	it('should throw an error for invalid fields', () => {
 		verifyError({ id: 'test', fields: null }, 'Layer.fields must be a non-null object');
-		verifyError({ id: 'test', fields: { field1: 'InvalidType' } }, 'Layer.fields values must be one of \'Boolean\', \'Number\', or \'String\'');
+		verifyError(
+			{ id: 'test', fields: { field1: 'InvalidType' } },
+			"Layer.fields values must be one of 'Boolean', 'Number', or 'String'"
+		);
 	});
 
 	it('should throw an error for invalid optional properties', () => {
@@ -60,6 +63,6 @@ describe('isVectorLayers', () => {
 			{ id: 'layer2', fields: { field2: 'InvalidType' } },
 		];
 
-		expect(() => isVectorLayers(invalidLayers)).toThrow(/Layer\[\d+\] at invalid:/);
+		expect(() => isVectorLayers(invalidLayers)).toThrow('Layer[1] is invalid');
 	});
 });

package/src/types/vector_layer.ts

@@ -7,10 +7,10 @@ export interface VectorLayer {
 	maxzoom?: number;
 }
 
-/** 
-* Verifies if an object conforms to the VectorLayer structure. 
-* Throws errors for any deviations from the expected structure or types.
-*/
+/**
+ * Verifies if an object conforms to the VectorLayer structure.
+ * Throws errors for any deviations from the expected structure or types.
+ */
 export function isVectorLayer(layer: unknown): layer is VectorLayer {
 	if (typeof layer !== 'object' || layer === null) {
 		throw new Error('Layer must be a non-null object');
@@ -25,8 +25,8 @@ export function isVectorLayer(layer: unknown): layer is VectorLayer {
 	if (typeof obj.fields !== 'object' || obj.fields === null) {
 		throw new Error('Layer.fields must be a non-null object');
 	}
-	if (Object.values(obj.fields).some(type => !['Boolean', 'Number', 'String'].includes(type as string))) {
-		throw new Error('Layer.fields values must be one of \'Boolean\', \'Number\', or \'String\'');
+	if (Object.values(obj.fields).some((type) => !['Boolean', 'Number', 'String'].includes(type as string))) {
+		throw new Error("Layer.fields values must be one of 'Boolean', 'Number', or 'String'");
 	}
 
 	if ('description' in obj && typeof obj.description !== 'string') {
@@ -58,10 +58,8 @@ export function isVectorLayers(layers: unknown): layers is VectorLayer[] {
 			if (!isVectorLayer(layer)) {
 				throw new Error(`Layer[${index}] is invalid`);
 			}
-		} catch (error) {
-			// Assuming `isVectorLayer` throws an error with a meaningful message, you can rethrow it
-			// Alternatively, customize the error message or handle the error as needed
-			throw new Error(`Layer[${index}] at invalid: ${String((error instanceof Error) ? error.message : error)}`);
+		} catch (cause) {
+			throw new Error(`Layer[${index}] is invalid`, { cause });
 		}
 	});