@versatiles/style 4.0.5 → 4.1.0

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "@versatiles/style",
-  "version": "4.0.5",
+  "version": "4.1.0",
   "description": "Generate StyleJSON for MapLibre",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "check": "npm run build && npm run lint && npm run test",
-    "build": "npm run build-browser && npm run build-node && npm run build-styles",
-    "build-browser": "rollup -c=rollup.config.js",
+    "check": "npm run lint && npm run build && npm run test",
+    "build": "rm -rf release; npm run build-browser && npm run build-node && npm run build-styles && npm run build-sprites",
+    "build-browser": "rollup -c=rollup.config.js; tar -cf - release/versatiles-style/versatiles-style.* | gzip -9 > release/versatiles-style.tar.gz; rm -rf release/versatiles-style",
     "build-node": "rm -rf dist && tsc -p tsconfig.node.json && chmod +x dist/index.js",
     "build-styles": "tsx scripts/build-styles.ts",
-    "doc": "vrt ts2md src/index.ts tsconfig.node.json | vrt insertmd README.md '# API'",
-    "lint": "npm run build-browser && eslint --color .",
+    "build-sprites": "tsx scripts/build-sprites.ts",
+    "// dev": "????",
+    "// doc": "vrt ts2md src/index.ts tsconfig.node.json | vrt insertmd README.md '# API'",
+    "lint": "eslint --color .",
     "release": "npx vrt release-npm",
-    "test": "npm run test-typescript && npm run test-node && npm run test-browser",
-    "test-browser": "npm run build-browser && jest -c=jest.config.browser.ts",
-    "test-coverage": "NODE_OPTIONS=--experimental-vm-modules jest -c=jest.config.coverage.ts",
-    "test-node": "npm run build-node && NODE_OPTIONS=--experimental-vm-modules jest -c=jest.config.node.ts",
-    "test-typescript": "NODE_OPTIONS=--experimental-vm-modules jest -c=jest.config.typescript.ts",
+    "test": "npm run test-typescript",
+    "test-coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "test-typescript": "NODE_OPTIONS=--experimental-vm-modules jest",
     "upgrade": "npm-check-updates -u && rm -f package-lock.json && rm -rf node_modules; npm i"
   },
   "repository": {
@@ -42,21 +42,26 @@
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
+    "@types/bin-pack": "^1.0.3",
     "@types/brace-expansion": "^1.1.2",
     "@types/inquirer": "^9.0.7",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.19",
+    "@types/tar-stream": "^3.1.3",
     "@typescript-eslint/eslint-plugin": "^7.0.1",
     "@typescript-eslint/parser": "^7.0.1",
-    "@versatiles/release-tool": "^1.2.1",
+    "@versatiles/release-tool": "^1.2.2",
+    "bin-pack": "^1.0.2",
     "eslint": "^8.56.0",
     "inquirer": "^9.2.14",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "jest-ts-webcompat-resolver": "^1.0.0",
     "npm-check-updates": "^16.14.15",
-    "rollup": "^4.11.0",
+    "rollup": "^4.12.0",
     "rollup-plugin-dts": "^6.1.0",
+    "sharp": "^0.33.2",
+    "tar-stream": "^3.1.7",
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.7.1",

package/dist/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.test.js

@@ -1,67 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { guessStyle, styles } from './index.js';
-describe('styles', () => {
-    it('should be all styles', () => {
-        expect(Array.from(Object.keys(styles)).sort())
-            .toStrictEqual(['colorful', 'graybeard', 'neutrino']);
-    });
-    Object.entries(styles).forEach(([name, builder]) => {
-        it(`should create and test an instance of ${name}`, () => {
-            expect(typeof builder).toBe('function');
-            const style = builder({ baseUrl: 'https://example.org' });
-            expect(JSON.stringify(style).length).toBeGreaterThan(50000);
-            expect(style.name).toBe('versatiles-' + name);
-            expect(style.glyphs).toBe('https://example.org/assets/fonts/{fontstack}/{range}.pbf');
-            expect(style.sprite).toBe('https://example.org/assets/sprites/sprites');
-            expect(Object.keys(style.sources).join(',')).toBe('versatiles-shortbread');
-            expect(style.sources['versatiles-shortbread'].tiles).toEqual(['https://example.org/tiles/osm/{z}/{x}/{y}']);
-        });
-    });
-});
-describe('Colorful', () => {
-    const style = styles.colorful({
-        baseUrl: 'https://dev.null',
-        colors: { commercial: '#f00' },
-    });
-    expect(style.glyphs).toBe('https://dev.null/assets/fonts/{fontstack}/{range}.pbf');
-    const paint = style.layers.find(l => l.id === 'land-commercial')?.paint;
-    expect(paint).toBeDefined();
-    if (paint == null)
-        throw Error();
-    expect(paint).toHaveProperty('fill-color');
-    if (!('fill-color' in paint))
-        throw Error();
-    expect(paint['fill-color']).toBe('#ff0000');
-});
-describe('guessStyle', () => {
-    const tiles = ['https://fancy.map/tiles/{z}/{x}/{y}'];
-    const vectorLayers = [{ id: 'hallo', fields: { label: 'String' } }];
-    it('should build raster styles', () => {
-        const style = guessStyle({
-            tiles,
-            format: 'png',
-        });
-        expect(style).toStrictEqual({
-            layers: [{ id: 'raster', source: 'rasterSource', type: 'raster' }],
-            sources: { rasterSource: { format: 'png', tilejson: '3.0.0', tiles, type: 'raster' } },
-            version: 8,
-        });
-    });
-    it('should build vector styles', () => {
-        const style = guessStyle({
-            tiles,
-            format: 'pbf',
-            vectorLayers,
-        });
-        expect(style).toStrictEqual({
-            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: vectorLayers } },
-            'version': 8,
-        });
-    });
-});

