@versatiles/style 5.2.5 → 5.2.7

package/dist/shortbread/template.d.ts

@@ -1,4 +0,0 @@
-import { StyleSpecification } from "@maplibre/maplibre-gl-style-spec";
-import { VectorLayer } from "../types/vector_layer.js";
-export declare function getShortbreadTemplate(): StyleSpecification;
-export declare function getShortbreadVectorLayers(): VectorLayer[];

package/dist/shortbread/template.js

@@ -1,339 +0,0 @@
-const maxzoom = 14;
-export function getShortbreadTemplate() {
-    return {
-        version: 8,
-        name: 'versatiles',
-        metadata: {
-            license: 'https://creativecommons.org/publicdomain/zero/1.0/',
-        },
-        glyphs: 'https://tiles.versatiles.org/assets/glyphs/{fontstack}/{range}.pbf',
-        sprite: [{ id: 'basics', url: 'https://tiles.versatiles.org/assets/sprites/basics/sprites' }],
-        sources: {
-            'versatiles-shortbread': {
-                attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-                tiles: [
-                    'https://tiles.versatiles.org/tiles/osm/{z}/{x}/{y}',
-                ],
-                type: 'vector',
-                scheme: 'xyz',
-                bounds: [
-                    -180,
-                    -85.0511287798066,
-                    180,
-                    85.0511287798066,
-                ],
-                minzoom: 0,
-                maxzoom
-            },
-        },
-        layers: [],
-    };
-}
-export function getShortbreadVectorLayers() {
-    return [
-        {
-            id: 'place_labels',
-            fields: {
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                population: 'Number',
-            },
-            minzoom: 3,
-            maxzoom,
-        },
-        {
-            id: 'boundaries',
-            fields: {
-                admin_level: 'Number',
-                coastline: 'Boolean',
-                disputed: 'Boolean',
-                maritime: 'Boolean',
-            },
-            minzoom: 0,
-            maxzoom,
-        },
-        {
-            id: 'boundary_labels',
-            fields: {
-                admin_level: 'Number',
-                land_area: 'Number',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                name_single: 'String',
-                way_area: 'Number',
-            },
-            minzoom: 2,
-            maxzoom,
-        },
-        {
-            id: 'addresses',
-            fields: {
-                housename: 'String',
-                housenumber: 'String',
-            },
-            minzoom: 14,
-            maxzoom,
-        },
-        {
-            id: 'water_lines',
-            fields: {
-                bridge: 'Boolean',
-                kind: 'String',
-                tunnel: 'Boolean',
-            },
-            minzoom: 4,
-            maxzoom,
-        },
-        {
-            id: 'water_lines_labels',
-            fields: {
-                bridge: 'Boolean',
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                tunnel: 'Boolean',
-            },
-            minzoom: 4,
-            maxzoom,
-        },
-        {
-            id: 'dam_lines',
-            fields: {
-                kind: 'String',
-            },
-            minzoom: 12,
-            maxzoom,
-        },
-        {
-            id: 'dam_polygons',
-            fields: {
-                kind: 'String',
-            },
-            minzoom: 12,
-            maxzoom,
-        },
-        {
-            id: 'pier_lines',
-            fields: {
-                kind: 'String',
-            },
-            minzoom: 12,
-            maxzoom,
-        },
-        {
-            id: 'pier_polygons',
-            fields: {
-                kind: 'String',
-            },
-            minzoom: 12,
-            maxzoom,
-        },
-        {
-            id: 'bridges',
-            fields: {
-                kind: 'String',
-            },
-            minzoom: 12,
-            maxzoom,
-        },
-        {
-            id: 'street_polygons',
-            fields: {
-                bridge: 'Boolean',
-                kind: 'String',
-                rail: 'Boolean',
-                service: 'String',
-                surface: 'String',
-                tunnel: 'Boolean',
-            },
-            minzoom: 11,
-            maxzoom,
-        },
-        {
-            id: 'streets_polygons_labels',
-            fields: {
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-            },
-            minzoom: 14,
-            maxzoom,
-        },
-        {
-            id: 'ferries',
-            fields: {
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-            },
-            minzoom: 8,
-            maxzoom,
-        },
-        {
-            id: 'streets',
-            fields: {
-                bicycle: 'String',
-                bridge: 'Boolean',
-                horse: 'String',
-                kind: 'String',
-                link: 'Boolean',
-                oneway: 'Boolean',
-                oneway_reverse: 'Boolean',
-                rail: 'Boolean',
-                service: 'String',
-                surface: 'String',
-                tracktype: 'String',
-                tunnel: 'Boolean',
-            },
-            minzoom: 5,
-            maxzoom,
-        },
-        {
-            id: 'street_labels',
-            fields: {
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                ref: 'String',
-                ref_cols: 'Number',
-                ref_rows: 'Number',
-                tunnel: 'Boolean',
-            },
-            minzoom: 10,
-            maxzoom,
-        },
-        {
-            id: 'street_labels_points',
-            fields: {
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                ref: 'String',
-            },
-            minzoom: 12,
-            maxzoom,
-        },
-        {
-            id: 'aerialways',
-            fields: {
-                kind: 'String',
-            },
-            minzoom: 12,
-            maxzoom,
-        },
-        {
-            id: 'public_transport',
-            fields: {
-                iata: 'String',
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                station: 'String',
-            },
-            minzoom: 11,
-            maxzoom,
-        },
-        {
-            id: 'buildings',
-            fields: {
-                amenity: 'String',
-                dummy: 'Number',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-            },
-            minzoom: 14,
-            maxzoom,
-        },
-        {
-            id: 'water_polygons',
-            fields: {
-                kind: 'String',
-                way_area: 'Number',
-            },
-            minzoom: 4,
-            maxzoom,
-        },
-        {
-            id: 'ocean',
-            fields: {
-                x: 'Number',
-                y: 'Number',
-            },
-            minzoom: 0,
-            maxzoom,
-        },
-        {
-            id: 'water_polygons_labels',
-            fields: {
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                way_area: 'Number',
-            },
-            minzoom: 14,
-            maxzoom,
-        },
-        {
-            id: 'land',
-            fields: {
-                kind: 'String',
-            },
-            minzoom: 7,
-            maxzoom,
-        },
-        {
-            id: 'sites',
-            fields: {
-                amenity: 'String',
-                kind: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-            },
-            minzoom: 14,
-            maxzoom,
-        },
-        {
-            id: 'pois',
-            fields: {
-                amenity: 'String',
-                atm: 'Boolean',
-                cuisine: 'String',
-                denomination: 'String',
-                emergency: 'String',
-                highway: 'String',
-                historic: 'String',
-                information: 'String',
-                leisure: 'String',
-                man_made: 'String',
-                name: 'String',
-                name_de: 'String',
-                name_en: 'String',
-                'recycling:clothes': 'Boolean',
-                'recycling:glass_bottles': 'Boolean',
-                'recycling:paper': 'Boolean',
-                'recycling:scrap_metal': 'Boolean',
-                religion: 'String',
-                shop: 'String',
-                sport: 'String',
-                tourism: 'String',
-                'tower:type': 'String',
-                vending: 'String',
-            },
-            minzoom: 14,
-            maxzoom,
-        },
-    ];
-}
-//# sourceMappingURL=template.js.map

