maplibre-gl-layers 0.11.0 → 0.12.0

package/dist/shader.d.ts

@@ -0,0 +1,83 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.12.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: e8e2cd81aeec4b10f2898c0ede5880ac56bf748d
+ */
+
+import { SpriteAnchor, SpriteScreenPoint } from './types';
+/** Number of components per vertex (clipPosition.xyzw + uv.xy). */
+export declare const VERTEX_COMPONENT_COUNT = 6;
+/** Component count for clip-space position attributes. */
+export declare const POSITION_COMPONENT_COUNT = 4;
+/** Component count for UV attributes. */
+export declare const UV_COMPONENT_COUNT = 2;
+/** Byte size of a Float32. */
+export declare const FLOAT_SIZE: number;
+/** Stride per vertex in bytes. */
+export declare const VERTEX_STRIDE: number;
+/** Byte offset for the UV attribute. */
+export declare const UV_OFFSET: number;
+/** Vertex count required to draw one sprite as two triangles. */
+export declare const QUAD_VERTEX_COUNT = 6;
+/** Shared vertex shader that converts screen-space vertices when requested. */
+export declare const VERTEX_SHADER_SOURCE: "\nattribute vec4 a_position;\nattribute vec2 a_uv;\nuniform vec2 u_screenToClipScale;\nuniform vec2 u_screenToClipOffset;\nuniform float u_billboardMode;\nuniform float u_surfaceMode;\nuniform vec2 u_billboardCenter;\nuniform vec2 u_billboardHalfSize;\nuniform vec2 u_billboardAnchor;\nuniform vec2 u_billboardSinCos;\nuniform float u_surfaceClipEnabled;\nuniform vec4 u_surfaceClipCenter;\nuniform vec4 u_surfaceClipBasisEast;\nuniform vec4 u_surfaceClipBasisNorth;\nuniform float u_surfaceDepthBias;\nvarying vec2 v_uv;\nvec2 computeBillboardCorner(vec2 uv) {\n  vec2 base = vec2(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);\n  vec2 anchorShift = vec2(u_billboardAnchor.x * u_billboardHalfSize.x, u_billboardAnchor.y * u_billboardHalfSize.y);\n  vec2 shifted = vec2(base.x * u_billboardHalfSize.x, base.y * u_billboardHalfSize.y) - anchorShift;\n  float sinR = u_billboardSinCos.x;\n  float cosR = u_billboardSinCos.y;\n  vec2 rotated = vec2(\n    shifted.x * cosR - shifted.y * sinR,\n    shifted.x * sinR + shifted.y * cosR\n  );\n  return vec2(\n    u_billboardCenter.x + rotated.x,\n    u_billboardCenter.y - rotated.y\n  );\n}\nvec4 computeSurfaceCorner(vec2 corner) {\n  if (u_surfaceClipEnabled < 0.5) {\n    return vec4(0.0, 0.0, 0.0, 1.0);\n  }\n  vec4 clip = u_surfaceClipCenter\n    + (corner.x * u_surfaceClipBasisEast)\n    + (corner.y * u_surfaceClipBasisNorth);\n  clip.z += u_surfaceDepthBias * clip.w;\n  return clip;\n}\nvoid main() {\n  v_uv = a_uv;\n  vec4 position;\n  if (u_billboardMode > 0.5) {\n    vec2 screenPosition = computeBillboardCorner(a_uv);\n    position = vec4(screenPosition, 0.0, 1.0);\n  } else if (u_surfaceMode > 0.5) {\n    vec2 baseCorner = vec2(a_position.x, a_position.y);\n    position = computeSurfaceCorner(baseCorner);\n  } else {\n    position = a_position;\n  }\n  position.xy = position.xy * u_screenToClipScale + u_screenToClipOffset;\n  gl_Position = position;\n}\n";
+/** Fragment shader that applies texture sampling and opacity. */
+export declare const FRAGMENT_SHADER_SOURCE: "\nprecision mediump float;\nuniform sampler2D u_texture;\nuniform float u_opacity;\nvarying vec2 v_uv;\nvoid main() {\n  vec4 texel = texture2D(u_texture, v_uv);\n  gl_FragColor = vec4(texel.rgb, texel.a) * u_opacity;\n}\n";
+/** Initial vertex data for a unit quad. */
+export declare const INITIAL_QUAD_VERTICES: Float32Array<ArrayBuffer>;
+/** Scratch buffer rewritten for each draw call. */
+export declare const QUAD_VERTEX_SCRATCH: Float32Array<ArrayBuffer>;
+/** Vertex shader for debug hit-test outline rendering using screen coordinates. */
+export declare const DEBUG_OUTLINE_VERTEX_SHADER_SOURCE: "\nattribute vec4 a_position;\nuniform vec2 u_screenToClipScale;\nuniform vec2 u_screenToClipOffset;\nvoid main() {\n  vec4 position = a_position;\n  position.xy = position.xy * u_screenToClipScale + u_screenToClipOffset;\n  gl_Position = position;\n}\n";
+/** Fragment shader emitting a solid color for debug outlines. */
+export declare const DEBUG_OUTLINE_FRAGMENT_SHADER_SOURCE: "\nprecision mediump float;\nuniform vec4 u_color;\nvoid main() {\n  gl_FragColor = u_color;\n}\n";
+/** Number of vertices required to outline a quad using LINE_LOOP. */
+export declare const DEBUG_OUTLINE_VERTEX_COUNT = 4;
+/** Components per debug outline vertex (clipPosition.xyzw). */
+export declare const DEBUG_OUTLINE_POSITION_COMPONENT_COUNT = 4;
+/** Stride in bytes for debug outline vertices. */
+export declare const DEBUG_OUTLINE_VERTEX_STRIDE: number;
+/** Scratch buffer reused when emitting debug outlines. */
+export declare const DEBUG_OUTLINE_VERTEX_SCRATCH: Float32Array<ArrayBuffer>;
+/** Solid red RGBA color used for debug outlines. */
+export declare const DEBUG_OUTLINE_COLOR: readonly [number, number, number, number];
+/** Corner traversal order used when outlining a quad without crossing diagonals. */
+export declare const DEBUG_OUTLINE_CORNER_ORDER: readonly [0, 1, 3, 2];
+/** Base corner definitions used when expanding billboards in shaders. */
+export declare const BILLBOARD_BASE_CORNERS: ReadonlyArray<readonly [number, number]>;
+/** Base corner definitions used when expanding surface quads in shaders. */
+export declare const SURFACE_BASE_CORNERS: ReadonlyArray<readonly [number, number]>;
+export declare const computeBillboardCornersShaderModel: ({ center, halfWidth, halfHeight, anchor, rotationDeg, }: {
+    center: Readonly<SpriteScreenPoint>;
+    halfWidth: number;
+    halfHeight: number;
+    anchor?: Readonly<SpriteAnchor>;
+    rotationDeg: number;
+}) => Array<{
+    x: number;
+    y: number;
+    u: number;
+    v: number;
+}>;
+/**
+ * Compiles a shader from source, throwing if compilation fails.
+ * @param {WebGLRenderingContext} glContext - Active WebGL context.
+ * @param {number} type - Shader type (`VERTEX_SHADER` or `FRAGMENT_SHADER`).
+ * @param {string} source - GLSL source code.
+ * @returns {WebGLShader} Compiled shader object.
+ * @throws When shader creation or compilation fails.
+ */
+export declare const compileShader: (glContext: WebGLRenderingContext, type: number, source: string) => WebGLShader;
+/**
+ * Links a vertex and fragment shader into a WebGL program.
+ * @param {WebGLRenderingContext} glContext - Active WebGL context.
+ * @param {string} vertexSource - Vertex shader GLSL source.
+ * @param {string} fragmentSource - Fragment shader GLSL source.
+ * @returns {WebGLProgram} Linked shader program ready for use.
+ * @throws When linking fails or a program cannot be created.
+ */
+export declare const createShaderProgram: (glContext: WebGLRenderingContext, vertexSource: string, fragmentSource: string) => WebGLProgram;

