@fxi/zartigl 0.9.2 → 0.10.0

package/dist/zartigl.d.ts

@@ -2,6 +2,19 @@ import { CustomLayerInterface } from 'maplibre-gl';
 import { CustomRenderMethodInput } from 'maplibre-gl';
 import { Map as Map_2 } from 'maplibre-gl';
 
+/**
+ * Transparent ends of a ramp, as fractions of the ramp from each end: `low`
+ * fades the lowest values in from transparent, `high` fades the highest out.
+ */
+export declare interface AlphaFade {
+    low?: number;
+    high?: number;
+    curve?: AlphaFadeCurve;
+}
+
+/** Shape of an alpha fade inside its zone; the same curves as `logScale`. */
+export declare type AlphaFadeCurve = "linear" | "log" | "exp";
+
 /** Particle backdrop off: see BackdropStyle. */
 export declare const BACKDROP_OFF: Readonly<BackdropStyle>;
 
@@ -532,7 +545,7 @@ declare interface GeoVideoScalarEncoding {
     codeMax: number;
     valueMin: number;
     valueMax: number;
-    transfer: "linear";
+    transfer: "linear" | "log10-1p9";
     colorSpace: "bt709";
     colorRange: "limited" | "full";
 }
@@ -566,7 +579,13 @@ declare interface GeoVideoVectorEncoding {
     colorRange: "limited" | "full";
 }
 
-export declare function getPalettes(): PaletteMeta[];
+/**
+ * Palettes to offer, without deprecated ones (still resolvable for old
+ * configs) unless `includeDeprecated`.
+ */
+export declare function getPalettes(options?: {
+    includeDeprecated?: boolean;
+}): PaletteMeta[];
 
 export declare function getVectorDerivationVariables(derivation: VectorDerivation): [string, string];
 
@@ -611,6 +630,8 @@ declare type LayerEventMap_2 = {
 declare interface LayerStyle {
     /** Palette id; undefined lets the engine pick its own. */
     palette?: string;
+    /** Run the palette from its last color to its first, for raster and particles. */
+    reversePalette: boolean;
     renderMode: StyleRenderMode;
     particles: ParticleStyle;
     raster: RasterStyle;
@@ -619,6 +640,7 @@ declare interface LayerStyle {
 /** A partial style: any key left out takes the value below it. */
 declare interface LayerStyleInput {
     palette?: string;
+    reversePalette?: boolean;
     renderMode?: StyleRenderMode;
     particles?: ParticleStyleInput;
     raster?: Partial<RasterStyle>;
@@ -630,6 +652,10 @@ export declare const LEGACY_STYLE_SETTINGS: Readonly<Partial<Record<keyof Zartig
 export declare type Legend = {
     type: "gradient";
     palette: string;
+    /** The palette runs from its last color to its first. */
+    reverse?: boolean;
+    /** Transparent ends of the ramp, already in the legend colors. */
+    alphaFade?: AlphaFade;
     min?: number;
     max?: number;
     unit?: string;
@@ -872,6 +898,17 @@ declare interface RasterStyle {
     vibrance: number;
     /** Fixed physical-value domain; null follows the data. */
     colorDomain: [number, number] | null;
+    /**
+     * Fraction of the color range, from its low end, over which colors fade in
+     * from transparent, [0, 1]: a field that is mostly zero (fires, heat
+     * stress) shows only where something happens. Values below the domain are
+     * transparent too.
+     */
+    alphaFadeLow: number;
+    /** Fraction of the color range, from its high end, fading out, [0, 1]. */
+    alphaFadeHigh: number;
+    /** Shape of both fades: "log" rises fast, "exp" stays faint longer. */
+    alphaFadeCurve: AlphaFadeCurve;
 }
 
 export declare type RenderMode = "raster" | "particles" | "raster+particles";
@@ -890,6 +927,16 @@ export declare function resolveBackdrop(input?: Partial<BackdropStyle>): Backdro
  */
 export declare function resolveColorGrade(input?: Partial<ColorGrade>): ColorGrade;
 
+/**
+ * Stops of a ramp, reversed on request, then with `alphaFade` multiplied into
+ * the alpha of its ends. The fade follows positions, not colors: on a reversed
+ * ramp it still fades the low values.
+ */
+export declare function resolveColorRamp(input: ColorRampInput, options?: {
+    reverse?: boolean;
+    alphaFade?: AlphaFade;
+}): Record<number, string>;
+
 /** Resolve a native date/time control value against actual available times. */
 export declare function resolveTimeInputSelection(values: readonly number[], value: string, granularity: TimeGranularity): number | undefined;
 
@@ -1080,11 +1127,6 @@ export declare function stitchVelocityChunks(uChunks: Array<{
     north: number;
 }, latDescending?: boolean, scalarMode?: boolean): VelocityData;
 
-/**
- * Layer style: how a layer looks, with the same keys in the catalog
- * `defaults`, the engines and story views. Playback (how time moves) is not
- * part of it, so `particles.speed` is always the particle speed.
- */
 declare type StyleRenderMode = "particles" | "raster" | "raster+particles";
 
 export declare type TimeGranularity = "year" | "month" | "day" | "hour" | "minute" | "second";
@@ -1101,6 +1143,11 @@ export declare interface TimeMeta {
     timelineKind?: GeoVideoManifest["timeline"]["kind"];
 }
 
+/**
+ * Time windows shared by zartigl and the renderers built on its engine: a
+ * fixed `start`/`end`, either side open, or the `trailing` ISO 8601 duration
+ * before the latest available time.
+ */
 export declare type TimeRange = {
     start?: Date | string | number;
     end?: Date | string | number;
@@ -1839,6 +1886,8 @@ export declare interface ZartiglOptions {
 
 export declare interface ZartiglSettings {
     palette: ColorRampInput;
+    /** Run the palette from its last color to its first. */
+    reversePalette: boolean;
     particleDensity: number;
     speed: number;
     fade: number;
@@ -1855,6 +1904,10 @@ export declare interface ZartiglSettings {
     backdrop: Partial<BackdropStyle>;
     /** Fixed physical-value domain for scalar colors. Null uses frame extrema. */
     colorDomain: [number, number] | null;
+    /** Transparent ends of the color range, as in RasterStyle. */
+    alphaFadeLow: number;
+    alphaFadeHigh: number;
+    alphaFadeCurve: AlphaFadeCurve;
     particleState: ParticleStateMode;
     rgba8MaxParticleZoom: number;
 }