package/dist/lib/build_style.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/build_style.test.js

@@ -1,68 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import Color from 'color';
-import StyleBuilder from './build_style.js';
-// Mock class for abstract class StyleBuilder
-class MockStyleBuilder extends StyleBuilder {
-    name = 'mock';
-    defaultFonts = { regular: 'Arial' };
-    defaultColors = { primary: '#FF8800' };
-    negateColors() {
-        this.transformDefaultColors(color => color.negate());
-    }
-    getStyleRules(opt) {
-        for (const color of Object.values(opt.colors))
-            if (!(color instanceof Color))
-                throw Error();
-        for (const font of Object.values(opt.fonts))
-            if (typeof font !== 'string')
-                throw Error();
-        return {
-            'water-area': {
-                textColor: opt.colors.primary,
-                textSize: 12,
-                textFont: opt.fonts.regular,
-            },
-        };
-    }
-}
-describe('StyleBuilder', () => {
-    let builder;
-    beforeEach(() => {
-        builder = new MockStyleBuilder();
-    });
-    it('should create an instance of StyleBuilder', () => {
-        expect(builder).toBeInstanceOf(StyleBuilder);
-    });
-    it('should build a MaplibreStyle object', () => {
-        const style = builder.build();
-        expect(style).toBeDefined();
-        expect(style).toHaveProperty('name');
-        expect(style).toHaveProperty('layers');
-        expect(style).toHaveProperty('glyphs');
-        expect(style).toHaveProperty('sprite');
-    });
-    it('should transform colors correctly', () => {
-        const initialColor = builder.defaultColors.primary;
-        builder.negateColors();
-        expect(builder.defaultColors.primary).not.toBe(initialColor);
-        expect(builder.defaultColors.primary).toBe(Color(initialColor).negate().hexa());
-    });
-    describe('build method', () => {
-        it('should create a style object', () => {
-            const style = builder.build();
-            expect(style).toBeDefined();
-            expect(style).toHaveProperty('layers');
-            expect(style).toHaveProperty('name');
-            expect(style).toHaveProperty('glyphs');
-            expect(style).toHaveProperty('sprite');
-        });
-        it('should resolve urls correctly', () => {
-            const style = builder.build({ baseUrl: 'https://my.base.url/' });
-            expect(style.glyphs).toBe('https://my.base.url/assets/fonts/{fontstack}/{range}.pbf');
-            expect(style.sprite).toBe('https://my.base.url/assets/sprites/sprites');
-            const source = style.sources['versatiles-shortbread'];
-            expect(source).toHaveProperty('tiles');
-            expect(source.tiles[0]).toBe('https://my.base.url/tiles/osm/{z}/{x}/{y}');
-        });
-    });
-});

package/dist/lib/decorator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/decorator.test.js