package/dist/types.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.11.0
+ * version: 0.12.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: 371efb126f281333d59ec75cfe788d45f3b1482e
+ * git.commit.hash: e8e2cd81aeec4b10f2898c0ede5880ac56bf748d
  */
 
 import { CustomLayerInterface } from 'maplibre-gl';
@@ -379,17 +379,21 @@ export interface SpriteMutateCallbacks<TTag, TSourceItem extends SpriteMutateSou
     modify: (sourceItem: TSourceItem, sprite: SpriteCurrentState<TTag>, update: SpriteUpdaterEntry<TTag>) => SpriteModifierResult;
 }
 /**
- * Represents a point in screen space.
+ * Represents a point on anonymous-unit space.
  *
- * @property {number} x - Horizontal screen coordinate in pixels.
- * @property {number} y - Vertical screen coordinate in pixels.
+ * @property {number} x - Horizontal (X axis) coordinate.
+ * @property {number} y - Vertical (Y axis) coordinate.
  */
-export interface SpriteScreenPoint {
-    /** Horizontal screen coordinate in pixels. */
+export interface SpritePoint {
+    /** Horizontal (X axis) coordinate. */
     readonly x: number;
-    /** Vertical screen coordinate in pixels. */
+    /** Vertical (Y axis) coordinate. */
     readonly y: number;
 }
+/**
+ * Represents a point in screen space.
+ */
+export type SpriteScreenPoint = SpritePoint;
 /**
  * Event dispatched when a sprite is clicked or tapped.
  *
@@ -508,6 +512,10 @@ export interface SpriteTextureFilteringOptions {
     generateMipmaps?: boolean;
     maxAnisotropy?: number;
 }
+/**
+ * Calculation variant. It is internal calculation methods.
+ */
+export type SpriteLayerCalculationVariant = 'simd' | 'nosimd' | 'disabled';
 /**
  * Options accepted when creating a SpriteLayer.
  *

package/dist/utils.d.ts

@@ -1,32 +1,37 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.11.0
+ * version: 0.12.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: 371efb126f281333d59ec75cfe788d45f3b1482e
+ * git.commit.hash: e8e2cd81aeec4b10f2898c0ede5880ac56bf748d
  */
 
-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);
-}
+import { ImageHandleBufferController, IdHandler, RenderTargetBucketBuffers, RenderTargetEntryLike, SpriteOriginReference } from './internalTypes';
 /**
- * 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.
+ * 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 readImageBitmap: (blob: Blob, options?: SpriteImageRegisterOptions) => Promise<ImageBitmap>;
+export declare const createIdHandler: <T>() => IdHandler<T>;
 /**
- * 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.
+ * Image handle buffer controller interface.
+ * @remarks It is used for (wasm) interoperability for image identity.
  */
