maplibre-gl-layers 0.19.0 → 1.1.0

package/dist/utils/color.d.ts

@@ -1,20 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.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: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { RgbaColor } from '../internalTypes';
-/**
- * Parses a CSS color string into normalized RGBA values.
- * Falls back to the supplied default when parsing fails.
- *
- * @param color CSS color string to parse.
- * @param fallback Fallback value used when parsing fails.
- * @returns Parsed RGBA tuple.
- */
-export declare const parseCssColorToRgba: (color: string | undefined, fallback: RgbaColor) => RgbaColor;

package/dist/utils/image.d.ts

@@ -1,32 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.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: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { SpriteImageRegisterOptions } from '../types';
-export type SvgSizeResolutionErrorCode = 'size-missing' | 'viewbox-disabled' | 'invalid-dimensions';
-export declare class SvgSizeResolutionError extends Error implements Error {
-    readonly code: SvgSizeResolutionErrorCode;
-    constructor(message: string, code: SvgSizeResolutionErrorCode);
-}
-/**
- * Helper that read an ImageBitmap from a blob.
- * @param blob Target blob.
- * @param options Optional reading options.
- * @returns Promise resolving to the ImageBitmap.
- * @remarks This function helps reading SVG with better manner.
- */
-export declare const readImageBitmap: (blob: Blob, options?: SpriteImageRegisterOptions) => Promise<ImageBitmap>;
-/**
- * Helper that loads an ImageBitmap from a URL.
- * @param url Target image URL.
- * @param options Optional loading options.
- * @returns Promise resolving to the ImageBitmap.
- * @remarks This function helps loading SVG with better manner.
- */
-export declare const loadImageBitmap: (url: string, options?: SpriteImageRegisterOptions) => Promise<ImageBitmap>;

package/dist/utils/looseQuadTree.d.ts

@@ -1,34 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.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: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-export interface Rect {
-    readonly x0: number;
-    readonly y0: number;
-    readonly x1: number;
-    readonly y1: number;
-}
-export interface Item<TState> extends Rect {
-    readonly state: TState;
-}
-export interface LooseQuadTree<TState> {
-    readonly size: number;
-    readonly add: (item: Item<TState>) => void;
-    readonly remove: (x0: number, y0: number, x1: number, y1: number, item: Item<TState>) => boolean;
-    readonly update: (oldX0: number, oldY0: number, oldX1: number, oldY1: number, newX0: number, newY0: number, newX1: number, newY1: number, item: Item<TState>) => boolean;
-    readonly lookup: (x0: number, y0: number, x1: number, y1: number) => Item<TState>[];
-    readonly clear: () => void;
-}
-export interface LooseQuadTreeOptions {
-    readonly bounds: Rect;
-    readonly maxItemsPerNode?: number;
-    readonly maxDepth?: number;
-    readonly looseness?: number;
-}
-export declare const createLooseQuadTree: <TState>(options: LooseQuadTreeOptions) => LooseQuadTree<TState>;

package/dist/utils/math.d.ts