@@ -1,55 +0,0 @@
-import { decorate } from './decorator.js';
-import Color from 'color';
-describe('decorate function', () => {
-    const mockLayers = [
-        { id: 'layer1', type: 'fill', layout: {}, paint: {}, source: 'versatiles-shortbread' },
-        { id: 'layer2', type: 'line', layout: {}, paint: {}, source: 'versatiles-shortbread' },
-    ];
-    const mockRules = {
-        'layer1': {
-            color: '#ff0000',
-            visibility: 'none',
-        },
-        'layer2': {
-            color: 'rgba(0, 255, 0, 0.5)',
-            visibility: 'visible',
-        },
-    };
-    it('should return an array of layers', () => {
-        const result = decorate(mockLayers, mockRules);
-        expect(Array.isArray(result)).toBe(true);
-    });
-    it('should apply styles from rules to the corresponding layers', () => {
-        const result = decorate(mockLayers, mockRules);
-        result.forEach(layer => {
-            if (layer.id === 'layer1') {
-                expect(layer.paint).toHaveProperty('fill-color', '#ff0000');
-                expect(layer.layout).toHaveProperty('visibility', 'none');
-            }
-            if (layer.id === 'layer2') {
-                expect(layer.paint).toHaveProperty('line-color', 'rgba(0, 255, 0, 0.5)');
-                expect(layer.layout).toHaveProperty('visibility', 'visible');
-            }
-        });
-    });
-    it('should handle color conversion correctly', () => {
-        const colorRule = {
-            'layer1': {
-                paintColor: new Color('#ff0000'),
-            },
-        };
-        const result = decorate(mockLayers, colorRule);
-        const layer0 = result[0];
-        expect(layer0).toBeDefined();
-        if (typeof layer0 === 'undefined')
-            return;
-        expect(layer0.paint).toBeDefined();
-        if (typeof layer0.paint === 'undefined')
-            return;
-        expect(layer0.paint).toHaveProperty('fill-color', '#ff0000');
-    });
-    it('should discard layers that have no style rules applied', () => {
-        const result = decorate(mockLayers, {});
-        expect(result.length).toBe(0);
-    });
-});

package/dist/lib/guess_style.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/guess_style.test.js

@@ -1,142 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import getTemplate from './shortbread/template.js';
-import guessStyle from './guess_style.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';
-        expect(guessStyle({ tiles, format }))
-            .toStrictEqual({
-            version: 8,
-            sources: { rasterSource: { format, tilejson: '3.0.0', tiles, type } },
-            layers: [{ id: 'raster', source: 'rasterSource', type }],
-        });
-    });
-    it('should build vector inspector styles', () => {
-        const type = 'vector';
-        const format = 'pbf';
-        expect(guessStyle({ tiles, format, vectorLayers: vectorLayersSomething }))
-            .toStrictEqual({
-            version: 8,
-            sources: { vectorSource: { format, tilejson: '3.0.0', tiles, type, vector_layers: vectorLayersSomething } },
-            layers: [
-                {
-                    id: 'background',
-                    type: 'background',
-                    paint: { 'background-color': '#fff' },
-                },
-                {
-                    id: 'vectorSource-geometry-fill',
-                    type: 'fill',
-                    source: 'vectorSource',
-                    'source-layer': 'geometry',
-                    filter: ['==', '$type', 'Polygon'],
-                    paint: { 'fill-antialias': true, 'fill-color': 'hsla(7,57%,56%,0.6)', 'fill-opacity': 0.3, 'fill-outline-color': 'hsla(7,57%,56%,0.6)' },
-                },
-                {
-                    id: 'vectorSource-geometry-line',
-                    type: 'line',
-                    source: 'vectorSource',
-                    'source-layer': 'geometry',
-                    filter: ['==', '$type', 'LineString'],
-                    layout: { 'line-cap': 'round', 'line-join': 'round' },
-                    paint: { 'line-color': 'hsla(7,57%,56%,0.6)' },
-                },
-                {
-                    id: 'vectorSource-geometry-circle',
-                    type: 'circle',
-                    source: 'vectorSource',
-                    'source-layer': 'geometry',
-                    filter: ['==', '$type', 'Point'],
-                    paint: { 'circle-color': 'hsla(7,57%,56%,0.6)', 'circle-radius': 2 },
-                },
-            ],
-        });
-    });
-    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]);
-            });
-        });
-    });
-    describe('absolute tile urls override baseUrl', () => {
-        cases.forEach(({ type, options }) => {
-            it(type, () => {
-                const style = guessStyle({ ...options, tiles: ['https://example1.org/tiles/{z}/{x}/{y}'], baseUrl: 'https://example2.org/' });
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                expect(Object.values(style.sources)[0].tiles).toEqual(['https://example1.org/tiles/{z}/{x}/{y}']);
-            });
-        });
-    });
-    describe('relative tile urls are resolved with baseUrl', () => {
-        cases.forEach(({ type, options }) => {
-            it(type, () => {
-                const style = guessStyle({ ...options, tiles: ['./{z}/{x}/{y}'], baseUrl: 'https://example2.org/tiles/' });
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                expect(Object.values(style.sources)[0].tiles).toEqual(['https://example2.org/tiles/{z}/{x}/{y}']);
-            });
-        });
-    });
-});