package/dist/style_builder/decorator.d.ts

@@ -1,4 +0,0 @@
-import type { MaplibreLayer } from '../types/index.js';
-import type { StyleRules } from './types.js';
-import type { CachedRecolor } from './recolor.js';
-export declare function decorate(layers: MaplibreLayer[], rules: StyleRules, recolor: CachedRecolor): MaplibreLayer[];

package/dist/style_builder/decorator.js

@@ -1,127 +0,0 @@
-import { Color } from '../color/index.js';
-import expandBraces from 'brace-expansion';
-import maplibreProperties from '../shortbread/properties.js';
-import { deepMerge } from '../lib/utils.js';
-export function decorate(layers, rules, recolor) {
-    const layerIds = layers.map(l => l.id);
-    const layerIdSet = new Set(layerIds);
-    // Initialize a new map to hold final styles for layers
-    const layerStyles = new Map();
-    // Iterate through the generated layer style rules
-    Object.entries(rules).forEach(([idDef, layerStyle]) => {
-        if (layerStyle == null)
-            return;
-        // Expand any braces in IDs and filter them through a RegExp if necessary
-        const ids = expandBraces(idDef).flatMap(id => {
-            if (!id.includes('*'))
-                return id;
-            const regExpString = id.replace(/[^a-z_:-]/g, c => {
-                if (c === '*')
-                    return '[a-z_-]*';
-                throw new Error('unknown char to process. Do not know how to make a RegExp from: ' + JSON.stringify(c));
-            });
-            const regExp = new RegExp(`^${regExpString}$`, 'i');
-            return layerIds.filter(layerId => regExp.test(layerId));
-        });
-        ids.forEach(id => {
-            if (!layerIdSet.has(id))
-                return;
-            layerStyles.set(id, deepMerge(layerStyles.get(id) ?? {}, layerStyle));
-        });
-    });
-    // Deep clone the original layers and apply styles
-    return layers.flatMap(layer => {
-        // Get the id and style of the layer
-        const layerStyle = layerStyles.get(layer.id);
-        // Don't export layers that have no style
-        if (!layerStyle)
-            return [];
-        processStyling(layer, layerStyle);
-        return [layer];
-    });
-    // Function to process each style attribute for the layer
-    function processStyling(layer, styleRule) {
-        for (const [ruleKeyCamelCase, ruleValue] of Object.entries(styleRule)) {
-            if (ruleValue == null)
-                continue;
-            // CamelCase to not-camel-case
-            const ruleKey = ruleKeyCamelCase.replace(/[A-Z]/g, c => '-' + c.toLowerCase());
-            const propertyDefs = maplibreProperties.get(layer.type + '/' + ruleKey);
-            if (!propertyDefs)
-                continue;
-            propertyDefs.forEach(propertyDef => {
-                const { key } = propertyDef;
-                let value = ruleValue;
-                switch (propertyDef.valueType) {
-                    case 'color':
-                        value = processExpression(value, processColor);
-                        break;
-                    case 'fonts':
-                        value = processExpression(value, processFont);
-                        break;
-                    case 'resolvedImage':
-                    case 'formatted':
-                    case 'array':
-                    case 'boolean':
-                    case 'enum':
-                    case 'number':
-                        value = processExpression(value);
-                        break;
-                    default: throw new Error(`unknown propertyDef.valueType "${propertyDef.valueType}" for key "${key}"`);
-                }
-                switch (propertyDef.parent) {
-                    case 'layer':
-                        // @ts-expect-error: too complex to handle
-                        layer[key] = value;
-                        break;
-                    case 'layout':
-                        if (!layer.layout)
-                            layer.layout = {};
-                        // @ts-expect-error: too complex to handle
-                        layer.layout[key] = value;
-                        break;
-                    case 'paint':
-                        if (!layer.paint)
-                            layer.paint = {};
-                        // @ts-expect-error: too complex to handle
-                        layer.paint[key] = value;
-                        break;
-                    default:
-                        throw new Error(`unknown parent "${propertyDef.parent}" for key "${key}"`);
-                }
-            });
-        }
-        function processColor(value) {
-            if (typeof value === 'string')
-                value = Color.parse(value);
-            if (value instanceof Color) {
-                const color = recolor.do(value);
-                return color.asString();
-            }
-            throw new Error(`unknown color type "${typeof value}"`);
-        }
-        function processFont(value) {
-            if (typeof value === 'string')
-                return [value];
-            throw new Error(`unknown font type "${typeof value}"`);
-        }
-        function processExpression(value, cbValue) {
-            if (typeof value === 'object') {
-                if (value instanceof Color)
-                    return processColor(value);
-                if (!Array.isArray(value)) {
-                    return processZoomStops(value, cbValue);
-                }
-            }
-            return cbValue ? cbValue(value) : value;
-        }
-        function processZoomStops(obj, cbValue) {
-            return {
-                stops: Object.entries(obj)
-                    .map(([z, v]) => [parseInt(z, 10), cbValue ? cbValue(v) : v])
-                    .sort((a, b) => a[0] - b[0]),
-            };
-        }
-    }
-}
-//# sourceMappingURL=decorator.js.map