-export declare const loadImageBitmap: (url: string, options?: SpriteImageRegisterOptions) => Promise<ImageBitmap>;
+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/wasmCalculationHost.d.ts

@@ -0,0 +1,68 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.12.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: e8e2cd81aeec4b10f2898c0ede5880ac56bf748d
+ */
+
+import { ClipContext, ImageHandleBufferController, IdHandler, InternalSpriteCurrentState, InternalSpriteImageState, PreparedDrawSpriteImageParams, PrepareDrawSpriteImageParams, Releaseable, RegisteredImage, RenderCalculationHost, SpriteOriginReference } from './internalTypes';
+import { SurfaceCorner } from './math';
+import { SpriteLocation, SpriteScreenPoint } from './types';
+import { BufferHolder, WasmHost } from './wasmHost';
+import { PreparedProjectionState, ProjectionHostParams } from './projectionHost';
+export declare const createWasmProjectLngLatToClipSpace: () => {
+    (clipContext: Readonly<ClipContext> | null, location: Readonly<SpriteLocation>): number[] | null;
+    release(): void;
+};
+export declare const createWasmCalculateBillboardDepthKey: (preparedState: PreparedProjectionState) => {
+    (_center: Readonly<SpriteScreenPoint>): number | null;
+    release(): void;
+};
+type CalculateSurfaceDepthKeyOptions = {
+    readonly indices?: readonly number[];
+    readonly bias?: {
+        readonly ndc: number;
+        readonly minClipZEpsilon?: number;
+    };
+};
+export declare const createWasmCalculateSurfaceDepthKey: (preparedState: PreparedProjectionState) => {
+    (baseLngLat: Readonly<SpriteLocation>, displacements: readonly SurfaceCorner[], options?: CalculateSurfaceDepthKeyOptions): number | null;
+    release(): void;
+};
+interface PreparedInputBuffer extends Releaseable {
+    readonly parameterHolder: BufferHolder<Float64Array>;
+    readonly resultItemCount: number;
+}
+interface WritableWasmProjectionState<TTag> {
+    readonly preparedProjection: PreparedProjectionState;
+    readonly prepareInputBuffer: (params: PrepareDrawSpriteImageParams<TTag>) => PreparedInputBuffer;
+    readonly getImageRefs: () => readonly InternalSpriteImageState[];
+    readonly getResourceRefs: () => readonly (RegisteredImage | undefined)[];
+}
+/**
+ * Wasm interoperability dependencies.
+ * @remarks These are a group of helpers that perform marshaling to generate input/output data for wasm calculation.
+ */
+export interface WasmCalculationInteropDependencies<TTag> {
+    readonly imageIdHandler: IdHandler<RegisteredImage>;
+    readonly imageHandleBuffersController: ImageHandleBufferController;
+    readonly originReference: SpriteOriginReference;
+    readonly spriteIdHandler: IdHandler<InternalSpriteCurrentState<TTag>>;
+}
+/**
+ * Create calculation host that wasm implementation.
+ * @param TTag Tag type.
+ * @param params Projection host params.
+ * @param deps Wasm interoperability dependencies.
+ * @returns Calculation host.
+ */
+export declare const createWasmCalculationHost: <TTag>(params: ProjectionHostParams, deps: WasmCalculationInteropDependencies<TTag>) => RenderCalculationHost<TTag>;
+export declare const __wasmCalculationTestInternals: {
+    convertToWasmProjectionState: <TTag>(wasm: WasmHost, params: ProjectionHostParams, deps: WasmCalculationInteropDependencies<TTag>) => WritableWasmProjectionState<TTag>;
+    converToPreparedDrawImageParams: <TTag>(state: WritableWasmProjectionState<TTag>, deps: WasmCalculationInteropDependencies<TTag>, resultBuffer: BufferHolder<Float64Array>) => PreparedDrawSpriteImageParams<TTag>[];
+    prepareDrawSpriteImagesInternal: <TTag>(wasm: WasmHost, wasmState: WritableWasmProjectionState<TTag>, deps: WasmCalculationInteropDependencies<TTag>, params: PrepareDrawSpriteImageParams<TTag>) => PreparedDrawSpriteImageParams<TTag>[];
+};
+export {};