package/dist/lib/random_color.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/random_color.test.js

@@ -1,68 +0,0 @@
-import randomColorGenerator from './random_color.js';
-describe('RandomColor', () => {
-    let randomColor;
-    beforeEach(() => {
-        randomColor = randomColorGenerator();
-    });
-    test('constructor initializes without errors', () => {
-        expect(randomColor).toBeDefined();
-    });
-    describe('randomColor method', () => {
-        test('returns a valid color string', () => {
-            const color = randomColor();
-            expect(isValidHSLA(color)).toBeTruthy();
-        });
-        test('returns correct color string for some test cases', () => {
-            expect(randomColor({ hue: 'red' })).toBe('hsl(343,65%,51%)');
-            expect(randomColor({ hue: 120 })).toBe('hsl(120,77%,32%)');
-            expect(randomColor({ luminosity: 'dark' })).toBe('hsl(135,96%,31%)');
-            expect(randomColor({ saturation: 'strong' })).toBe('hsl(193,100%,24%)');
-            expect(randomColor({ opacity: 0.5 })).toBe('hsla(242,55%,42%,0.5)');
-            expect(randomColor({ seed: 'testSeed' })).toBe('hsl(185,90%,23%)');
-        });
-        test('consistent color generation with a seed', () => {
-            const options = { seed: 'consistentSeed' };
-            const color1 = randomColor(options);
-            const color2 = randomColor(options);
-            expect(color1).toBe(color2);
-        });
-        test('different color generation without a seed', () => {
-            const color1 = randomColor();
-            const color2 = randomColor();
-            expect(color1).not.toBe(color2);
-        });
-    });
-});
-function isValidHSLA(textColor) {
-    let match, h, s, l, a;
-    if (textColor.startsWith('hsla')) {
-        match = /^hsla\((\d+),(\d+)%,(\d+)%,([.0-9]+)\)$/.exec(textColor);
-        if (match == null)
-            return false;
-        [, h, s, l, a] = match;
-    }
-    else {
-        match = /^hsl\((\d+),(\d+)%,(\d+)%\)$/.exec(textColor);
-        if (match == null)
-            return false;
-        [, h, s, l] = match;
-        a = '1';
-    }
-    if (!check(h, 0, 360))
-        return false;
-    if (!check(s, 0, 100))
-        return false;
-    if (!check(l, 0, 100))
-        return false;
-    if (!check(a, 0, 1))
-        return false;
-    return true;
-    function check(textNumber, min, max) {
-        const value = parseFloat(textNumber);
-        if (value < min)
-            return false;
-        if (value > max)
-            return false;
-        return true;
-    }
-}

package/dist/lib/recolor.test.d.ts

@@ -1,13 +0,0 @@
-import type { StyleRules, StyleRulesOptions } from './types.js';
-import StyleBuilder from './build_style.js';
-export default class TestStyle extends StyleBuilder<TestStyle> {
-    readonly name: string;
-    defaultFonts: {};
-    defaultColors: {
-        c0: string;
-        c1: string;
-        c2: string;
-        c3: string;
-    };
-    protected getStyleRules(_options: StyleRulesOptions<TestStyle>): StyleRules;
-}

package/dist/lib/recolor.test.js