package/dist/style_builder/recolor.d.ts

@@ -1,22 +0,0 @@
-import { Color } from '../color/index.js';
-export interface RecolorOptions {
-    invertBrightness?: boolean;
-    rotate?: number;
-    saturate?: number;
-    gamma?: number;
-    contrast?: number;
-    brightness?: number;
-    tint?: number;
-    tintColor?: string;
-}
-export declare function getDefaultRecolorFlags(): RecolorOptions;
-export declare function recolorObject(colors: Record<string, Color>, opt?: RecolorOptions): void;
-export declare function recolorArray(colors: Color[], opt?: RecolorOptions): void;
-export declare class CachedRecolor {
-    private readonly skip;
-    private readonly opt?;
-    private readonly cache;
-    constructor(opt?: RecolorOptions);
-    do(color: Color): Color;
-}
-export declare function recolor(color: Color, opt?: RecolorOptions): Color;

package/dist/style_builder/recolor.js

@@ -1,89 +0,0 @@
-import { Color } from '../color/index.js';
-export function getDefaultRecolorFlags() {
-    return {
-        invertBrightness: false,
-        rotate: 0,
-        saturate: 0,
-        gamma: 1,
-        contrast: 1,
-        brightness: 0,
-        tint: 0,
-        tintColor: '#FF0000',
-    };
-}
-function isValidRecolorOptions(opt) {
-    if (!opt)
-        return false;
-    if ((opt.invertBrightness != null) && opt.invertBrightness)
-        return true;
-    if ((opt.rotate != null) && (opt.rotate !== 0))
-        return true;
-    if ((opt.saturate != null) && (opt.saturate !== 0))
-        return true;
-    if ((opt.gamma != null) && (opt.gamma !== 1))
-        return true;
-    if ((opt.contrast != null) && (opt.contrast !== 1))
-        return true;
-    if ((opt.brightness != null) && (opt.brightness !== 0))
-        return true;
-    if ((opt.tint != null) && (opt.tint !== 0))
-        return true;
-    if ((opt.tintColor != null) && (opt.tintColor !== '#FF0000'))
-        return true;
-    return false;
-}
-export function recolorObject(colors, opt) {
-    if (!isValidRecolorOptions(opt))
-        return;
-    for (const [k, c] of Object.entries(colors)) {
-        colors[k] = recolor(c, opt);
-    }
-}
-export function recolorArray(colors, opt) {
-    if (!isValidRecolorOptions(opt))
-        return;
-    for (let i = 0; i < colors.length; i++) {
-        colors[i] = recolor(colors[i], opt);
-    }
-}
-export class CachedRecolor {
-    skip;
-    opt;
-    cache;
-    constructor(opt) {
-        this.skip = !isValidRecolorOptions(opt);
-        this.cache = new Map();
-        this.opt = opt;
-    }
-    do(color) {
-        if (this.skip)
-            return color;
-        const key = color.asHex();
-        const result = this.cache.get(key);
-        if (result)
-            return result;
-        color = recolor(color, this.opt);
-        this.cache.set(key, color);
-        return color;
-    }
-}
-export function recolor(color, opt) {
-    if (!isValidRecolorOptions(opt))
-        return color;
-    if (opt.invertBrightness ?? false)
-        color = color.invertLuminosity();
-    if ((opt.rotate !== undefined) && (opt.rotate !== 0))
-        color = color.rotateHue(opt.rotate);
-    if ((opt.saturate !== undefined) && (opt.saturate !== 0))
-        color = color.saturate(opt.saturate);
-    if ((opt.gamma !== undefined) && (opt.gamma !== 1))
-        color = color.gamma(opt.gamma);
-    if ((opt.contrast !== undefined) && (opt.contrast !== 1))
-        color = color.contrast(opt.contrast);
-    if ((opt.brightness !== undefined) && (opt.brightness !== 0))
-        color = color.brightness(opt.brightness);
-    if ((opt.tint !== undefined) && (opt.tintColor !== undefined) && (opt.tint !== 0))
-        color = color.tint(opt.tint, Color.parse(opt.tintColor));
-    return color;
-}
-//# sourceMappingURL=recolor.js.map

package/dist/style_builder/style_builder.d.ts

@@ -1,15 +0,0 @@
-import { Color } from '../color/index.js';
-import type { StyleSpecification } from '../types/maplibre.js';
-import type { StyleBuilderColors, StyleBuilderColorsEnsured, StyleBuilderFonts, StyleBuilderOptions } from './types.js';
-import type { StyleRules, StyleRulesOptions } from './types.js';
-export declare abstract class StyleBuilder {
-    #private;
-    abstract readonly name: string;
-    abstract readonly defaultColors: StyleBuilderColors;
-    abstract readonly defaultFonts: StyleBuilderFonts;
-    build(options?: StyleBuilderOptions): StyleSpecification;
-    getColors(colors: StyleBuilderColors): StyleBuilderColorsEnsured;
-    getDefaultOptions(): StyleBuilderOptions;
-    protected transformDefaultColors(callback: (color: Color) => Color): void;
-    protected abstract getStyleRules(options: StyleRulesOptions): StyleRules;
-}