package/dist/wasmHost.d.ts

@@ -0,0 +1,125 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.12.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: e8e2cd81aeec4b10f2898c0ede5880ac56bf748d
+ */
+
+import { SpriteLayerCalculationVariant } from './types';
+/**
+ * `fromLngLat` function parameter
+ */
+export type WasmFromLngLat = (lng: number, lat: number, altitude: number, outPtr: number) => boolean;
+/**
+ * `project` function parameter
+ */
+export type WasmProject = (lng: number, lat: number, altitude: number, worldSize: number, matrixPtr: number, outPtr: number) => boolean;
+/**
+ * `unproject` function parameter
+ */
+export type WasmUnproject = (x: number, y: number, worldSize: number, matrixPtr: number, outPtr: number) => boolean;
+/**
+ * `calculatePerspectiveRatio` function parameter
+ */
+export type WasmCalculatePerspectiveRatio = (lng: number, lat: number, altitude: number, cachedMercatorPtr: number, cameraToCenterDistance: number, matrixPtr: number, outPtr: number) => boolean;
+export type WasmProjectLngLatToClipSpace = (lng: number, lat: number, altitude: number, matrixPtr: number, outPtr: number) => boolean;
+export type WasmCalculateBillboardDepthKey = (centerX: number, centerY: number, worldSize: number, inverseMatrixPtr: number, mercatorMatrixPtr: number, outPtr: number) => boolean;
+export type WasmCalculateSurfaceDepthKey = (baseLng: number, baseLat: number, baseAltitude: number, displacementPtr: number, displacementCount: number, indexPtr: number, indexCount: number, mercatorMatrixPtr: number, applyBias: number, biasNdc: number, minClipZEpsilon: number, outPtr: number) => boolean;
+export type WasmPrepareDrawSpriteImages = (paramsPtr: number, resultPtr: number) => boolean;
+/**
+ * Wasm raw pointer type.
+ */
+export type Pointer = number;
+/**
+ * An array element type that createTypedBuffer.
+ * @param TArray - A type for ArrayBufferView (ex: Float64Array)
+ */
+export type TypedArrayElement<TArray> = TArray extends {
+    [index: number]: infer T;
+} ? T : never;
+/**
+ * Typed ArrayBufferView.
+ * @param TArray - A type for ArrayBufferView (ex: Float64Array)
+ */
+export interface TypedArrayBufferView<TArray> extends ArrayBufferView {
+    /**
+     * Copy in an array.
+     * @param from An array.
+     */
+    readonly set: (from: ArrayLike<TypedArrayElement<TArray>>) => void;
+    readonly length: number;
+}
+/**
+ * TypedArrayBuffer view constructor type.
+ * @param TArray - A type for ArrayBufferView (ex: Float64Array)
+ */
+export type TypedArrayConstructor<TArray extends TypedArrayBufferView<TArray>> = {
+    readonly BYTES_PER_ELEMENT: number;
+    new (buffer: ArrayBuffer, byteOffset: number, length: number): TArray;
+};
+/**
+ * The BufferHolder, capsule both wasm raw memory pointer and ArrayBufferBuffer.
+ * @param TArray - A type for ArrayBufferView (ex: Float64Array)
+ */
+export interface BufferHolder<TArray extends TypedArrayBufferView<TArray>> {
+    /**
+     * Prepare and get the raw pointer and the buffer reference.
+     * @returns The raw pointer and the buffer reference.
+     */
+    readonly prepare: () => {
+        ptr: Pointer;
+        buffer: TArray;
+    };
+    /**
+     * Release the buffer.
+     * @returns
+     */
+    readonly release: () => void;
+}
+/**
+ * Wasm host reference.
+ */
+export interface WasmHost {
+    /**
+     * Helper for wasm interoperation buffer.
+     * @param TArray - A type for ArrayBufferView (ex: Float64Array)
+     * @param ArrayType - ArrayBufferView constructor
+     * @param elements - Buffer element count or copy in data array.
+     */
+    readonly allocateTypedBuffer: <TArray extends TypedArrayBufferView<TArray>>(ArrayType: TypedArrayConstructor<TArray>, elements: number | ArrayLike<TypedArrayElement<TArray>>) => BufferHolder<TArray>;
+    readonly fromLngLat: WasmFromLngLat;
+    readonly project: WasmProject;
+    readonly calculatePerspectiveRatio: WasmCalculatePerspectiveRatio;
+    readonly unproject: WasmUnproject;
+    readonly projectLngLatToClipSpace: WasmProjectLngLatToClipSpace;
+    readonly calculateBillboardDepthKey: WasmCalculateBillboardDepthKey;
+    readonly calculateSurfaceDepthKey: WasmCalculateSurfaceDepthKey;
+    readonly prepareDrawSpriteImages?: WasmPrepareDrawSpriteImages;
+}
+export type WasmVariant = SpriteLayerCalculationVariant;
+/**
+ * Wasm initialization options.
+ */
+export interface InitializeWasmHostOptions {
+    /** Force initialization. Default is false. */
+    readonly force?: boolean;
+}
+/**
+ * Initialize wasm offload module.
+ * @param preferredVariant Uses wasm offload module variant.
+ * @param options Options.
+ * @returns Initialized WasmHost.
+ */
+export declare const initializeWasmHost: (preferredVariant: WasmVariant, options?: InitializeWasmHostOptions) => Promise<WasmVariant>;
+/**
+ * Release wasm offload module.
+ */
+export declare const releaseWasmHost: () => void;
+/**
+ * Get wasm host.
+ * @returns Entry points.
+ */
+export declare const prepareWasmHost: () => WasmHost;