@@ -1,192 +0,0 @@
-import { getDefaultRecolorFlags, recolor } from './recolor.js';
-import StyleBuilder from './build_style.js';
-describe('colorTransformer', () => {
-    describe('getDefaultRecolorFlags', () => {
-        it('should return the default color transformer flags', () => {
-            const defaultFlags = getDefaultRecolorFlags();
-            expect(defaultFlags).toEqual({
-                invert: false,
-                rotate: 0,
-                saturate: 0,
-                gamma: 1,
-                contrast: 1,
-                brightness: 0,
-                tint: 0,
-                tintColor: '#FF0000',
-            });
-        });
-    });
-    describe('recolor', () => {
-        it('should not alter the colors if no flags are provided', () => {
-            const colors = getDefaultColors();
-            recolor(colors, {});
-            expect(colors).toEqual(getDefaultColors());
-        });
-        describe('invert', () => {
-            it('should invert colors when invert flag is true', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { invert: true });
-                expect(colors2string(colors)).toBe('0055AA00,FF005555,AAFF00AA,55AAFFFF');
-            });
-        });
-        describe('rotate', () => {
-            it('should rotate colors 120°', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { rotate: 120 });
-                expect(colors2string(colors)).toBe('55FFAA00,AA00FF55,FF5500AA,00AA55FF');
-            });
-            it('should rotate colors 180°', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { rotate: 180 });
-                expect(colors2string(colors)).toBe('55AAFF00,FF005555,AAFF00AA,0055AAFF');
-            });
-            it('should rotate colors 240°', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { rotate: 240 });
-                expect(colors2string(colors)).toBe('AA55FF00,FFAA0055,00FF55AA,5500AAFF');
-            });
-        });
-        describe('saturation', () => {
-            it('should remove any saturation', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { saturate: -1.0 });
-                expect(colors2string(colors)).toBe('AAAAAA00,80808055,808080AA,555555FF');
-            });
-            it('should decrease saturation', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { saturate: -0.5 });
-                expect(colors2string(colors)).toBe('D4AA7F00,40BF9555,6A40BFAA,7F552AFF');
-            });
-            it('should increase saturation', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { saturate: 0.5 });
-                expect(colors2string(colors)).toBe('FFAA2A00,00FFBF55,4000FFAA,D45500FF');
-            });
-            it('should maximize saturation', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { saturate: 1.0 });
-                expect(colors2string(colors)).toBe('FFAA0000,00FFD455,2B00FFAA,FF5500FF');
-            });
-        });
-        describe('gamma', () => {
-            it('should decrease gamma', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { gamma: 0.5 });
-                expect(colors2string(colors)).toBe('FFD09300,00FFD055,9300FFAA,D09300FF');
-            });
-            it('should increase gamma', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { gamma: 2 });
-                expect(colors2string(colors)).toBe('FF711C00,00FF7155,1C00FFAA,711C00FF');
-            });
-        });
-        describe('contrast', () => {
-            it('should remove any contrast', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { contrast: 0 });
-                expect(colors2string(colors)).toBe('80808000,80808055,808080AA,808080FF');
-            });
-            it('should decrease contrast', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { contrast: 0.5 });
-                expect(colors2string(colors)).toBe('BF956A00,40BF9555,6A40BFAA,956A40FF');
-            });
-            it('should increase contrast', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { contrast: 2 });
-                expect(colors2string(colors)).toBe('FFD52B00,00FFD555,2B00FFAA,D52B00FF');
-            });
-            it('should maximize contrast', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { contrast: Infinity });
-                expect(colors2string(colors)).toBe('FFFF0000,00FFFF55,0000FFAA,FF0000FF');
-            });
-        });
-        describe('contrast', () => {
-            it('should remove any brightness', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { brightness: -1 });
-                expect(colors2string(colors)).toBe('00000000,00000055,000000AA,000000FF');
-            });
-            it('should decrease brightness', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { brightness: -0.5 });
-                expect(colors2string(colors)).toBe('80552B00,00805555,2B0080AA,552B00FF');
-            });
-            it('should increase brightness', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { brightness: 0.5 });
-                expect(colors2string(colors)).toBe('FFD5AA00,80FFD555,AA80FFAA,D5AA80FF');
-            });
-            it('should maximize brightness', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { brightness: 1 });
-                expect(colors2string(colors)).toBe('FFFFFF00,FFFFFF55,FFFFFFAA,FFFFFFFF');
-            });
-        });
-        describe('tint', () => {
-            it('should not tint at all', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { tint: 0, tintColor: '#F00' });
-                expect(colors2string(colors)).toBe('FFAA5500,00FFAA55,5500FFAA,AA5500FF');
-            });
-            it('should tint a little bit red', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { tint: 0.5, tintColor: '#F00' });
-                expect(colors2string(colors)).toBe('FF552B00,80805555,AA0080AA,D52B00FF');
-            });
-            it('should tint a little bit yellow', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { tint: 0.5, tintColor: '#FF0' });
-                expect(colors2string(colors)).toBe('FFD52B00,80FF5555,AA8080AA,D5AA00FF');
-            });
-            it('should tint a little bit green', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { tint: 0.5, tintColor: '#0F0' });
-                expect(colors2string(colors)).toBe('80D52B00,00FF5555,2B8080AA,55AA00FF');
-            });
-            it('should tint a little bit blue', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { tint: 0.5, tintColor: '#00F' });
-                expect(colors2string(colors)).toBe('8055AA00,0080D555,2B00FFAA,552B80FF');
-            });
-            it('should tint a strongly orange', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { tint: 0.5, tintColor: '#F80' });
-                expect(colors2string(colors)).toBe('FF992B00,80C45555,AA4480AA,D56F00FF');
-            });
-            it('should tint a strongly blue', () => {
-                const colors = getDefaultColors();
-                recolor(colors, { tint: 0.5, tintColor: '#00F' });
-                expect(colors2string(colors)).toBe('8055AA00,0080D555,2B00FFAA,552B80FF');
-            });
-        });
-    });
-});
-function colors2string(colors) {
-    const colorArray = [
-        colors.c0,
-        colors.c1,
-        colors.c2,
-        colors.c3,
-    ];
-    return colorArray.map(c => c.hexa().slice(1)).join(',');
-}
-export default class TestStyle extends StyleBuilder {
-    name = 'teststyle';
-    defaultFonts = {};
-    defaultColors = {
-        c0: '#FFAA5500',
-        c1: '#00FFAA55',
-        c2: '#5500FFAA',
-        c3: '#AA5500FF',
-    };
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getStyleRules(_options) {
-        throw new Error('Method not implemented.');
-    }
-}
-function getDefaultColors() {
-    const style = new TestStyle();
-    return style.getColors(style.defaultColors);
-}

