@versatiles/style 5.9.0 → 5.9.2

package/src/styles/satellite.ts

@@ -1,106 +0,0 @@
-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

@@ -1,11 +0,0 @@
-import Colorful from './colorful.js';
-
-export default class Shadow extends Colorful {
-	public readonly name: string = 'Shadow';
-
-	public constructor() {
-		super();
-
-		this.transformDefaultColors((color) => color.saturate(-1).invert().brightness(0.2));
-	}
-}

package/src/types/index.ts

@@ -1,5 +0,0 @@
-export type { MaplibreLayerDefinition, MaplibreLayer } from './maplibre.js';
-export type { VectorLayer } from './vector_layer.js';
-export { isTileJSONSpecification } from './tilejson.js';
-export type { TileJSONSpecification, TileJSONSpecificationRaster, TileJSONSpecificationVector } from './tilejson.js';
-export { isVectorLayers } from './vector_layer.js';

package/src/types/maplibre.ts

@@ -1,25 +0,0 @@
-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;
-
-/** 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'>;
-
-/** Represents a filter specification in Maplibre styles. */
-export type MaplibreFilter = FilterSpecification;

package/src/types/tilejson.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { isTileJSONSpecification } from './tilejson.js';
-
-describe('isTileJSONSpecification', () => {
-	const validVectorSpec = {
-		tilejson: '3.0.0',
-		type: 'vector',
-		format: 'pbf',
-		tiles: ['http://example.com/{z}/{x}/{y}.pbf'],
-		vector_layers: [{ id: 'layer1', fields: { property1: 'Number' }, description: 'A test layer' }],
-	};
-	const validRasterSpec = {
-		tilejson: '3.0.0',
-		type: 'raster',
-		format: 'png',
-		tiles: ['http://example.com/{z}/{x}/{y}.png'],
-	};
-
-	it('should return true for a valid raster source', () => {
-		expect(isTileJSONSpecification({ ...validRasterSpec })).toBeTruthy();
-	});
-
-	it('should return true for a valid vector source', () => {
-		expect(isTileJSONSpecification({ ...validVectorSpec })).toBeTruthy();
-	});
-
-	it('should throw an error if not object', () => {
-		expect(() => isTileJSONSpecification(null)).toThrow('spec must be an object');
-		expect(() => isTileJSONSpecification(1)).toThrow('spec must be an object');
-	});
-
-	it('should throw an error if the tiles property is missing', () => {
-		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]' },
-			{ 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 }) => {
-			expect(() => isTileJSONSpecification({ ...validVectorSpec, bounds })).toThrow(errorMessage);
-		});
-	});
-
-	it('should throw an error if the center property is invalid', () => {
-		[
-			{ 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);
-		});
-	});
-
-	describe('check every property', () => {
-		[
-			['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'],
-			['data', 'an array of strings if present', ['url'], 'url', [1], 1],
-			['description', 'a string if present', 'valid', 1],
-			['fillzoom', 'a positive integer if present', 5, 'invalid', -1],
-			['grids', 'an array of strings if present', ['1', '2', '3', '4'], [1, 2, 3, 4], 'invalid'],
-			['legend', 'a string if present', 'valid', 1],
-			['maxzoom', 'a positive integer if present', 5, 'invalid', -1],
-			['minzoom', 'a positive integer if present', 5, 'invalid', -1],
-			['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) => {
-			const key = test[0] as string;
-			const errorMessage = test[1] as string;
-			const values = test.slice(2) as unknown[];
-			it(key, () => {
-				for (let i = 0; i < values.length; i++) {
-					const value = values[i];
-					if (i === 0) {
-						expect(isTileJSONSpecification({ ...validVectorSpec, [key]: value })).toBe(true);
-					} else {
-						expect(() => isTileJSONSpecification({ ...validVectorSpec, [key]: value })).toThrow(
-							`spec.${key} must be ${errorMessage}`
-						);
-					}
-				}
-			});
-		});
-	});
-});

package/src/types/tilejson.ts

@@ -1,147 +0,0 @@
-import type { VectorLayer } from './vector_layer.js';
-
-/** Basic structure for TileJSON specification, applicable to both raster and vector types. */
-export interface TileJSONSpecificationRaster {
-	tilejson?: '3.0.0';
-	tiles: string[];
-
-	attribution?: string;
-	bounds?: [number, number, number, number];
-	center?: [number, number];
-	data?: string[];
-	description?: string;
-	fillzoom?: number;
-	grids?: string[];
-	legend?: string;
-	maxzoom?: number;
-	minzoom?: number;
-	name?: string;
-	scheme?: 'tms' | 'xyz';
-	template?: string;
-	version?: string;
-}
-
-/** Structure for TileJSON specification of vector type, specifying vector-specific properties. */
-export interface TileJSONSpecificationVector extends TileJSONSpecificationRaster {
-	vector_layers: VectorLayer[];
-}
-
-/** 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.
- */
-export function isTileJSONSpecification(spec: unknown): spec is TileJSONSpecification {
-	if (typeof spec !== 'object' || spec === null) {
-		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 new Error(`TileJSON validation: spec.tilejson must be "3.0.0", but got "${obj.tilejson}"`);
-	}
-
-	if (obj.attribution != null && typeof obj.attribution !== 'string') {
-		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 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 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 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 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 new Error('TileJSON validation: spec.data must be an array of strings if present');
-	}
-
-	if (obj.description != null && typeof obj.description !== 'string') {
-		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 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 new Error('TileJSON validation: spec.grids must be an array of strings if present');
-	}
-
-	if (obj.legend != null && typeof obj.legend !== 'string') {
-		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 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 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 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 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 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 new Error('TileJSON validation: spec.tiles must be a non-empty array of strings');
-	}
-
-	return true;
-}
-
-export function isRasterTileJSONSpecification(spec: unknown): spec is TileJSONSpecificationRaster {
-	if (!isTileJSONSpecification(spec)) return false;
-	if ('vector_layers' in spec && spec.vector_layers != null) return false;
-	return true;
-}