@@ -1,451 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.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: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { SpriteAnchor, SpriteLocation, SpritePoint, SpriteScalingOptions, SpriteScreenPoint } from '../types';
-import { InternalSpriteCurrentState, MatrixInput, ProjectionHost, SpriteMercatorCoordinate } from '../internalTypes';
-export type OffsetInput = {
-    offsetMeters?: number;
-    offsetDeg?: number;
-} | undefined;
-/**
- * Produces a deep copy so later updates do not mutate the original object.
- */
-export declare const cloneSpriteLocation: (location: SpriteLocation) => SpriteLocation;
-/**
- * Linearly interpolates longitude, latitude, and optionally altitude.
- * The `ratio` may fall outside [0, 1]; callers are responsible for clamping if needed.
- */
-export declare const lerpSpriteLocation: (from: SpriteLocation, to: SpriteLocation, ratio: number) => SpriteLocation;
-/**
- * Compares two locations. Treats altitude as equal when either side is undefined.
- */
-export declare const spriteLocationsEqual: (a: SpriteLocation, b: SpriteLocation) => boolean;
-export declare const calculateCartesianDistanceMeters: (a: Readonly<SpriteLocation>, b: Readonly<SpriteLocation>) => number;
-/**
- * Normalizes an angle in degrees to the [0, 360) range.
- */
-export declare const normalizeAngleDeg: (angle: number) => number;
-/**
- * Multiplies a 4x4 matrix with a 4-component vector using row-major indexing.
- * @param {MatrixInput} matrix - Matrix to multiply.
- * @param {number} x - X component of the vector.
- * @param {number} y - Y component of the vector.
- * @param {number} z - Z component of the vector.
- * @param {number} w - W component of the vector.
- * @returns {[number, number, number, number]} Resulting homogeneous coordinate.
- */
-export declare const multiplyMatrixAndVector: (matrix: MatrixInput, x: number, y: number, z: number, w: number) => [number, number, number, number];
-/**
- * Structure holding resolved sprite scaling options.
- */
-export interface ResolvedSpriteScalingOptions {
-    /** Effective number of meters represented by each rendered pixel. */
-    metersPerPixel: number;
-    /** Distance at or below which sprites stop growing further. */
-    minScaleDistanceMeters: number;
-    /** Distance at or above which sprites stop shrinking further. */
-    maxScaleDistanceMeters: number;
-}
-/**
- * Fills missing {@link SpriteScalingOptions} values with defaults so downstream math can assume a complete object.
- * @param options Optional scaling configuration from the caller.
- * @returns {ResolvedSpriteScalingOptions} Resolved scaling settings covering every field.
- */
-export declare const resolveScalingOptions: (options?: SpriteScalingOptions) => ResolvedSpriteScalingOptions;
-/**
- * Computes a scale factor based on camera-to-sprite distance.
- * @param {number} distanceMeters - Calculated distance from camera to sprite.
- * @param {ResolvedSpriteScalingOptions} scaling - Resolved scaling options.
- * @returns {number} Scale multiplier that clamps near/far distances to maintain consistent sizing.
- */
-export declare const calculateDistanceScaleFactor: (distanceMeters: number, scaling: ResolvedSpriteScalingOptions) => number;
-/**
- * Calculates meters per pixel at the given latitude.
- * Uses Web Mercator scale and applies the latitude-based cosine correction.
- * @param {number} zoom - Map zoom level used to determine the Mercator scale.
- * @param {number} latitude - Latitude in degrees where the meters-per-pixel value is resolved.
- * @returns {number} Distance in meters represented by a single pixel at the provided latitude.
- */
-export declare const calculateMetersPerPixelAtLatitude: (zoom: number, latitude: number) => number;
-/**
- * Checks whether a value is finite and not `NaN`.
- * @param {number} value - Value to validate.
- * @returns {boolean} `true` when the number is both finite and not `NaN`.
- */
-export declare const isFiniteNumber: (value: number) => boolean;
-/**
- * Calculates the distance and bearing between two points in meters.
- * @param {SpriteLocation} from - Starting point expressed in longitude/latitude (degrees) and optional altitude.
- * @param {SpriteLocation} to - Destination point expressed in longitude/latitude (degrees) and optional altitude.
- * @returns {{ distanceMeters: number; bearingDeg: number }} Distance in meters and bearing clockwise from north.
- */
-export declare const calculateDistanceAndBearingMeters: (from: SpriteLocation, to: SpriteLocation) => {
-    distanceMeters: number;
-    bearingDeg: number;
-};
-/**
- * Calculates billboard image dimensions in pixels.
- * @param {number | undefined} imageWidth - Source bitmap width in pixels.
- * @param {number | undefined} imageHeight - Source bitmap height in pixels.
- * @param {number} baseMetersPerPixel - Base scale derived from map zoom and latitude.
- * @param {number} imageScale - User-provided scale multiplier.
- * @param {number} distanceScaleFactor - Distance-dependent scale multiplier.
- * @param {number} effectivePixelsPerMeter - Conversion between world meters and screen pixels.
- * @returns {{ width: number; height: number; scaleAdjustment: number }} Pixel dimensions alongside the scale factor (always 1 without clamping).
- */
-export declare const calculateBillboardPixelDimensions: (imageWidth: number | undefined, imageHeight: number | undefined, baseMetersPerPixel: number, imageScale: number, distanceScaleFactor: number, effectivePixelsPerMeter: number) => {
-    width: number;
-    height: number;
-    scaleAdjustment: number;
-};
-/**
- * Computes the billboard offset in screen-space pixels.
- * @param {OffsetInput} offset - Offset configuration describing length (meters) and heading (degrees).
- * @param {number} imageScale - User-provided scale multiplier applied to the offset distance.
- * @param {number} distanceScaleFactor - Distance-dependent scale multiplier.
- * @param {number} effectivePixelsPerMeter - Conversion factor from meters to pixels.
- * @param {number} [sizeScaleAdjustment=1] - Additional scale factor applied when sprite size is clamped.
- * @returns {SpriteScreenPoint} Screen-space offset relative to the billboard center.
- */
-export declare const calculateBillboardOffsetPixels: (offset: OffsetInput, imageScale: number, distanceScaleFactor: number, effectivePixelsPerMeter: number, sizeScaleAdjustment?: number) => SpriteScreenPoint;
-/**
- * Computes the screen-space shift caused by anchor rotation for billboards.
- * @param {number} halfWidth - Half of the sprite width in pixels.
- * @param {number} halfHeight - Half of the sprite height in pixels.
- * @param {SpriteAnchor | undefined} anchor - Anchor definition normalized to [-1, 1] range.
- * @param {number} totalRotateDeg - Rotation applied to the sprite, combining user and bearing rotations.
- * @returns {SpritePoint} Pixel delta required to bring the anchor back to the requested origin.
- */
-export declare const calculateBillboardAnchorShiftPixels: (halfWidth: number, halfHeight: number, anchor: SpriteAnchor | undefined, totalRotateDeg: number) => SpritePoint;
-/**
- * Calculates surface image dimensions in world meters.
- * @param {number | undefined} imageWidth - Source bitmap width in pixels.
- * @param {number | undefined} imageHeight - Source bitmap height in pixels.
- * @param {number} baseMetersPerPixel - World meters represented by a pixel at the current zoom.
- * @param {number} imageScale - User-provided scale multiplier.
- * @param {number} distanceScaleFactor - Distance-dependent scale multiplier.
- * @returns {{ width: number; height: number; scaleAdjustment: number }} World dimensions in meters and the applied clamp scale factor (always 1 without clamping).
- */
-export declare const calculateSurfaceWorldDimensions: (imageWidth: number | undefined, imageHeight: number | undefined, baseMetersPerPixel: number, imageScale: number, distanceScaleFactor: number) => {
-    width: number;
-    height: number;
-    scaleAdjustment: number;
-};
-/**
- * Computes east/north shifts from anchor rotation on surface images.
- * @param {number} halfWidthMeters - Half of the world-space width.
- * @param {number} halfHeightMeters - Half of the world-space height.
- * @param {SpriteAnchor | undefined} anchor - Anchor definition normalized to [-1, 1] range.
- * @param {number} totalRotateDeg - Rotation angle applied to the surface.
- * @returns {SurfaceCorner} Displacement in meters required to apply the anchor.
- */
-export declare const calculateSurfaceAnchorShiftMeters: (halfWidthMeters: number, halfHeightMeters: number, anchor: SpriteAnchor | undefined, totalRotateDeg: number) => SurfaceCorner;
-/**
- * Calculates surface image offsets in meters.
- * @param {OffsetInput} offset - Offset configuration for the surface sprite.
- * @param {number} imageScale - User-provided scale multiplier applied to the offset distance.
- * @param {number} distanceScaleFactor - Distance-dependent scale multiplier.
- * @param {number} [sizeScaleAdjustment=1] - Additional scale factor applied when sprite size is clamped.
- * @returns {SurfaceCorner} Offset vector in meters.
- */
-export declare const calculateSurfaceOffsetMeters: (offset: OffsetInput, imageScale: number, distanceScaleFactor: number, sizeScaleAdjustment?: number) => SurfaceCorner;
-/**
- * Adds east/north distances (meters) to a longitude/latitude pair.
- * @param {number} location - Base location in degrees.
- * @param {number} east - Eastward displacement in meters.
- * @param {number} north - Northward displacement in meters.
- * @returns {SpriteLocation} New geographic position after applying the displacement.
- */
-export declare const applySurfaceDisplacement: (location: SpriteLocation, corner: SurfaceCorner) => SpriteLocation;
-/**
- * Converts screen coordinates to clip space.
- * @param {number} point - Screen-space coordinate in CSS pixels.
- * @param {number} drawingBufferWidth - WebGL drawing buffer width in device pixels.
- * @param {number} drawingBufferHeight - WebGL drawing buffer height in device pixels.
- * @param {number} pixelRatio - Device pixel ratio used to scale CSS pixels to device pixels.
- * @returns {[number, number]} Clip-space coordinates in the range [-1, 1].
- */
-export declare const screenToClip: (point: SpriteScreenPoint, drawingBufferWidth: number, drawingBufferHeight: number, pixelRatio: number) => [number, number];
-/**
- * Converts homogeneous clip coordinates back into screen-space pixels.
- * @param {[number, number, number, number]} clipPosition - Homogeneous clip coordinates.
- * @param {number} drawingBufferWidth - WebGL drawing buffer width in device pixels.
- * @param {number} drawingBufferHeight - WebGL drawing buffer height in device pixels.
- * @param {number} pixelRatio - Device pixel ratio relating CSS pixels to device pixels.
- * @returns {SpriteScreenPoint | null} Screen-space coordinates or `null` when invalid.
- */
-export declare const clipToScreen: (clipPosition: readonly [number, number, number, number], drawingBufferWidth: number, drawingBufferHeight: number, pixelRatio: number) => SpriteScreenPoint | null;
-/**
- * Calculates the conversion factor between meters and pixels taking perspective into account.
- * @param {number} metersPerPixelAtLatitude - Meters covered by a single pixel at the sprite latitude.
- * @param {number} perspectiveRatio - Additional scale factor introduced by perspective settings.
- * @returns {number} Effective pixels per meter along the camera ray.
- */
-export declare const calculateEffectivePixelsPerMeter: (metersPerPixelAtLatitude: number, perspectiveRatio: number) => number;
-/**
- * Projects a geographic coordinate and elevation into homogeneous clip space.
- * @typedef ProjectToClipSpaceFn
- * @param {number} location - Location in degrees.
- * @returns {[number, number, number, number] | undefined} Homogeneous clip coordinates or `undefined` when outside the view.
- */
-export type ProjectToClipSpaceFn = (location: Readonly<SpriteLocation>) => [number, number, number, number] | undefined;
-/**
- * Unprojects a screen-space point back to longitude/latitude.
- * @typedef UnprojectPointFn
- * @param {SpriteScreenPoint} point - Screen-space coordinates in pixels.
- * @returns {SpriteLocation | undefined} Geographic location or `undefined` when unprojection fails.
- */
-export type UnprojectPointFn = (point: Readonly<SpriteScreenPoint>) => SpriteLocation | undefined;
-/**
- * Resolves a depth key for billboards by sampling the clip-space Z at the sprite center.
- * @param {SpriteScreenPoint} center - Screen-space center of the billboard in pixels.
- * @param {SpriteLocation} spriteLocation - Geographic location including optional altitude.
- * @param {UnprojectPointFn} unproject - Function for converting screen coordinates to geographic coordinates.
- * @param {ProjectToClipSpaceFn} projectToClipSpace - Function that projects a geographic coordinate to clip space.
- * @returns {number | undefined} Negative normalized device coordinate Z used for depth sorting, or `undefined` when unavailable.
- */
-export declare const calculateBillboardDepthKey: (center: Readonly<SpriteScreenPoint>, unproject: UnprojectPointFn, projectToClipSpace: ProjectToClipSpaceFn) => number | undefined;
-/**
- * Signature for surface depth bias callbacks that tweak clip-space Z/W.
- * @typedef SurfaceDepthBiasFn
- * @param {{ index: number; clipZ: number; clipW: number }} params - Geometry index and unmodified clip coordinates.
- * @returns {{ clipZ: number; clipW: number }} Adjusted clip coordinates used for depth evaluation.
- */
-export type SurfaceDepthBiasFn = (params: {
-    index: number;
-    clipZ: number;
-    clipW: number;
-}) => {
-    clipZ: number;
-    clipW: number;
-};
-/**
- * Computes a depth key for surface quads by projecting each corner and tracking the deepest point.
- * @param {SpriteLocation} baseLngLat - Base longitude/latitude of the quad center.
- * @param {readonly SurfaceCorner[]} displacements - Corner offsets in meters from the center.
- * @param {ProjectToClipSpaceFn} projectToClipSpace - Projection function used to reach clip space.
- * @param {{ readonly indices?: readonly number[]; readonly biasFn?: SurfaceDepthBiasFn }} [options] - Optional overrides.
- * @returns {number | undefined} Depth key suitable for sorting, or `undefined` when any corner cannot be projected.
- */
-export declare const calculateSurfaceDepthKey: (baseLngLat: Readonly<SpriteLocation>, displacements: readonly SurfaceCorner[], projectToClipSpace: ProjectToClipSpaceFn, options?: {
-    readonly indices?: readonly number[];
-    readonly biasFn?: SurfaceDepthBiasFn;
-}) => number | undefined;
-/**
- * Projects a longitude/latitude pair to screen-space pixels.
- * @typedef ProjectLngLatFn
- * @param {SpriteLocation} lngLat - Geographic coordinate to project.
- * @returns {SpriteScreenPoint | undefined} Screen coordinates or `undefined` when projection fails.
- */
-export type ProjectLngLatFn = (lngLat: Readonly<SpriteLocation>) => SpriteScreenPoint | undefined;
-/**
- * Parameters required to resolve a billboard center position.
- */
-export interface BillboardCenterParams {
-    /** Reference screen-space position (usually anchor point). */
-    base: Readonly<SpriteScreenPoint>;
-    /** Source bitmap width in pixels. */
-    imageWidth?: number;
-    /** Source bitmap height in pixels. */
-    imageHeight?: number;
-    /** Meters represented by a pixel at the sprite latitude. */
-    baseMetersPerPixel: number;
-    /** User-provided scaling multiplier. */
-    imageScale: number;
-    /** Distance-dependent scale multiplier. */
-    distanceScaleFactor: number;
-    /** Pixels per meter after perspective adjustments. */
-    effectivePixelsPerMeter: number;
-    /** Aggregate rotation applied to the sprite in degrees. */
-    totalRotateDeg: number;
-    /** Anchor definition normalized between -1 and 1. */
-    anchor?: Readonly<SpriteAnchor>;
-    /** Offset definition applied in meters/deg. */
-    offset?: OffsetInput;
-}
-/**
- * Resolved properties describing the billboard center and derived dimensions.
- */
-export interface BillboardCenterResult {
-    /** Screen-space coordinate after offset adjustments. */
-    center: SpriteScreenPoint;
-    /** Half of the pixel width. */
-    halfWidth: number;
-    /** Half of the pixel height. */
-    halfHeight: number;
-    /** Full pixel width after scaling. */
-    pixelWidth: number;
-    /** Full pixel height after scaling. */
-    pixelHeight: number;
-    /** Pixel delta caused by anchor rotation. */
-    anchorShift: SpritePoint;
-    /** Pixel delta caused by radial offset. */
-    offsetShift: SpritePoint;
-    /** Scaling adjustment applied during pixel dimension calculation. */
-    scaleAdjustment: number;
-}
-/**
- * Calculates the final billboard center position, applying scaling, anchor, and offset adjustments.
- * @param {BillboardCenterParams} params - Inputs describing sprite geometry and scaling context.
- * @returns {BillboardCenterResult} Computed center position and derived metrics for rendering.
- */
-export declare const calculateBillboardCenterPosition: (params: BillboardCenterParams) => BillboardCenterResult;
-/**
- * Parameters controlling how billboard corners are computed in screen space.
- */
-export interface BillboardCornerParams {
-    /** Screen-space coordinate for the billboard center after offsets. */
-    center: Readonly<SpriteScreenPoint>;
-    /** Half of the billboard width in pixels. */
-    halfWidth: number;
-    /** Half of the billboard height in pixels. */
-    halfHeight: number;
-    /** Optional anchor definition normalized between -1 and 1. */
-    anchor?: Readonly<SpriteAnchor>;
-    /** Total rotation applied to the billboard in degrees. */
-    totalRotateDeg: number;
-}
-/**
- * Screen-space coordinates combined with UV data for a quad corner.
- */
-export interface QuadCorner extends SpriteScreenPoint {
-    /** Texture u coordinate. */
-    readonly u: number;
-    /** Texture v coordinate. */
-    readonly v: number;
-}
-/**
- * Produces the rotated, anchor-adjusted screen-space positions for each billboard corner.
- * @param {BillboardCornerParams} params - Inputs describing the billboard geometry.
- * @returns {QuadCorner[]} Array containing screen- and texture-space information per corner.
- */
-export declare const calculateBillboardCornerScreenPositions: (params: BillboardCornerParams) => QuadCorner[];
-export interface SurfaceShaderModelParams {
-    baseLngLat: Readonly<SpriteLocation>;
-    worldWidthMeters: number;
-    worldHeightMeters: number;
-    anchor: Readonly<SpriteAnchor>;
-    totalRotateDeg: number;
-    offsetMeters: Readonly<SurfaceCorner>;
-}
-export type SurfaceShaderCornerModel = SurfaceCorner & SpriteLocation;
-export declare const computeSurfaceCornerShaderModel: (params: SurfaceShaderModelParams) => SurfaceShaderCornerModel[];
-/**
- * Parameters for projecting a surface sprite's center into screen space.
- */
-export interface SurfaceCenterParams {
-    /** Base geographic location of the sprite. */
-    baseLngLat: Readonly<SpriteLocation>;
-    /** Source bitmap width in pixels. */
-    imageWidth?: number;
-    /** Source bitmap height in pixels. */
-    imageHeight?: number;
-    /** Base meters per pixel at the sprite latitude. */
-    baseMetersPerPixel: number;
-    /** User-provided scaling multiplier. */
-    imageScale: number;
-    /** Distance-dependent scale multiplier. */
-    distanceScaleFactor: number;
-    /** Rotation applied to the sprite in degrees. */
-    totalRotateDeg: number;
-    /** Anchor definition normalized between -1 and 1. */
-    anchor?: Readonly<SpriteAnchor>;
-    /** Offset definition applied in meters/deg. */
-    offset?: OffsetInput;
-    /** Projection function mapping longitude/latitude to screen space. */
-    project?: ProjectLngLatFn;
-    /** Projection into clip space when available. */
-    projectToClipSpace?: ProjectToClipSpaceFn;
-    /** WebGL drawing buffer width in device pixels. */
-    drawingBufferWidth?: number;
-    /** WebGL drawing buffer height in device pixels. */
-    drawingBufferHeight?: number;
-    /** Device pixel ratio relating CSS pixels to device pixels. */
-    pixelRatio?: number;
-    /** When true, also computes the anchorless center. */
-    resolveAnchorless?: boolean;
-}
-/**
- * Output describing the resolved surface center and displacement details.
- */
-export interface SurfaceCenterResult {
-    /** Projected screen coordinates or `undefined` when projection fails. */
-    center: Readonly<SpriteScreenPoint> | undefined;
-    /** Sprite dimensions in world meters. */
-    worldDimensions: Readonly<{
-        width: number;
-        height: number;
-        scaleAdjustment: number;
-    }>;
-    /** Combined anchor and offset displacement in meters. */
-    totalDisplacement: Readonly<SurfaceCorner>;
-    /** Geographic coordinates after applying displacement. */
-    displacedLngLat: Readonly<SpriteLocation>;
-    /** Anchorless screen coordinates when requested. */
-    anchorlessCenter?: Readonly<SpriteScreenPoint> | null;
-    /** Offset-only displacement when requested. */
-    anchorlessDisplacement?: Readonly<SurfaceCorner>;
-    /** Anchorless geographic coordinate when requested. */
-    anchorlessLngLat?: Readonly<SpriteLocation>;
-}
-/**
- * Calculates the projected center of a surface sprite and derives related world-space displacements.
- * @param {SurfaceCenterParams} params - Inputs describing the sprite geometry and projection context.
- * @returns {SurfaceCenterResult} Result containing projection output and displacement metadata.
- */
-export declare const calculateSurfaceCenterPosition: (params: SurfaceCenterParams) => SurfaceCenterResult;
-/**
- * Parameters describing how to compute each surface corner displacement.
- */
-export interface SurfaceCornerParams {
-    /** Width of the sprite footprint in meters. */
-    worldWidthMeters: number;
-    /** Height of the sprite footprint in meters. */
-    worldHeightMeters: number;
-    /** Anchor definition normalized between -1 and 1. */
-    anchor: Readonly<SpriteAnchor>;
-    /** Rotation applied to the surface in degrees. */
-    totalRotateDeg: number;
-    /** Additional displacement applied uniformly to all corners. */
-    offsetMeters: Readonly<SurfaceCorner>;
-}
-/**
- * East/north displacement for an individual surface corner.
- */
-export interface SurfaceCorner {
-    /** Eastward offset in meters relative to the base center. */
-    readonly east: number;
-    /** Northward offset in meters relative to the base center. */
-    readonly north: number;
-}
-/**
- * Number of surface corners returns from `calculateSurfaceCornerDisplacements`.
- */
-export declare const SURFACE_CORNER_DISPLACEMENT_COUNT: number;
-/**
- * Converts normalized surface corners into world-space displacements honoring anchor, rotation, and offsets.
- * @param {SurfaceCornerParams} params - Inputs describing quad geometry and positioning.
- * @returns {SurfaceCorner[]} Array of corner displacements in meters relative to the base center.
- */
-export declare const calculateSurfaceCornerDisplacements: (params: SurfaceCornerParams) => SurfaceCorner[];
-/**
- * Ensures the sprite's cached Mercator coordinate matches its current location.
- * Recomputes the coordinate lazily when longitude/latitude/altitude change.
- * @param {ProjectionHost} projectionHost - Projection host.
- * @param {InternalSpriteCurrentState<T>} sprite - Target sprite.
- * @returns {SpriteMercatorCoordinate} Cached Mercator coordinate representing the current location.
- */
-export declare const resolveSpriteMercator: <T>(projectionHost: ProjectionHost, sprite: InternalSpriteCurrentState<T>) => SpriteMercatorCoordinate;
-/**
- * Clamp opacity value.
- * @param value Value
- * @returns Clamped value
- */
-export declare const clampOpacity: (value: number) => number;