package/dist/lib/shortbread/layers.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/shortbread/layers.test.js

@@ -1,27 +0,0 @@
-import getLayers from './layers.js';
-describe('layers', () => {
-    it('should return an array of MaplibreLayer', () => {
-        const languageSuffix = '_en';
-        const layers = getLayers({ languageSuffix });
-        expect(Array.isArray(layers)).toBe(true);
-        expect(layers).not.toHaveLength(0);
-        layers.forEach((layer) => {
-            expect(layer).toHaveProperty('id');
-            expect(layer).toHaveProperty('type');
-        });
-    });
-    it('should handle language suffix correctly', () => {
-        const languageSuffix = '_en';
-        const layers = getLayers({ languageSuffix });
-        const labelLayer = layers.find((layer) => layer.id === 'label-street-pedestrian');
-        expect(labelLayer).toBeDefined();
-        expect(labelLayer.layout?.['text-field']).toContain('{name_en}');
-    });
-    it('should create appropriate filters for land layers', () => {
-        const languageSuffix = '_en';
-        const layers = getLayers({ languageSuffix });
-        const landLayer = layers.find((layer) => layer.id === 'land-agriculture');
-        expect(landLayer).toBeDefined();
-        expect(landLayer.filter).toEqual(['all', ['in', 'kind', 'brownfield', 'farmland', 'farmyard', 'greenfield', 'greenhouse_horticulture', 'orchard', 'plant_nursery', 'vineyard']]);
-    });
-});

package/dist/lib/shortbread/properties.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/shortbread/properties.test.js

