@versatiles/style 5.2.0 → 5.2.2

package/dist/color/abstract.d.ts

@@ -8,9 +8,10 @@ export declare abstract class Color {
     static HSV: typeof HSV;
     static RGB: typeof RGB;
     static random: (options?: RandomColorOptions) => HSV;
-    abstract clone(): InstanceType<typeof Color>;
+    abstract clone(): Color;
     asHex(): string;
     abstract asString(): string;
+    abstract round(): Color;
     abstract asArray(): number[];
     abstract asHSL(): HSL;
     abstract asHSV(): HSV;
@@ -28,5 +29,5 @@ export declare abstract class Color {
     lighten(value: number): RGB;
     darken(value: number): RGB;
     tint(value: number, tintColor: Color): RGB;
-    abstract fade(value: number): InstanceType<typeof Color>;
+    abstract fade(value: number): Color;
 }

package/dist/color/hsl.d.ts

@@ -7,7 +7,8 @@ export declare class HSL extends Color {
     l: number;
     a: number;
     constructor(h: number, s: number, l: number, a?: number);
-    asArray(): number[];
+    asArray(): [number, number, number, number];
+    round(): HSL;
     clone(): HSL;
     asString(): string;
     asHSL(): HSL;

package/dist/color/hsl.js

@@ -17,6 +17,13 @@ export class HSL extends Color {
     asArray() {
         return [this.h, this.s, this.l, this.a];
     }
+    round() {
+        this.h = Math.round(this.h);
+        this.s = Math.round(this.s);
+        this.l = Math.round(this.l);
+        this.a = Math.round(this.a * 1000) / 1000;
+        return this;
+    }
     clone() {
         return new HSL(this.h, this.s, this.l, this.a);
     }
@@ -86,12 +93,7 @@ export class HSL extends Color {
         return this;
     }
     saturate(ratio) {
-        if (ratio < 0) {
-            this.s = clamp(this.s * (1 + ratio), 0, 100);
-        }
-        else {
-            this.s = clamp(100 - (100 - this.s) * (1 - ratio), 0, 100);
-        }
+        this.s = clamp(this.s * (1 + ratio), 0, 100);
         return this;
     }
     fade(value) {

package/dist/color/hsv.d.ts

@@ -7,7 +7,8 @@ export declare class HSV extends Color {
     v: number;
     a: number;
     constructor(h: number, s: number, v: number, a?: number);
-    asArray(): number[];
+    asArray(): [number, number, number, number];
+    round(): HSV;
     asString(): string;
     clone(): HSV;
     asHSL(): HSL;

package/dist/color/hsv.js

@@ -17,6 +17,13 @@ export class HSV extends Color {
     asArray() {
         return [this.h, this.s, this.v, this.a];
     }
+    round() {
+        this.h = Math.round(this.h);
+        this.s = Math.round(this.s);
+        this.v = Math.round(this.v);
+        this.a = Math.round(this.a * 1000) / 1000;
+        return this;
+    }
     asString() {
         return this.asHSL().asString();
     }

package/dist/color/index.d.ts

@@ -1,3 +1,6 @@
 import { Color } from './abstract.js';
+export type { RandomColorOptions } from './random.js';
+export type { HSL } from './hsl.js';
+export type { HSV } from './hsv.js';
+export type { RGB } from './rgb.js';
 export { Color };
-export default Color;

package/dist/color/index.js

@@ -24,4 +24,3 @@ Color.HSV = HSV;
 Color.RGB = RGB;
 Color.random = randomColor;
 export { Color };
-export default Color;

package/dist/color/random.js

@@ -49,18 +49,24 @@ export default function randomColor(options) {
     }
     function pickBrightness(h, s, options) {
         let bMin = getMinimumBrightness(h, s), bMax = 100;
-        switch (options.luminosity) {
-            case 'dark':
-                bMax = Math.min(100, bMin + 20);
-                break;
-            case 'light':
-                bMin = (bMax + bMin) / 2;
-                break;
-            case 'random':
-                bMin = 0;
-                bMax = 100;
-                break;
-            default:
+        if (typeof options.luminosity === 'number') {
+            bMin = options.luminosity;
+            bMax = options.luminosity;
+        }
+        else {
+            switch (options.luminosity) {
+                case 'dark':
+                    bMax = Math.min(100, bMin + 20);
+                    break;
+                case 'light':
+                    bMin = (bMax + bMin) / 2;
+                    break;
+                case 'random':
+                    bMin = 0;
+                    bMax = 100;
+                    break;
+                default:
+            }
         }
         return randomWithin([bMin, bMax]);
         function getMinimumBrightness(h, s) {

package/dist/color/rgb.d.ts

@@ -8,7 +8,8 @@ export declare class RGB extends Color {
     a: number;
     constructor(r: number, g: number, b: number, a?: number);
     clone(): RGB;
-    asArray(): number[];
+    asArray(): [number, number, number, number];
+    round(): RGB;
     asString(): string;
     asHex(): string;
     asHSL(): HSL;

package/dist/color/rgb.js

@@ -20,6 +20,13 @@ export class RGB extends Color {
     asArray() {
         return [this.r, this.g, this.b, this.a];
     }
+    round() {
+        this.r = Math.round(this.r);
+        this.g = Math.round(this.g);
+        this.b = Math.round(this.b);
+        this.a = Math.round(this.a * 1000) / 1000;
+        return this;
+    }
     asString() {
         if (this.a === 1) {
             return `rgb(${this.r.toFixed(0)},${this.g.toFixed(0)},${this.b.toFixed(0)})`;

package/dist/guess_style/guess_style.d.ts

@@ -1,5 +1,8 @@
-import type { MaplibreStyle } from '../types/index.js';
-import type { Container } from '@versatiles/container';
-import type { GuessContainerOptions, GuessStyleOptions } from './types.js';
-export declare function guessStyle(opt: GuessStyleOptions): MaplibreStyle;
-export declare function guessStyleFromContainer(container: Container, options: GuessContainerOptions): Promise<MaplibreStyle>;
+import type { TileJSONSpecification } from '../types/index.js';
+import type { SpriteSpecification, StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+export interface GuessStyleOptions {
+    baseUrl?: string;
+    glyphs?: string;
+    sprite?: SpriteSpecification;
+}
+export declare function guessStyle(tileJSON: TileJSONSpecification, options?: GuessStyleOptions): StyleSpecification;

package/dist/guess_style/guess_style.js

@@ -1,112 +1,33 @@
-import { isTileJSONSpecification, isVectorLayers } from '../types/index.js';
-import { resolveUrl } from '../lib/utils.js';
+import { isTileJSONSpecification } from '../types/index.js';
+import { deepClone, resolveUrl } from '../lib/utils.js';
 import { colorful } from '../styles/index.js';
 import { Color } from '../color/index.js';
-export function guessStyle(opt) {
-    const { format } = opt;
-    const tilejsonBasic = {
-        tilejson: '3.0.0',
-        attribution: opt.attribution,
-        tiles: opt.tiles,
-        scheme: opt.scheme,
-        bounds: opt.bounds,
-        center: opt.center,
-        description: opt.description,
-        fillzoom: opt.fillzoom,
-        grids: opt.grids,
-        legend: opt.legend,
-        minzoom: opt.minzoom,
-        maxzoom: opt.maxzoom,
-        name: opt.name,
-        template: opt.template,
-    };
-    const { baseUrl } = opt;
-    if (typeof baseUrl === 'string') {
-        tilejsonBasic.tiles = tilejsonBasic.tiles.map(url => resolveUrl(baseUrl, url));
-    }
-    let k;
-    for (k in tilejsonBasic) {
-        if (tilejsonBasic[k] === undefined)
-            delete tilejsonBasic[k];
-    }
-    let tilejson;
-    let vectorLayers;
-    switch (format) {
-        case 'avif':
-        case 'jpg':
-        case 'png':
-        case 'webp':
-            tilejson = { ...tilejsonBasic, type: 'raster', format };
-            break;
-        case 'pbf':
-            vectorLayers = opt.vectorLayers;
-            if (!isVectorLayers(vectorLayers))
-                throw Error('property vector_layers is invalid');
-            tilejson = { ...tilejsonBasic, type: 'vector', format, vector_layers: vectorLayers };
-            break;
-        default:
-            throw Error(`format "${String(format)}" is not supported`);
+import { isRasterTileJSONSpecification } from '../types/tilejson.js';
+export function guessStyle(tileJSON, options) {
+    tileJSON = deepClone(tileJSON);
+    if (options && options.baseUrl) {
+        const { baseUrl } = options;
+        tileJSON.tiles = tileJSON.tiles.map(url => resolveUrl(baseUrl, url));
     }
-    if (!isTileJSONSpecification(tilejson))
-        throw Error();
+    if (!isTileJSONSpecification(tileJSON))
+        throw Error('Invalid TileJSON specification');
     let style;
-    switch (tilejson.type) {
-        case 'raster':
-            style = getImageStyle(tilejson);
-            break;
-        case 'vector':
-            if (isShortbread(tilejson)) {
-                style = getShortbreadStyle(tilejson, opt);
-            }
-            else {
-                style = getInspectorStyle(tilejson);
-            }
-    }
-    if (opt.minzoom ?? 0)
-        style.zoom ??= opt.minzoom;
-    if (opt.bounds)
-        style.center ??= [
-            (opt.bounds[0] + opt.bounds[2]) / 2,
-            (opt.bounds[1] + opt.bounds[3]) / 2,
-        ];
-    if (opt.center)
-        style.center = opt.center;
-    return style;
-}
-export async function guessStyleFromContainer(container, options) {
-    const header = await container.getHeader();
-    const metadata = await container.getMetadata();
-    const format = header.tileFormat;
-    switch (format) {
-        case 'avif':
-        case 'jpg':
-        case 'pbf':
-        case 'png':
-        case 'webp':
-            break;
-        default:
-            throw Error(`format "${String(format)}" is not supported`);
+    if (isRasterTileJSONSpecification(tileJSON)) {
+        style = getRasterStyle(tileJSON);
     }
-    let vectorLayers;
-    if (typeof metadata === 'string') {
-        try {
-            const t = JSON.parse(metadata);
-            if (('vector_layers' in t) && Array.isArray(t.vector_layers))
-                vectorLayers = t.vector_layers;
+    else {
+        if (isShortbread(tileJSON)) {
+            style = getShortbreadStyle(tileJSON, {
+                baseUrl: options?.baseUrl,
+                glyphs: options?.glyphs,
+                sprite: options?.sprite,
+            });
         }
-        catch (error) {
-            console.log(error);
+        else {
+            style = getInspectorStyle(tileJSON);
         }
     }
-    const guessStyleOptions = {
-        ...options,
-        format,
-        bounds: header.bbox,
-        minzoom: header.zoomMin,
-        maxzoom: header.zoomMax,
-        vectorLayers,
-    };
-    return guessStyle(guessStyleOptions);
+    return style;
 }
 function isShortbread(spec) {
     if (typeof spec !== 'object')
@@ -187,7 +108,7 @@ function getInspectorStyle(spec) {
     return {
         version: 8,
         sources: {
-            [sourceName]: spec,
+            [sourceName]: sourceFromSpec(spec, 'vector'),
         },
         layers: [
             ...layers.background,
@@ -197,11 +118,13 @@ function getInspectorStyle(spec) {
         ],
     };
 }
-function getImageStyle(spec) {
+function getRasterStyle(spec) {
     const sourceName = 'rasterSource';
     return {
         version: 8,
-        sources: { [sourceName]: spec },
+        sources: {
+            [sourceName]: sourceFromSpec(spec, 'raster'),
+        },
         layers: [{
                 id: 'raster',
                 type: 'raster',
@@ -209,3 +132,15 @@ function getImageStyle(spec) {
             }],
     };
 }
+function sourceFromSpec(spec, type) {
+    const source = { tiles: spec.tiles, type };
+    if (spec.minzoom != null)
+        source.minzoom = spec.minzoom;
+    if (spec.maxzoom != null)
+        source.maxzoom = spec.maxzoom;
+    if (spec.attribution != null)
+        source.attribution = spec.attribution;
+    if (spec.scheme != null)
+        source.scheme = spec.scheme;
+    return source;
+}

package/dist/guess_style/index.d.ts

@@ -1,2 +1,2 @@
-export type { GuessStyleOptions, GuessContainerOptions } from './types.js';
-export { guessStyle, guessStyleFromContainer } from './guess_style.js';
+export type { GuessStyleOptions } from './guess_style.js';
+export { guessStyle } from './guess_style.js';

package/dist/guess_style/index.js

@@ -1 +1 @@
-export { guessStyle, guessStyleFromContainer } from './guess_style.js';
+export { guessStyle } from './guess_style.js';

package/dist/index.d.ts

@@ -1,6 +1,11 @@
 export type * from './styles/index.js';
-export * from './styles/index.js';
-export { guessStyle, guessStyleFromContainer } from './guess_style/index.js';
-export type { GuessStyleOptions, GuessContainerOptions } from './guess_style/index.js';
+export * as styles from './styles/index.js';
+export type { GuessStyleOptions } from './guess_style/index.js';
+export type { RGB, HSL, HSV, RandomColorOptions } from './color/index.js';
+export type { TileJSONSpecification, TileJSONSpecificationRaster, TileJSONSpecificationVector } from './types/tilejson.js';
 export type { VectorLayer } from './types/index.js';
-export { default as Color } from './color/index.js';
+export type { StyleBuilderOptions, StyleBuilderColorStrings, StyleBuilderFontStrings, Language, StyleBuilderColorKeys, StyleBuilderFontKeys } from './style_builder/types.js';
+export type { RecolorOptions } from './style_builder/recolor.js';
+export type { StyleBuilder } from './style_builder/style_builder.js';
+export { guessStyle } from './guess_style/index.js';
+export { Color } from './color/index.js';

package/dist/index.js

@@ -1,3 +1,3 @@
-export * from './styles/index.js';
-export { guessStyle, guessStyleFromContainer } from './guess_style/index.js';
-export { default as Color } from './color/index.js';
+export * as styles from './styles/index.js';
+export { guessStyle } from './guess_style/index.js';
+export { Color } from './color/index.js';

package/dist/lib/utils.js

@@ -1,4 +1,4 @@
-import Color from '../color/index.js';
+import { Color } from '../color/index.js';
 // Utility function to deep clone an object
 export function deepClone(obj) {
     const type = typeof obj;

package/dist/shortbread/template.d.ts

@@ -1,2 +1,4 @@
-import type { MaplibreStyleVector } from '../types/index.js';
-export declare function getShortbreadTemplate(): MaplibreStyleVector;
+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[];