maplibre-gl-layers 0.16.0 → 0.18.0

package/dist/internalTypes.d.ts

@@ -1,17 +1,30 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.16.0
+ * version: 0.18.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ * git.commit.hash: ca8392c8aa3aae7e0e4e3c871e195d49b125e481
  */
 
-import { SpriteMode, SpriteAnchor, SpriteInterpolationOptions, SpriteImageOriginLocation, SpriteLocation, SpriteTextGlyphHorizontalAlign, SpriteTextureMagFilter, SpriteTextureMinFilter, SpriteInterpolationMode, SpriteScreenPoint, SpritePoint, SpriteEasing, SpriteImageLineAttributeState, SpriteImageState, SpriteInterpolatedValues, SpriteImageInterpolatedOffset } from './types';
-import { EasingFunction } from './interpolation/easing';
+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';
-import { RgbaColor } from './utils/color';
+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.
  */
@@ -159,33 +172,30 @@ 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 SpriteInterpolatedValues}, used internally so SpriteLayer
  * can reuse object references while still exposing readonly snapshots publicly.
  */
-export interface MutableSpriteInterpolatedValues<T> extends SpriteInterpolatedValues<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 extends SpriteImageInterpolatedOffset {
     offsetMeters: MutableSpriteInterpolatedValues<number>;
     offsetDeg: MutableSpriteInterpolatedValues<number>;
 }
-export interface Releasable {
-    readonly release: () => void;
-}
 /**
  * Mimimum abstraction that exposes projection-related helpers.
  */
@@ -394,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: SpriteEasing;
-    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: SpriteEasing;
-    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: SpriteEasing;
-    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 {
@@ -451,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 {
@@ -460,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 {
@@ -468,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.
  */
@@ -576,6 +561,7 @@ export interface InternalSpriteImageState extends SpriteImageState {
     imageHandle: number;
     mode: SpriteMode;
     opacity: MutableSpriteInterpolatedValues<number>;
+    lodOpacity: number;
     scale: number;
     anchor: Readonly<SpriteAnchor>;
     border: ResolvedSpriteImageLineAttribute | undefined;
@@ -592,18 +578,6 @@ export interface InternalSpriteImageState extends SpriteImageState {
     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?: [
@@ -621,14 +595,13 @@ export interface InternalSpriteCurrentState<TTag> {
     handle: IdHandle;
     isEnabled: boolean;
     visibilityDistanceMeters?: number;
-    location: MutableSpriteInterpolatedValues<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.16.0
+ * version: 0.18.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ * git.commit.hash: ca8392c8aa3aae7e0e4e3c871e195d49b125e481
  */
 
 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.16.0
+ * version: 0.18.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ * git.commit.hash: ca8392c8aa3aae7e0e4e3c871e195d49b125e481
  */
 
 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.16.0
+ * version: 0.18.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ * git.commit.hash: ca8392c8aa3aae7e0e4e3c871e195d49b125e481
  */
 
-import { SpriteEasing } from '../types';
-export type EasingFunction = (progress: number) => number;
+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: SpriteEasing;
+    readonly param: SpriteEasingParam;
+    readonly func: EasingFunction;
 }
 /**
  * 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?: SpriteEasing) => ResolvedEasing;
+export declare const resolveEasing: (easing?: SpriteEasingParam) => ResolvedEasing;

package/dist/interpolation/interpolation.d.ts

@@ -1,37 +1,35 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.16.0
+ * version: 0.18.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ * git.commit.hash: ca8392c8aa3aae7e0e4e3c871e195d49b125e481
  */
 
 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.16.0
+ * version: 0.18.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ * git.commit.hash: ca8392c8aa3aae7e0e4e3c871e195d49b125e481
  */
 
 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.16.0
+ * version: 0.18.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ * git.commit.hash: ca8392c8aa3aae7e0e4e3c871e195d49b125e481
  */
 
 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.