package/dist/utils/utils.d.ts

@@ -1,37 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.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: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { ImageHandleBufferController, IdHandler, RenderTargetBucketBuffers, RenderTargetEntryLike, SpriteOriginReference } from '../internalTypes';
-/**
- * Create id handler object.
- * @param T Identified instance type
- * @returns Image id handler object.
- * @remarks It is used for (wasm) interoperability for image identity.
- */
-export declare const createIdHandler: <T>() => IdHandler<T>;
-/**
- * Image handle buffer controller interface.
- * @remarks It is used for (wasm) interoperability for image identity.
- */
-export declare const createImageHandleBufferController: () => ImageHandleBufferController;
-/**
- * Creates typed buffers aligned with the supplied render target bucket for WASM interop.
- * @param bucket Render target bucket containing sprite/image pairs.
- * @param options Optional configuration.
- * @returns {RenderTargetBucketBuffers} Typed array views of origin metadata.
- */
-export declare const createRenderTargetBucketBuffers: <T>(bucket: readonly Readonly<RenderTargetEntryLike<T>>[], options?: {
-    readonly originReference?: SpriteOriginReference;
-}) => RenderTargetBucketBuffers;
-/**
- * Encode/Decode a (subLayer, order) pair into a compact numeric key.
- * @remarks It is used for (wasm) interoperability for image identity.
- */
-export declare const createSpriteOriginReference: () => SpriteOriginReference;

package/dist/wasm/config.json.d.ts

@@ -1,16 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.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: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-declare const _default: {
-  "pthreadPoolSize": 4
-}
-;
-
-export default _default;