package/dist/wasmProjectionHost.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.12.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: e8e2cd81aeec4b10f2898c0ede5880ac56bf748d
+ */
+
+import { ProjectionHostParams } from './projectionHost';
+import { ProjectionHost } from './internalTypes';
+/**
+ * Create wasm-based calculation projection host.
+ * @param params Projection parameters
+ * @returns Projection host
+ * @remarks This needs using before initialization (initializeWasmHost function)
+ */
+export declare const createWasmProjectionHost: (params: ProjectionHostParams) => ProjectionHost;

package/package.json

@@ -1,20 +1,20 @@
 {
   "git": {
     "tags": [
-      "0.11.0"
+      "0.12.0"
     ],
     "branches": [
       "main"
     ],
-    "version": "0.11.0",
+    "version": "0.12.0",
     "commit": {
-      "hash": "371efb126f281333d59ec75cfe788d45f3b1482e",
-      "shortHash": "371efb1",
-      "date": "2025-11-01T23:41:18+09:00Z",
+      "hash": "e8e2cd81aeec4b10f2898c0ede5880ac56bf748d",
+      "shortHash": "e8e2cd8",
+      "date": "2025-11-10T22:39:19+09:00Z",
       "message": "Merge branch 'develop'"
     }
   },
-  "version": "0.11.0",
+  "version": "0.12.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",
@@ -53,13 +53,14 @@
     "images/demo2.png"
   ],
   "scripts": {
-    "build": "vite build",
+    "build": "node ./scripts/build-wasm.mjs && vite build",
     "dev": "npm run build",
     "test": "npm run build && vitest run",
     "test:e2e": "npm run build && playwright test",
     "pack": "npm run build && screw-up pack --pack-destination ../artifacts"
   },
   "dependencies": {
+    "async-primitives": ">=1.4.0",
     "maplibre-gl": ">=5.0.0"
   },
   "devDependencies": {

package/dist/location.d.ts

@@ -1,24 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.11.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: 371efb126f281333d59ec75cfe788d45f3b1482e
- */
-
-import { SpriteLocation } from './types';
-/**
- * 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;