maplibre-gl-layers 0.15.0 → 0.17.0

package/dist/internalTypes.d.ts

@@ -1,15 +1,30 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.15.0
+ * version: 0.17.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
+ * git.commit.hash: 9fe9aa30db6602d13643e32c94af39ae2b26b082
  */
 
-import { SpriteMode, SpriteAnchor, SpriteInterpolationOptions, SpriteImageOriginLocation, SpriteLocation, SpriteTextGlyphHorizontalAlign, SpriteTextureMagFilter, SpriteTextureMinFilter, SpriteInterpolationMode, EasingFunction, SpriteScreenPoint, SpritePoint, SpriteEasingPresetName } from './types';
+import { SpriteMode, SpriteAnchor, SpriteInterpolationOptions, SpriteImageOriginLocation, SpriteLocation, SpriteTextGlyphHorizontalAlign, SpriteTextureMagFilter, SpriteTextureMinFilter, SpriteInterpolationMode, SpriteScreenPoint, SpritePoint, SpriteEasingParam, SpriteImageLineAttributeState, SpriteImageState, SpriteInterpolatedValues, SpriteImageInterpolatedOffset } from './types';
 import { ResolvedSpriteScalingOptions, SurfaceCorner } from './utils/math';
+export interface Releasable {
+    readonly release: () => void;
+}
+export type RgbaColor = readonly [number, number, number, number];
+/**
+ * Represents a projected three dimensional position.
+ * `MercatorCoordinate` uses the web mercator projection ([EPSG:3857](https://epsg.io/3857)) with slightly different units:
+ * - the size of 1 unit is the width of the projected world instead of the "mercator meter"
+ * - the origin of the coordinate space is at the north-west corner instead of the middle
+ */
+export interface SpriteMercatorCoordinate {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
 /**
  * The handle value that using the instance.
  */
@@ -157,34 +172,32 @@ export interface RenderTargetBucketBuffers {
     readonly originTargetIndices: Int32Array;
 }
 /**
- * Represents a projected three dimensional position.
- * `MercatorCoordinate` uses the web mercator projection ([EPSG:3857](https://epsg.io/3857)) with slightly different units:
- * - the size of 1 unit is the width of the projected world instead of the "mercator meter"
- * - the origin of the coordinate space is at the north-west corner instead of the middle
+ * Mutable interpolation states.
  */
-export interface SpriteMercatorCoordinate {
-    readonly x: number;
-    readonly y: number;
-    readonly z: number;
+export interface MutableSpriteInterpolation<TValue> {
+    state: SpriteInterpolationState<TValue> | null;
+    options: Readonly<SpriteInterpolationOptions> | null;
+    lastCommandValue: TValue;
+    baseValue: TValue | undefined;
+    targetValue: TValue | undefined;
 }
 /**
- * Mutable counterpart to {@link InterpolatedValues}, used internally so SpriteLayer
+ * Mutable counterpart to {@link SpriteInterpolatedValues}, used internally so SpriteLayer
  * can reuse object references while still exposing readonly snapshots publicly.
  */
-export interface MutableInterpolatedValues<T> {
-    current: T;
-    from: T | undefined;
-    to: T | undefined;
+export interface MutableSpriteInterpolatedValues<TValue> extends SpriteInterpolatedValues<TValue> {
+    current: TValue;
+    from: TValue | undefined;
+    to: TValue | undefined;
+    invalidated: boolean | undefined;
+    interpolation: MutableSpriteInterpolation<TValue>;
 }
-export interface MutableSpriteImageInterpolatedOffset {
-    offsetMeters: MutableInterpolatedValues<number>;
-    offsetDeg: MutableInterpolatedValues<number>;
-}
-export interface Releasable {
-    readonly release: () => void;
+export interface MutableSpriteImageInterpolatedOffset extends SpriteImageInterpolatedOffset {
+    offsetMeters: MutableSpriteInterpolatedValues<number>;
+    offsetDeg: MutableSpriteInterpolatedValues<number>;
 }
 /**
- * Abstraction that exposes projection-related helpers.
+ * Mimimum abstraction that exposes projection-related helpers.
  */
 export interface ProjectionHost extends Releasable {
     /**
@@ -192,11 +205,16 @@ export interface ProjectionHost extends Releasable {
      * @returns Zoom level.
      */
     readonly getZoom: () => number;
+    /**
+     * Get camera location.
+     * @returns Camera location when viewport is available.
+     */
+    readonly getCameraLocation: () => SpriteLocation | undefined;
     /**
      * Extracts the current clip-space context if the mercator matrix is available.
-     * @returns {ClipContext | null} Clip context or `null` when the transform is not ready.
+     * @returns {ClipContext | undefined} Clip context or `undefined` when the transform is not ready.
      */
-    readonly getClipContext: () => ClipContext | null;
+    readonly getClipContext: () => ClipContext | undefined;
     /**
      * Get mercator coordinate from the location
      * @param location Location.
@@ -208,13 +226,13 @@ export interface ProjectionHost extends Releasable {
      * @param location Location.
      * @returns Projected point if valid location.
      */
-    readonly project: (location: Readonly<SpriteLocation>) => SpritePoint | null;
+    readonly project: (location: Readonly<SpriteLocation>) => SpritePoint | undefined;
     /**
      * Unproject the location.
      * @param point Projected point.
      * @returns Location if valid point.
      */
-    readonly unproject: (point: Readonly<SpritePoint>) => SpriteLocation | null;
+    readonly unproject: (point: Readonly<SpritePoint>) => SpriteLocation | undefined;
     /**
      * Calculate perspective ratio.
      * @param location Location.
@@ -222,7 +240,6 @@ export interface ProjectionHost extends Releasable {
      * @returns The ratio.
      */
     readonly calculatePerspectiveRatio: (location: Readonly<SpriteLocation>, cachedMercator?: SpriteMercatorCoordinate) => number;
-    readonly getCameraLocation: () => SpriteLocation | null;
 }
 export interface PrepareDrawSpriteImageParamsBase {
     readonly imageResources: ImageResourceTable;
@@ -233,7 +250,7 @@ export interface PrepareDrawSpriteImageParamsBase {
     readonly drawingBufferWidth: number;
     readonly drawingBufferHeight: number;
     readonly pixelRatio: number;
-    readonly clipContext: Readonly<ClipContext> | null;
+    readonly clipContext: Readonly<ClipContext> | undefined;
 }
 export interface PrepareDrawSpriteImageParamsBefore<TTag> extends PrepareDrawSpriteImageParamsBase {
     readonly bucket: readonly Readonly<RenderTargetEntryLike<TTag>>[];
@@ -387,55 +404,34 @@ export interface SurfaceShaderInputs {
         readonly w: number;
     }>;
 }
+/**
+ * Easing function type.
+ */
+export type EasingFunction = (progress: number) => number;
 /**
  * Runtime state describing the active interpolation between two sprite locations.
  * Consumers reuse the same state across ticks to avoid re-allocations while animation is running.
- *
- * @property mode - Strategy used to resolve the target location (feedback or feedforward).
- * @property durationMs - Total time allocated for the interpolation in milliseconds.
- * @property easing - Resolved easing function applied to raw progress values.
- * @property startTimestamp - Epoch millisecond when the interpolation started, or -1 when uninitialized.
- * @property from - Origin sprite location cloned from the current render state.
- * @property to - Destination sprite location being interpolated towards.
- */
-export interface SpriteInterpolationState {
-    readonly mode: SpriteInterpolationMode;
-    readonly durationMs: number;
-    readonly easing: EasingFunction;
-    readonly easingPreset: SpriteEasingPresetName | null;
-    startTimestamp: number;
-    readonly from: SpriteLocation;
-    readonly to: SpriteLocation;
-}
-/**
- * Runtime state tracked for numeric interpolations.
- * @property {number} durationMs - Total duration of the interpolation in milliseconds.
- * @property {EasingFunction} easing - Easing function applied to progress samples.
- * @property {number} from - Start value used for interpolation.
- * @property {number} to - Adjusted target along the shortest rotation path.
- * @property {number} finalValue - Caller-requested final value (used once interpolation completes).
- * @property {number} startTimestamp - Timestamp when interpolation began, `-1` until evaluation starts.
  */
-export interface DegreeInterpolationState {
-    readonly durationMs: number;
-    readonly easing: EasingFunction;
-    readonly easingPreset: SpriteEasingPresetName | null;
-    readonly from: number;
-    readonly to: number;
-    readonly finalValue: number;
-    startTimestamp: number;
-}
-export interface DistanceInterpolationState {
+export interface SpriteInterpolationState<TValue> {
+    /** Strategy used to resolve the target location (feedback or feedforward). */
+    readonly mode: SpriteInterpolationMode;
+    /** Total time allocated for the interpolation in milliseconds. */
     readonly durationMs: number;
-    readonly easing: EasingFunction;
-    readonly easingPreset: SpriteEasingPresetName | null;
-    readonly from: number;
-    readonly to: number;
-    readonly finalValue: number;
+    /** Easing attributes */
+    readonly easingParam: SpriteEasingParam;
+    /** Resolved easing function applied to raw progress values. */
+    readonly easingFunc: EasingFunction;
+    /** Origin sprite location cloned from the current render state. */
+    readonly from: TValue;
+    /** Destination sprite location being interpolated towards.  */
+    readonly to: TValue;
+    /** */
+    readonly pathTarget?: TValue;
+    /** Epoch millisecond when the interpolation started, or -1 when uninitialized. */
     startTimestamp: number;
 }
 export interface DistanceInterpolationEvaluationParams {
-    readonly state: DistanceInterpolationState;
+    readonly state: SpriteInterpolationState<number>;
     readonly timestamp: number;
 }
 export interface DistanceInterpolationEvaluationResult {
@@ -444,7 +440,7 @@ export interface DistanceInterpolationEvaluationResult {
     readonly effectiveStartTimestamp: number;
 }
 export interface DegreeInterpolationEvaluationParams {
-    readonly state: DegreeInterpolationState;
+    readonly state: SpriteInterpolationState<number>;
     readonly timestamp: number;
 }
 export interface DegreeInterpolationEvaluationResult {
@@ -453,7 +449,7 @@ export interface DegreeInterpolationEvaluationResult {
     readonly effectiveStartTimestamp: number;
 }
 export interface SpriteInterpolationEvaluationParams {
-    readonly state: SpriteInterpolationState;
+    readonly state: SpriteInterpolationState<SpriteLocation>;
     readonly timestamp: number;
 }
 export interface SpriteInterpolationEvaluationResult {
@@ -461,10 +457,6 @@ export interface SpriteInterpolationEvaluationResult {
     readonly completed: boolean;
     readonly effectiveStartTimestamp: number;
 }
-/**
- * Alias for the interpolation state used internally by sprites.
- */
-export type InternalSpriteInterpolationState = SpriteInterpolationState;
 /**
  * Texture filtering parameters resolved from the public options structure.
  */
@@ -555,40 +547,37 @@ export type Canvas2DContext = CanvasRenderingContext2D | OffscreenCanvasRenderin
  * Canvas sources supported when rendering text glyphs.
  */
 export type Canvas2DSource = HTMLCanvasElement | OffscreenCanvas;
+/** Line definition resolved for rendering. */
+export interface ResolvedSpriteImageLineAttribute extends SpriteImageLineAttributeState {
+    readonly rgba: RgbaColor;
+}
 /**
  * Base attributes for an image that composes a sprite.
  */
-export interface InternalSpriteImageState {
+export interface InternalSpriteImageState extends SpriteImageState {
     subLayer: number;
     order: number;
     imageId: string;
     imageHandle: number;
     mode: SpriteMode;
-    opacity: MutableInterpolatedValues<number>;
+    opacity: MutableSpriteInterpolatedValues<number>;
+    lodOpacity: number;
     scale: number;
     anchor: Readonly<SpriteAnchor>;
+    border: ResolvedSpriteImageLineAttribute | undefined;
+    borderPixelWidth: number;
+    leaderLine: ResolvedSpriteImageLineAttribute | undefined;
+    leaderLinePixelWidth: number;
     offset: MutableSpriteImageInterpolatedOffset;
-    rotateDeg: MutableInterpolatedValues<number>;
+    rotateDeg: MutableSpriteInterpolatedValues<number>;
     rotationCommandDeg: number;
     displayedRotateDeg: number;
     autoRotation: boolean;
     autoRotationMinDistanceMeters: number;
     resolvedBaseRotateDeg: number;
-    originLocation?: Readonly<SpriteImageOriginLocation>;
+    originLocation: Readonly<SpriteImageOriginLocation> | undefined;
     originReferenceKey: SpriteOriginReferenceKey;
     originRenderTargetIndex: SpriteOriginReferenceIndex;
-    rotationInterpolationState: Readonly<DegreeInterpolationState> | null;
-    rotationInterpolationOptions: Readonly<SpriteInterpolationOptions> | null;
-    offsetDegInterpolationState: Readonly<DegreeInterpolationState> | null;
-    offsetMetersInterpolationState: Readonly<DistanceInterpolationState> | null;
-    opacityInterpolationState: Readonly<DistanceInterpolationState> | null;
-    opacityInterpolationOptions: Readonly<SpriteInterpolationOptions> | null;
-    opacityTargetValue: number;
-    lodLastCommandOpacity: number;
-    lastCommandRotateDeg: number;
-    lastCommandOffsetDeg: number;
-    lastCommandOffsetMeters: number;
-    lastCommandOpacity: number;
     interpolationDirty: boolean;
     surfaceShaderInputs?: Readonly<SurfaceShaderInputs>;
     hitTestCorners?: [
@@ -606,14 +595,13 @@ export interface InternalSpriteCurrentState<TTag> {
     handle: IdHandle;
     isEnabled: boolean;
     visibilityDistanceMeters?: number;
-    location: MutableInterpolatedValues<Readonly<SpriteLocation>>;
+    opacityMultiplier: number;
+    location: MutableSpriteInterpolatedValues<SpriteLocation>;
     images: Map<number, Map<number, InternalSpriteImageState>>;
     tag: TTag | null;
-    interpolationState: InternalSpriteInterpolationState | null;
-    pendingInterpolationOptions: SpriteInterpolationOptions | null;
-    lastCommandLocation: Readonly<SpriteLocation>;
     lastAutoRotationLocation: Readonly<SpriteLocation>;
     lastAutoRotationAngleDeg: number;
+    autoRotationInvalidated: boolean;
     interpolationDirty: boolean;
     cachedMercator: Readonly<SpriteMercatorCoordinate>;
     cachedMercatorLng: number;

package/dist/interpolation/degreeInterpolation.d.ts

@@ -1,35 +1,35 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.15.0
+ * version: 0.17.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
+ * git.commit.hash: 9fe9aa30db6602d13643e32c94af39ae2b26b082
  */
 
 import { SpriteInterpolationOptions } from '../types';
-import { DegreeInterpolationState, DegreeInterpolationEvaluationResult, InternalSpriteImageState } from '../internalTypes';
+import { DegreeInterpolationEvaluationResult, InternalSpriteImageState, MutableSpriteInterpolation, SpriteInterpolationState } from '../internalTypes';
 /**
  * Parameters required to construct a {@link DegreeInterpolationState}.
- * @property {number} currentValue - Current numeric value rendered on screen.
- * @property {number} targetValue - Desired value after interpolation completes.
- * @property {number | undefined} previousCommandValue - Prior commanded value used for feed-forward prediction.
- * @property {SpriteInterpolationOptions} options - Timing and easing configuration.
  */
 export interface CreateDegreeInterpolationStateParams {
+    /** Current numeric value rendered on screen. */
     currentValue: number;
+    /** Desired value after interpolation completes. */
     targetValue: number;
+    /** Prior commanded value used for feed-forward prediction. */
     previousCommandValue?: number;
+    /** Timing and easing configuration. */
     options: SpriteInterpolationOptions;
 }
 /**
  * Result returned by {@link createDegreeInterpolationState} containing state and a flag for activation.
- * @property {DegreeInterpolationState} state - Resolved state object.
- * @property {boolean} requiresInterpolation - Indicates whether the caller should animate or snap.
  */
 export interface CreateDegreeInterpolationStateResult {
-    readonly state: DegreeInterpolationState;
+    /** Resolved state object. */
+    readonly state: SpriteInterpolationState<number>;
+    /** Indicates whether the caller should animate or snap. */
     readonly requiresInterpolation: boolean;
 }
 /**
@@ -40,22 +40,22 @@ export interface CreateDegreeInterpolationStateResult {
 export declare const createDegreeInterpolationState: (params: CreateDegreeInterpolationStateParams) => CreateDegreeInterpolationStateResult;
 /**
  * Parameters describing interpolation evaluation state.
- * @property {DegreeInterpolationState} state - State generated via {@link createDegreeInterpolationState}.
- * @property {number} timestamp - Timestamp in milliseconds used to sample the interpolation curve.
  */
 export interface EvaluateDegreeInterpolationParams {
-    state: DegreeInterpolationState;
+    /** State generated via {@link createDegreeInterpolationState}. */
+    state: SpriteInterpolationState<number>;
+    /** Timestamp in milliseconds used to sample the interpolation curve. */
     timestamp: number;
 }
 /**
  * Result of evaluating a numeric interpolation at a specific timestamp.
- * @property {number} value - Current interpolated value (or final value after completion).
- * @property {boolean} completed - Indicates whether interpolation reached the end.
- * @property {number} effectiveStartTimestamp - Start timestamp applied during evaluation.
  */
 export interface EvaluateDegreeInterpolationResult {
+    /** Current interpolated value (or final value after completion). */
     readonly value: number;
+    /** Indicates whether interpolation reached the end. */
     readonly completed: boolean;
+    /** Start timestamp applied during evaluation. */
     readonly effectiveStartTimestamp: number;
 }
 /**
@@ -64,9 +64,8 @@ export interface EvaluateDegreeInterpolationResult {
  * @returns {EvaluateDegreeInterpolationResult} Current value, completion flag, and effective start time.
  */
 export declare const evaluateDegreeInterpolation: (params: EvaluateDegreeInterpolationParams) => EvaluateDegreeInterpolationResult;
-type DegreeInterpolationStateKey = 'rotationInterpolationState' | 'offsetDegInterpolationState';
 interface DegreeInterpolationChannelDescriptor {
-    readonly stateKey: DegreeInterpolationStateKey;
+    readonly resolveInterpolation: (image: InternalSpriteImageState) => MutableSpriteInterpolation<number>;
     readonly normalize?: (value: number) => number;
     readonly applyValue: (image: InternalSpriteImageState, value: number) => void;
     readonly applyFinalValue?: (image: InternalSpriteImageState, value: number) => void;
@@ -74,7 +73,7 @@ interface DegreeInterpolationChannelDescriptor {
 export interface DegreeInterpolationWorkItem {
     readonly descriptor: DegreeInterpolationChannelDescriptor;
     readonly image: InternalSpriteImageState;
-    readonly state: DegreeInterpolationState;
+    readonly state: SpriteInterpolationState<number>;
 }
 export declare const collectDegreeInterpolationWorkItems: (image: InternalSpriteImageState, workItems: DegreeInterpolationWorkItem[]) => void;
 export declare const applyDegreeInterpolationEvaluations: (workItems: readonly DegreeInterpolationWorkItem[], evaluations: readonly DegreeInterpolationEvaluationResult[], timestamp: number) => boolean;

package/dist/interpolation/distanceInterpolation.d.ts

@@ -1,15 +1,15 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.15.0
+ * version: 0.17.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
+ * git.commit.hash: 9fe9aa30db6602d13643e32c94af39ae2b26b082
  */
 
 import { SpriteInterpolationOptions } from '../types';
-import { DistanceInterpolationEvaluationParams, DistanceInterpolationEvaluationResult, DistanceInterpolationState, InternalSpriteImageState } from '../internalTypes';
+import { DistanceInterpolationEvaluationParams, DistanceInterpolationEvaluationResult, InternalSpriteImageState, MutableSpriteInterpolation, SpriteInterpolationState } from '../internalTypes';
 export interface CreateDistanceInterpolationStateParams {
     currentValue: number;
     targetValue: number;
@@ -17,14 +17,13 @@ export interface CreateDistanceInterpolationStateParams {
     options: SpriteInterpolationOptions;
 }
 export interface CreateDistanceInterpolationStateResult {
-    readonly state: DistanceInterpolationState;
+    readonly state: SpriteInterpolationState<number>;
     readonly requiresInterpolation: boolean;
 }
 export declare const createDistanceInterpolationState: (params: CreateDistanceInterpolationStateParams) => CreateDistanceInterpolationStateResult;
 export declare const evaluateDistanceInterpolation: (params: DistanceInterpolationEvaluationParams) => DistanceInterpolationEvaluationResult;
-type DistanceInterpolationStateKey = 'offsetMetersInterpolationState' | 'opacityInterpolationState';
 interface DistanceInterpolationChannelDescriptor {
-    readonly stateKey: DistanceInterpolationStateKey;
+    readonly resolveInterpolation: (image: InternalSpriteImageState) => MutableSpriteInterpolation<number>;
     readonly normalize?: (value: number) => number;
     readonly applyValue: (image: InternalSpriteImageState, value: number) => void;
     readonly applyFinalValue?: (image: InternalSpriteImageState, value: number) => void;
@@ -35,7 +34,7 @@ export type DistanceInterpolationChannelName = keyof DistanceInterpolationChanne
 export interface DistanceInterpolationWorkItem {
     readonly descriptor: DistanceInterpolationChannelDescriptorMap[DistanceInterpolationChannelName];
     readonly image: InternalSpriteImageState;
-    readonly state: DistanceInterpolationState;
+    readonly state: SpriteInterpolationState<number>;
 }
 export interface CollectDistanceInterpolationWorkItemOptions {
     readonly includeOffsetMeters?: boolean;

package/dist/interpolation/easing.d.ts

@@ -1,24 +1,26 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.15.0
+ * version: 0.17.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
+ * git.commit.hash: 9fe9aa30db6602d13643e32c94af39ae2b26b082
  */
 
-import { EasingFunction, SpriteEasingPresetName, SpriteInterpolationEasing } from '../types';
+import { EasingFunction } from '../internalTypes';
+import { SpriteEasingParam } from '../types';
 /**
  * Linear interpolation that clamps the value to the [0, 1] range.
  */
 export declare const linearEasing: EasingFunction;
 export interface ResolvedEasing {
-    readonly easing: EasingFunction;
-    readonly preset: SpriteEasingPresetName | null;
+    readonly param: SpriteEasingParam;
+    readonly func: EasingFunction;
 }
 /**
- * Returns the provided easing function or falls back to linear interpolation.
- * When a preset name is supplied the resolved preset identifier is preserved for downstream consumers.
+ * Resolves an easing definition into its implementation, defaulting to linear when unspecified or unknown.
+ * @param easing - Easing parameter.
+ * @return Resolved easing parameters.
  */
-export declare const resolveEasing: (easing?: SpriteInterpolationEasing) => ResolvedEasing;
+export declare const resolveEasing: (easing?: SpriteEasingParam) => ResolvedEasing;

package/dist/interpolation/interpolation.d.ts

@@ -1,37 +1,35 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.15.0
+ * version: 0.17.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
+ * git.commit.hash: 9fe9aa30db6602d13643e32c94af39ae2b26b082
  */
 
 import { SpriteInterpolationOptions, SpriteLocation } from '../types';
-import { SpriteInterpolationState, SpriteInterpolationEvaluationParams, SpriteInterpolationEvaluationResult } from '../internalTypes';
+import { SpriteInterpolationEvaluationParams, SpriteInterpolationEvaluationResult, SpriteInterpolationState } from '../internalTypes';
 /**
  * Parameters required to create a fresh interpolation state for the next animation segment.
- *
- * @property currentLocation - Sprite location currently rendered on screen.
- * @property lastCommandLocation - Previously commanded target, used for feedforward extrapolation.
- * @property nextCommandLocation - Upcoming commanded target that the sprite should reach.
- * @property options - Raw interpolation options supplied by the caller.
  */
 export interface CreateInterpolationStateParams {
+    /** Sprite location currently rendered on screen. */
     currentLocation: SpriteLocation;
+    /** Previously commanded target, used for feedforward extrapolation. */
     lastCommandLocation?: SpriteLocation;
+    /** Upcoming commanded target that the sprite should reach. */
     nextCommandLocation: SpriteLocation;
+    /** Raw interpolation options supplied by the caller. */
     options: SpriteInterpolationOptions;
 }
 /**
  * Result of preparing interpolation state, including a flag denoting whether any lerp is needed.
- *
- * @property state - Prepared interpolation state ready for evaluation.
- * @property requiresInterpolation - Indicates whether lerping is needed or an immediate snap is sufficient.
  */
 export interface CreateInterpolationStateResult {
-    readonly state: SpriteInterpolationState;
+    /** Prepared interpolation state ready for evaluation. */
+    readonly state: SpriteInterpolationState<SpriteLocation>;
+    /** Indicates whether lerping is needed or an immediate snap is sufficient. */
     readonly requiresInterpolation: boolean;
 }
 /**

package/dist/interpolation/interpolationChannels.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.15.0
+ * version: 0.17.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
+ * git.commit.hash: 9fe9aa30db6602d13643e32c94af39ae2b26b082
  */
 
 import { SpriteInterpolationOptions, SpriteImageOffset } from '../types';
@@ -26,7 +26,8 @@ export declare const clearOffsetMetersInterpolation: (image: InternalSpriteImage
  * Clears any running opacity interpolation.
  */
 export declare const clearOpacityInterpolation: (image: InternalSpriteImageState) => void;
-export declare const applyOpacityUpdate: (image: InternalSpriteImageState, nextOpacity: number, interpolationOptions?: SpriteInterpolationOptions | null) => void;
+export declare const applyOpacityUpdate: (image: InternalSpriteImageState, nextOpacity: number, interpolationOptions?: SpriteInterpolationOptions | null, spriteOpacityMultiplier?: number) => void;
+export declare const applyResolvedOpacityTarget: (image: InternalSpriteImageState, resolvedTarget: number, interpolationOptions?: SpriteInterpolationOptions | null) => void;
 export type ImageInterpolationStepperId = 'rotation' | 'offsetDeg' | 'offsetMeters' | 'opacity';
 /**
  * Executes all interpolation steppers for an image and reports whether any remain active.

package/dist/interpolation/rotationInterpolation.d.ts

@@ -1,37 +1,37 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.15.0
+ * version: 0.17.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
+ * git.commit.hash: 9fe9aa30db6602d13643e32c94af39ae2b26b082
  */
 
 import { SpriteInterpolationOptions } from '../types';
-import { DegreeInterpolationState } from '../internalTypes';
+import { SpriteInterpolationState } from '../internalTypes';
 export { normalizeAngleDeg } from '../utils/math';
 /**
  * Parameters describing the rotation update request.
- * @property {number} currentAngleDeg - Current angle already applied to the sprite in degrees.
- * @property {number} targetAngleDeg - Desired angle in degrees that should be reached.
- * @property {number | undefined} previousCommandAngleDeg - Previous commanded angle for feed-forward prediction.
- * @property {SpriteInterpolationOptions | null} [options] - Optional interpolation configuration.
  */
 export interface ResolveRotationTargetParams {
+    /** Current angle already applied to the sprite in degrees. */
     currentAngleDeg: number;
+    /** Desired angle in degrees that should be reached. */
     targetAngleDeg: number;
+    /** Previous commanded angle for feed-forward prediction. */
     previousCommandAngleDeg?: number;
+    /** Optional interpolation configuration. */
     options?: SpriteInterpolationOptions | null;
 }
 /**
  * Result produced by {@link resolveRotationTarget} when determining the next rotation step.
- * @property {number} nextAngleDeg - Angle that should be applied immediately.
- * @property {DegreeInterpolationState | null} interpolationState - Optional state for animating toward the target.
  */
 export interface ResolveRotationTargetResult {
+    /** Angle that should be applied immediately. */
     readonly nextAngleDeg: number;
-    readonly interpolationState: DegreeInterpolationState | null;
+    /** Optional state for animating toward the target. */
+    readonly interpolationState: SpriteInterpolationState<number> | null;
 }
 /**
  * Determines whether a rotation change requires interpolation and, if so, produces the state to drive it.