@@ -1,36 +0,0 @@
-import propertyLookup from './properties.js';
-describe('propertyLookup', () => {
-    it('should be a Map', () => {
-        expect(propertyLookup).toBeInstanceOf(Map);
-    });
-    it('should contain keys for each type and property', () => {
-        const expectedTypes = ['background', 'fill', 'line', 'symbol'];
-        expectedTypes.forEach(type => {
-            propertyLookup.forEach((value, key) => {
-                if (key.startsWith(type)) {
-                    expect(key).toMatch(new RegExp(`^${type}\/`));
-                }
-            });
-        });
-    });
-    it('should contain the correct properties for each type', () => {
-        const expectedProps = ['filter', 'maxzoom', 'minzoom', 'visibility'];
-        expectedProps.forEach(prop => {
-            propertyLookup.forEach((value, key) => {
-                if (key.endsWith(prop)) {
-                    expect(value.some((p) => p.key === prop)).toBeTruthy();
-                }
-            });
-        });
-    });
-    it('should store properties with the correct structure', () => {
-        propertyLookup.forEach(properties => {
-            properties.forEach((prop) => {
-                expect(prop).toHaveProperty('key');
-                expect(prop).toHaveProperty('parent');
-                expect(prop).toHaveProperty('valueType');
-                expect(['layer', 'layout', 'paint']).toContain(prop.parent);
-            });
-        });
-    });
-});

package/dist/lib/shortbread/template.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/shortbread/template.test.js

@@ -1,55 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import getTemplate from './template.js';
-describe('getTemplate', () => {
-    const styleTemplate = getTemplate();
-    it('returns a style object with the correct version', () => {
-        expect(styleTemplate).toHaveProperty('version', 8);
-    });
-    it('has the expected name for the style', () => {
-        expect(styleTemplate).toHaveProperty('name', 'versatiles');
-    });
-    it('contains metadata with expected properties', () => {
-        expect(styleTemplate).toHaveProperty('metadata');
-        expect(styleTemplate.metadata).toHaveProperty('maputnik:renderer', 'mbgljs');
-        expect(styleTemplate.metadata).toHaveProperty('license', 'https://creativecommons.org/publicdomain/zero/1.0/');
-    });
-    it('specifies glyphs and sprite URLs correctly', () => {
-        expect(styleTemplate).toHaveProperty('glyphs', 'https://tiles.versatiles.org/fonts/{fontstack}/{range}.pbf');
-        expect(styleTemplate).toHaveProperty('sprite', 'https://tiles.versatiles.org/sprites/sprites');
-    });
-    it('defines sources with required properties', () => {
-        expect(styleTemplate).toHaveProperty('sources');
-        const sources = styleTemplate.sources['versatiles-shortbread'];
-        expect(sources).toHaveProperty('type', 'vector');
-        expect(sources).toHaveProperty('scheme', 'xyz');
-        expect(sources).toHaveProperty('format', 'pbf');
-        expect(sources).toHaveProperty('tiles');
-        expect(sources.tiles).toContain('https://tiles.versatiles.org/tiles/osm/{z}/{x}/{y}');
-    });
-    it('sets bounds to the expected global extent', () => {
-        const expectedBounds = [-180, -85.0511287798066, 180, 85.0511287798066];
-        expect(styleTemplate.sources['versatiles-shortbread']).toHaveProperty('bounds', expectedBounds);
-    });
-    it('has layers array initialized as empty', () => {
-        expect(styleTemplate).toHaveProperty('layers');
-        expect(styleTemplate.layers).toEqual([]);
-    });
-    describe('sources vector_layers validation', () => {
-        expect(styleTemplate).toBeDefined();
-        expect(styleTemplate.sources).toBeDefined();
-        const { vector_layers } = styleTemplate.sources['versatiles-shortbread'];
-        expect(typeof vector_layers).toBe('object');
-        it('contains vector_layers with id and fields', () => {
-            expect(Array.isArray(vector_layers)).toBeTruthy();
-            vector_layers.forEach(layer => {
-                expect(layer).toHaveProperty('id');
-                expect(layer).toHaveProperty('fields');
-            });
-        });
-        it('has maxzoom set to 14 for all vector layers', () => {
-            vector_layers.forEach(layer => {
-                expect(layer).toHaveProperty('maxzoom', 14);
-            });
-        });
-    });
-});

package/dist/lib/utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/utils.test.js

@@ -1,115 +0,0 @@
-import { deepClone, isSimpleObject, isBasicType, deepMerge, resolveUrl } from './utils.js';
-import Color from 'color';
-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');
-    });
-});