package/src/types/vector_layer.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { VectorLayer } from './vector_layer.js';
-import { isVectorLayer, isVectorLayers } from './vector_layer.js';
-
-describe('isVectorLayer', () => {
-	it('should validate a correct VectorLayer object', () => {
-		const validLayer: VectorLayer = { id: 'test-layer', fields: { field1: 'Number', field2: 'String' } };
-
-		expect(() => isVectorLayer(validLayer)).not.toThrow();
-	});
-
-	it('should throw an error for non-object inputs', () => {
-		verifyError(null, 'Layer must be a non-null object');
-		verifyError(42, 'Layer must be a non-null object');
-	});
-
-	it('should throw an error for invalid id types', () => {
-		verifyError({ id: 123, fields: {} }, 'Layer.id must be a string');
-	});
-
-	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'"
-		);
-	});
-
-	it('should throw an error for invalid optional properties', () => {
-		verifyError({ id: 'test', fields: {}, description: 123 }, 'Layer.description must be a string if present');
-		verifyError({ id: 'test', fields: {}, minzoom: -1 }, 'Layer.minzoom must be a non-negative number if present');
-		verifyError({ id: 'test', fields: {}, maxzoom: 'high' }, 'Layer.maxzoom must be a non-negative number if present');
-		verifyError({ id: 'test', fields: {}, maxzoom: -1 }, 'Layer.maxzoom must be a non-negative number if present');
-	});
-
-	function verifyError(layer: unknown, message: string): void {
-		expect(() => isVectorLayer(layer)).toThrow(message);
-	}
-});
-
-describe('isVectorLayers', () => {
-	it('should validate an array of correct VectorLayer objects', () => {
-		const validLayers = [
-			{ id: 'layer1', fields: { field1: 'Number' } },
-			{ id: 'layer2', fields: { field2: 'String' }, description: 'A test layer' },
-		];
-
-		expect(() => isVectorLayers(validLayers)).not.toThrow();
-	});
-
-	it('should throw an error for non-array inputs', () => {
-		expect(() => isVectorLayers(null)).toThrow('Expected an array of layers');
-		expect(() => isVectorLayers({})).toThrow('Expected an array of layers');
-	});
-
-	it('should throw an error for empty arrays', () => {
-		expect(() => isVectorLayers([])).toThrow('Array of layers cannot be empty');
-	});
-
-	it('should throw an error for arrays containing invalid layers', () => {
-		const invalidLayers = [
-			{ id: 'layer1', fields: { field1: 'Number' } },
-			{ id: 'layer2', fields: { field2: 'InvalidType' } },
-		];
-
-		expect(() => isVectorLayers(invalidLayers)).toThrow('Layer[1] is invalid');
-	});
-});

package/src/types/vector_layer.ts

@@ -1,67 +0,0 @@
-/** Represents the structure of a vector layer in a TileJSON specification. */
-export interface VectorLayer {
-	id: string;
-	fields: Record<string, 'Boolean' | 'Number' | 'String'>;
-	description?: string;
-	minzoom?: number;
-	maxzoom?: number;
-}
-
-/**
- * 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');
-	}
-
-	const obj = layer as Record<string, unknown>;
-
-	if (typeof obj.id !== 'string') {
-		throw new Error('Layer.id must be a string');
-	}
-
-	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 ('description' in obj && typeof obj.description !== 'string') {
-		throw new Error('Layer.description must be a string if present');
-	}
-
-	if ('minzoom' in obj && (typeof obj.minzoom !== 'number' || obj.minzoom < 0)) {
-		throw new Error('Layer.minzoom must be a non-negative number if present');
-	}
-
-	if ('maxzoom' in obj && (typeof obj.maxzoom !== 'number' || obj.maxzoom < 0)) {
-		throw new Error('Layer.maxzoom must be a non-negative number if present');
-	}
-
-	return true;
-}
-
-export function isVectorLayers(layers: unknown): layers is VectorLayer[] {
-	if (!Array.isArray(layers)) {
-		throw new Error('Expected an array of layers');
-	}
-
-	if (layers.length === 0) {
-		throw new Error('Array of layers cannot be empty');
-	}
-
-	layers.forEach((layer, index) => {
-		try {
-			if (!isVectorLayer(layer)) {
-				throw new Error(`Layer[${index}] is invalid`);
-			}
-		} catch (cause) {
-			throw new Error(`Layer[${index}] is invalid`, { cause });
-		}
-	});
-
-	return true;
-}