maplibre-gl-layers 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.3.0
+ * version: 0.5.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: fd90d1fd66e4ca9c0defa49e68ecaeb9c14fbd06
+ * git.commit.hash: ce37eea48b788c36b4bf98cdfce83b95a85833ee
  */
 
 export * from './types.ts';

package/dist/index.mjs

@@ -1,12 +1,30 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.3.0
+ * version: 0.5.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: fd90d1fd66e4ca9c0defa49e68ecaeb9c14fbd06
+ * git.commit.hash: ce37eea48b788c36b4bf98cdfce83b95a85833ee
  */
+const UNLIMITED_SPRITE_SCALING_OPTIONS = {
+  metersPerPixel: 1,
+  zoomMin: 0,
+  zoomMax: 30,
+  scaleMin: 1,
+  scaleMax: 1,
+  spriteMinPixel: 0,
+  spriteMaxPixel: 1e5
+};
+const STANDARD_SPRITE_SCALING_OPTIONS = {
+  metersPerPixel: 1,
+  zoomMin: 8,
+  zoomMax: 20,
+  scaleMin: 0.1,
+  scaleMax: 1,
+  spriteMinPixel: 24,
+  spriteMaxPixel: 100
+};
 var maplibreGl$1 = { exports: {} };
 /**
  * MapLibre GL JS
@@ -21311,26 +21329,134 @@ const EARTH_RADIUS_METERS = 6378137;
 const DEG2RAD = Math.PI / 180;
 const RAD2DEG = 180 / Math.PI;
 const TILE_SIZE = 512;
-const DEFAULT_SPRITE_SCALING_OPTIONS = {
-  metersPerPixel: 1,
-  zoomMin: 0,
-  zoomMax: 30,
-  scaleMin: 1,
-  scaleMax: 1,
-  spriteMinPixel: 0,
-  spriteMaxPixel: 1e4
-};
 const resolveScalingOptions = (options) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
-  const base = DEFAULT_SPRITE_SCALING_OPTIONS;
+  var _a, _b;
+  const base = UNLIMITED_SPRITE_SCALING_OPTIONS;
+  const warnings = [];
+  const fallbackMetersPerPixel = Number.isFinite(base.metersPerPixel) && ((_a = base.metersPerPixel) != null ? _a : 0) > 0 ? base.metersPerPixel : 1;
+  let metersPerPixel = (options == null ? void 0 : options.metersPerPixel) !== void 0 ? options.metersPerPixel : fallbackMetersPerPixel;
+  if (!Number.isFinite(metersPerPixel) || metersPerPixel <= 0) {
+    if ((options == null ? void 0 : options.metersPerPixel) !== void 0) {
+      warnings.push(
+        `metersPerPixel(${String(options.metersPerPixel)}) is invalid; using ${fallbackMetersPerPixel}`
+      );
+    }
+    metersPerPixel = fallbackMetersPerPixel;
+  }
+  const fallbackZoomMin = Number.isFinite(base.zoomMin) ? base.zoomMin : 0;
+  let zoomMin = (options == null ? void 0 : options.zoomMin) !== void 0 ? options.zoomMin : fallbackZoomMin;
+  if (!Number.isFinite(zoomMin)) {
+    if ((options == null ? void 0 : options.zoomMin) !== void 0) {
+      warnings.push(
+        `zoomMin(${String(options.zoomMin)}) is not finite; using ${fallbackZoomMin}`
+      );
+    }
+    zoomMin = fallbackZoomMin;
+  }
+  const fallbackZoomMax = Number.isFinite(base.zoomMax) && base.zoomMax > fallbackZoomMin ? base.zoomMax : fallbackZoomMin;
+  let zoomMax = (options == null ? void 0 : options.zoomMax) !== void 0 ? options.zoomMax : fallbackZoomMax;
+  if (!Number.isFinite(zoomMax)) {
+    if ((options == null ? void 0 : options.zoomMax) !== void 0) {
+      warnings.push(
+        `zoomMax(${String(options.zoomMax)}) is not finite; using ${fallbackZoomMax}`
+      );
+    }
+    zoomMax = fallbackZoomMax;
+  }
+  if (zoomMax < zoomMin) {
+    warnings.push(
+      `zoomMax(${zoomMax}) < zoomMin(${zoomMin}); swapped values to maintain ascending order`
+    );
+    [zoomMin, zoomMax] = [zoomMax, zoomMin];
+  }
+  const fallbackScaleMin = Number.isFinite(base.scaleMin) ? base.scaleMin : 1;
+  let scaleMin = (options == null ? void 0 : options.scaleMin) !== void 0 ? options.scaleMin : fallbackScaleMin;
+  if (!Number.isFinite(scaleMin)) {
+    if ((options == null ? void 0 : options.scaleMin) !== void 0) {
+      warnings.push(
+        `scaleMin(${String(options.scaleMin)}) is not finite; using ${fallbackScaleMin}`
+      );
+    }
+    scaleMin = fallbackScaleMin;
+  }
+  if (scaleMin < 0) {
+    warnings.push(`scaleMin(${scaleMin}) is negative; clamped to 0`);
+    scaleMin = 0;
+  }
+  const fallbackScaleMax = Number.isFinite(base.scaleMax) ? base.scaleMax : 1;
+  let scaleMax = (options == null ? void 0 : options.scaleMax) !== void 0 ? options.scaleMax : fallbackScaleMax;
+  if (!Number.isFinite(scaleMax)) {
+    if ((options == null ? void 0 : options.scaleMax) !== void 0) {
+      warnings.push(
+        `scaleMax(${String(options.scaleMax)}) is not finite; using ${fallbackScaleMax}`
+      );
+    }
+    scaleMax = fallbackScaleMax;
+  }
+  if (scaleMax < 0) {
+    warnings.push(`scaleMax(${scaleMax}) is negative; clamped to 0`);
+    scaleMax = 0;
+  }
+  if (scaleMax < scaleMin) {
+    warnings.push(
+      `scaleMax(${scaleMax}) < scaleMin(${scaleMin}); swapped values to maintain ascending order`
+    );
+    [scaleMin, scaleMax] = [scaleMax, scaleMin];
+  }
+  const fallbackSpriteMin = Number.isFinite(base.spriteMinPixel) && base.spriteMinPixel >= 0 ? base.spriteMinPixel : 0;
+  let spriteMinPixel = (options == null ? void 0 : options.spriteMinPixel) !== void 0 ? options.spriteMinPixel : fallbackSpriteMin;
+  if (!Number.isFinite(spriteMinPixel)) {
+    if ((options == null ? void 0 : options.spriteMinPixel) !== void 0) {
+      warnings.push(
+        `spriteMinPixel(${String(
+          options.spriteMinPixel
+        )}) is not finite; using ${fallbackSpriteMin}`
+      );
+    }
+    spriteMinPixel = fallbackSpriteMin;
+  } else if (spriteMinPixel < 0) {
+    warnings.push(
+      `spriteMinPixel(${spriteMinPixel}) is negative; clamped to 0`
+    );
+    spriteMinPixel = 0;
+  }
+  const fallbackSpriteMax = Number.isFinite(base.spriteMaxPixel) && base.spriteMaxPixel >= 0 ? base.spriteMaxPixel : 0;
+  let spriteMaxPixel = (options == null ? void 0 : options.spriteMaxPixel) !== void 0 ? options.spriteMaxPixel : fallbackSpriteMax;
+  if (!Number.isFinite(spriteMaxPixel)) {
+    if ((options == null ? void 0 : options.spriteMaxPixel) !== void 0) {
+      warnings.push(
+        `spriteMaxPixel(${String(
+          options.spriteMaxPixel
+        )}) is not finite; using ${fallbackSpriteMax}`
+      );
+    }
+    spriteMaxPixel = fallbackSpriteMax;
+  } else if (spriteMaxPixel < 0) {
+    warnings.push(
+      `spriteMaxPixel(${spriteMaxPixel}) is negative; clamped to 0`
+    );
+    spriteMaxPixel = 0;
+  }
+  if (spriteMinPixel > 0 && spriteMaxPixel > 0 && spriteMaxPixel < spriteMinPixel) {
+    warnings.push(
+      `spriteMaxPixel(${spriteMaxPixel}) < spriteMinPixel(${spriteMinPixel}); swapped values to maintain ascending order`
+    );
+    [spriteMinPixel, spriteMaxPixel] = [spriteMaxPixel, spriteMinPixel];
+  }
+  if (warnings.length > 0 && typeof console !== "undefined") {
+    const warn = (_b = console.warn) != null ? _b : null;
+    if (typeof warn === "function") {
+      warn(`[SpriteScalingOptions] ${warnings.join("; ")}`);
+    }
+  }
   return {
-    metersPerPixel: (_b = (_a = options == null ? void 0 : options.metersPerPixel) != null ? _a : base.metersPerPixel) != null ? _b : 1,
-    zoomMin: (_d = (_c = options == null ? void 0 : options.zoomMin) != null ? _c : base.zoomMin) != null ? _d : 0,
-    zoomMax: (_f = (_e = options == null ? void 0 : options.zoomMax) != null ? _e : base.zoomMax) != null ? _f : 24,
-    scaleMin: (_h = (_g = options == null ? void 0 : options.scaleMin) != null ? _g : base.scaleMin) != null ? _h : 1,
-    scaleMax: (_j = (_i = options == null ? void 0 : options.scaleMax) != null ? _i : base.scaleMax) != null ? _j : 1,
-    spriteMinPixel: (_l = (_k = options == null ? void 0 : options.spriteMinPixel) != null ? _k : base.spriteMinPixel) != null ? _l : 0,
-    spriteMaxPixel: (_n = (_m = options == null ? void 0 : options.spriteMaxPixel) != null ? _m : base.spriteMaxPixel) != null ? _n : 0
+    metersPerPixel,
+    zoomMin,
+    zoomMax,
+    scaleMin,
+    scaleMax,
+    spriteMinPixel,
+    spriteMaxPixel
   };
 };
 const calculateZoomScaleFactor = (zoom, scaling) => {
@@ -21391,25 +21517,30 @@ const calculateDistanceAndBearingMeters = (from, to) => {
 const clampSpritePixelSize = (width, height, spriteMinPixel, spriteMaxPixel) => {
   const largest = Math.max(width, height);
   if (!Number.isFinite(largest) || largest <= 0) {
-    return { width, height };
+    return { width, height, scaleAdjustment: 1 };
   }
   let nextWidth = width;
   let nextHeight = height;
+  let scaleAdjustment = 1;
+  let adjustedLargest = largest;
   if (spriteMinPixel > 0 && largest < spriteMinPixel) {
     const factor = spriteMinPixel / largest;
     nextWidth *= factor;
     nextHeight *= factor;
+    scaleAdjustment *= factor;
+    adjustedLargest *= factor;
   }
-  if (spriteMaxPixel > 0 && largest > spriteMaxPixel) {
-    const factor = spriteMaxPixel / largest;
+  if (spriteMaxPixel > 0 && adjustedLargest > spriteMaxPixel) {
+    const factor = spriteMaxPixel / adjustedLargest;
     nextWidth *= factor;
     nextHeight *= factor;
+    scaleAdjustment *= factor;
   }
-  return { width: nextWidth, height: nextHeight };
+  return { width: nextWidth, height: nextHeight, scaleAdjustment };
 };
 const calculateBillboardPixelDimensions = (imageWidth, imageHeight, baseMetersPerPixel, imageScale, zoomScaleFactor, effectivePixelsPerMeter, spriteMinPixel, spriteMaxPixel) => {
   if (!imageWidth || !imageHeight || imageWidth <= 0 || imageHeight <= 0 || baseMetersPerPixel <= 0 || effectivePixelsPerMeter <= 0) {
-    return { width: 0, height: 0 };
+    return { width: 0, height: 0, scaleAdjustment: 1 };
   }
   const scaleFactor = baseMetersPerPixel * imageScale * zoomScaleFactor * effectivePixelsPerMeter;
   const rawWidth = ensureFinite(imageWidth * scaleFactor);
@@ -21421,10 +21552,10 @@ const calculateBillboardPixelDimensions = (imageWidth, imageHeight, baseMetersPe
     spriteMaxPixel
   );
 };
-const calculateBillboardOffsetPixels = (offset, imageScale, zoomScaleFactor, effectivePixelsPerMeter) => {
+const calculateBillboardOffsetPixels = (offset, imageScale, zoomScaleFactor, effectivePixelsPerMeter, sizeScaleAdjustment = 1) => {
   var _a, _b;
   const offsetMeters = ((_a = offset == null ? void 0 : offset.offsetMeters) != null ? _a : 0) * imageScale * zoomScaleFactor;
-  const offsetPixels = offsetMeters * effectivePixelsPerMeter;
+  const offsetPixels = offsetMeters * effectivePixelsPerMeter * sizeScaleAdjustment;
   const offsetRad = ((_b = offset == null ? void 0 : offset.offsetDeg) != null ? _b : 0) * DEG2RAD;
   return {
     x: offsetPixels * Math.sin(offsetRad),
@@ -21448,14 +21579,40 @@ const calculateBillboardAnchorShiftPixels = (halfWidth, halfHeight, anchor, tota
   const shiftY = -anchorX * sinR - anchorY * cosR;
   return { x: shiftX, y: shiftY };
 };
-const calculateSurfaceWorldDimensions = (imageWidth, imageHeight, baseMetersPerPixel, imageScale, zoomScaleFactor) => {
+const calculateSurfaceWorldDimensions = (imageWidth, imageHeight, baseMetersPerPixel, imageScale, zoomScaleFactor, options) => {
+  var _a, _b;
   if (!imageWidth || !imageHeight || imageWidth <= 0 || imageHeight <= 0 || baseMetersPerPixel <= 0) {
-    return { width: 0, height: 0 };
+    return { width: 0, height: 0, scaleAdjustment: 1 };
   }
   const scaleFactor = baseMetersPerPixel * imageScale * zoomScaleFactor;
-  const width = ensureFinite(imageWidth * scaleFactor);
-  const height = ensureFinite(imageHeight * scaleFactor);
-  return { width, height };
+  let width = ensureFinite(imageWidth * scaleFactor);
+  let height = ensureFinite(imageHeight * scaleFactor);
+  let scaleAdjustment = 1;
+  const effectivePixelsPerMeter = (options == null ? void 0 : options.effectivePixelsPerMeter) !== void 0 ? options.effectivePixelsPerMeter : 0;
+  const spriteMinPixel = (_a = options == null ? void 0 : options.spriteMinPixel) != null ? _a : 0;
+  const spriteMaxPixel = (_b = options == null ? void 0 : options.spriteMaxPixel) != null ? _b : 0;
+  if (effectivePixelsPerMeter > 0 && Number.isFinite(effectivePixelsPerMeter) && (spriteMinPixel > 0 || spriteMaxPixel > 0)) {
+    const largestMeters = Math.max(width, height);
+    if (largestMeters > 0 && Number.isFinite(largestMeters)) {
+      const largestPixels = largestMeters * effectivePixelsPerMeter;
+      if (Number.isFinite(largestPixels) && largestPixels > 0) {
+        let scale = 1;
+        if (spriteMinPixel > 0 && largestPixels < spriteMinPixel) {
+          scale = spriteMinPixel / largestPixels;
+        }
+        const scaledLargest = largestPixels * scale;
+        if (spriteMaxPixel > 0 && scaledLargest > spriteMaxPixel) {
+          scale = spriteMaxPixel / largestPixels;
+        }
+        if (scale !== 1) {
+          width *= scale;
+          height *= scale;
+          scaleAdjustment *= scale;
+        }
+      }
+    }
+  }
+  return { width, height, scaleAdjustment };
 };
 const calculateSurfaceAnchorShiftMeters = (halfWidthMeters, halfHeightMeters, anchor, totalRotateDeg) => {
   var _a, _b;
@@ -21474,16 +21631,16 @@ const calculateSurfaceAnchorShiftMeters = (halfWidthMeters, halfHeightMeters, an
   const north = -anchorEast * sinR - anchorNorth * cosR;
   return { east, north };
 };
-const calculateSurfaceOffsetMeters = (offset, imageScale) => {
+const calculateSurfaceOffsetMeters = (offset, imageScale, zoomScaleFactor, sizeScaleAdjustment = 1) => {
   var _a, _b;
-  const offsetMeters = ((_a = offset == null ? void 0 : offset.offsetMeters) != null ? _a : 0) * imageScale;
+  const offsetMeters = ((_a = offset == null ? void 0 : offset.offsetMeters) != null ? _a : 0) * imageScale * zoomScaleFactor;
   if (offsetMeters === 0) {
     return { east: 0, north: 0 };
   }
   const rad = ((_b = offset == null ? void 0 : offset.offsetDeg) != null ? _b : 0) * DEG2RAD;
   return {
-    east: offsetMeters * Math.sin(rad),
-    north: offsetMeters * Math.cos(rad)
+    east: offsetMeters * Math.sin(rad) * sizeScaleAdjustment,
+    north: offsetMeters * Math.cos(rad) * sizeScaleAdjustment
   };
 };
 const MIN_COS_LAT = 1e-6;
@@ -21631,7 +21788,8 @@ const calculateBillboardCenterPosition = (params) => {
     offset,
     imageScale,
     zoomScaleFactor,
-    effectivePixelsPerMeter
+    effectivePixelsPerMeter,
+    pixelDims.scaleAdjustment
   );
   const centerX = base.x + offsetShift.x;
   const centerY = base.y - offsetShift.y;
@@ -21694,6 +21852,9 @@ const calculateSurfaceCenterPosition = (params) => {
     totalRotateDeg,
     anchor,
     offset,
+    effectivePixelsPerMeter = 0,
+    spriteMinPixel = 0,
+    spriteMaxPixel = 0,
     project,
     projectToClipSpace,
     drawingBufferWidth,
@@ -21731,7 +21892,12 @@ const calculateSurfaceCenterPosition = (params) => {
     imageHeight,
     baseMetersPerPixel,
     imageScale,
-    zoomScaleFactor
+    zoomScaleFactor,
+    {
+      effectivePixelsPerMeter,
+      spriteMinPixel,
+      spriteMaxPixel
+    }
   );
   const halfWidthMeters = worldDims.width / 2;
   const halfHeightMeters = worldDims.height / 2;
@@ -21741,7 +21907,12 @@ const calculateSurfaceCenterPosition = (params) => {
     anchor,
     totalRotateDeg
   );
-  const offsetMeters = calculateSurfaceOffsetMeters(offset, imageScale);
+  const offsetMeters = calculateSurfaceOffsetMeters(
+    offset,
+    imageScale,
+    zoomScaleFactor,
+    worldDims.scaleAdjustment
+  );
   const totalEast = anchorShiftMeters.east + offsetMeters.east;
   const totalNorth = anchorShiftMeters.north + offsetMeters.north;
   const displaced = applySurfaceDisplacement(
@@ -22073,6 +22244,35 @@ const resolveTextGlyphPadding = (padding) => {
   }
   return { top: 0, right: 0, bottom: 0, left: 0 };
 };
+const resolveBorderSides = (sides) => {
+  if (!Array.isArray(sides) || sides.length === 0) {
+    return { top: true, right: true, bottom: true, left: true };
+  }
+  let top = false;
+  let right = false;
+  let bottom = false;
+  let left = false;
+  for (const side of sides) {
+    switch (side) {
+      case "top":
+        top = true;
+        break;
+      case "right":
+        right = true;
+        break;
+      case "bottom":
+        bottom = true;
+        break;
+      case "left":
+        left = true;
+        break;
+    }
+  }
+  if (!top && !right && !bottom && !left) {
+    return { top: true, right: true, bottom: true, left: true };
+  }
+  return { top, right, bottom, left };
+};
 const resolveTextAlign = (align) => {
   switch (align) {
     case "left":
@@ -22116,7 +22316,7 @@ const resolveTextGlyphOptions = (options, preferredLineHeight) => {
     DEFAULT_TEXT_GLYPH_FONT_SIZE
   );
   const resolvedFontSize = resolvePositiveFinite(
-    options == null ? void 0 : options.fontSizePixel,
+    options == null ? void 0 : options.fontSizePixelHint,
     fallbackFontSize
   );
   return {
@@ -22131,6 +22331,7 @@ const resolveTextGlyphOptions = (options, preferredLineHeight) => {
     borderColor: options == null ? void 0 : options.borderColor,
     borderWidthPixel: resolveNonNegativeFinite(options == null ? void 0 : options.borderWidthPixel, 0),
     borderRadiusPixel: resolveNonNegativeFinite(options == null ? void 0 : options.borderRadiusPixel, 0),
+    borderSides: resolveBorderSides(options == null ? void 0 : options.borderSides),
     textAlign: resolveTextAlign(options == null ? void 0 : options.textAlign),
     renderPixelRatio: resolveRenderPixelRatio(options == null ? void 0 : options.renderPixelRatio)
   };
@@ -22242,13 +22443,58 @@ const fillRoundedRect = (ctx, width, height, radius, color) => {
   ctx.fill();
   ctx.restore();
 };
-const strokeRoundedRect = (ctx, width, height, radius, color, lineWidth) => {
+const strokeRoundedRect = (ctx, width, height, radius, color, lineWidth, sides) => {
+  const { top, right, bottom, left } = sides;
+  if (lineWidth <= 0 || !top && !right && !bottom && !left) {
+    return;
+  }
   ctx.save();
-  ctx.beginPath();
-  drawRoundedRectPath(ctx, 0, 0, width, height, radius);
   ctx.strokeStyle = color;
   ctx.lineWidth = lineWidth;
-  ctx.stroke();
+  const cornerRadius = Math.max(0, Math.min(radius, width / 2, height / 2));
+  const previousCap = ctx.lineCap;
+  ctx.lineCap = cornerRadius === 0 ? "square" : "butt";
+  if (top) {
+    const startX = cornerRadius;
+    const endX = width - cornerRadius;
+    if (endX > startX) {
+      ctx.beginPath();
+      ctx.moveTo(startX, 0);
+      ctx.lineTo(endX, 0);
+      ctx.stroke();
+    }
+  }
+  if (right) {
+    const startY = cornerRadius;
+    const endY = height - cornerRadius;
+    if (endY > startY) {
+      ctx.beginPath();
+      ctx.moveTo(width, startY);
+      ctx.lineTo(width, endY);
+      ctx.stroke();
+    }
+  }
+  if (bottom) {
+    const startX = width - cornerRadius;
+    const endX = cornerRadius;
+    if (startX > endX) {
+      ctx.beginPath();
+      ctx.moveTo(startX, height);
+      ctx.lineTo(endX, height);
+      ctx.stroke();
+    }
+  }
+  if (left) {
+    const startY = height - cornerRadius;
+    const endY = cornerRadius;
+    if (startY > endY) {
+      ctx.beginPath();
+      ctx.moveTo(0, startY);
+      ctx.lineTo(0, endY);
+      ctx.stroke();
+    }
+  }
+  ctx.lineCap = previousCap;
   ctx.restore();
 };
 const measureTextWidthWithSpacing = (ctx, text, letterSpacing) => {
@@ -22574,6 +22820,9 @@ const createSpriteLayer = (options) => {
       totalRotateDeg: totalRotDeg,
       anchor: img.anchor,
       offset: img.offset,
+      effectivePixelsPerMeter,
+      spriteMinPixel,
+      spriteMaxPixel,
       projectToClipSpace,
       drawingBufferWidth,
       drawingBufferHeight,
@@ -23174,6 +23423,9 @@ const createSpriteLayer = (options) => {
           totalRotateDeg,
           anchor,
           offset: offsetDef,
+          effectivePixelsPerMeter,
+          spriteMinPixel,
+          spriteMaxPixel,
           projectToClipSpace: (lng, lat, elevation) => projectLngLatToClipSpace(lng, lat, elevation, clipContext),
           drawingBufferWidth,
           drawingBufferHeight,
@@ -23189,7 +23441,9 @@ const createSpriteLayer = (options) => {
         }
         const offsetMeters = calculateSurfaceOffsetMeters(
           offsetDef,
-          imageScale
+          imageScale,
+          zoomScaleFactor,
+          surfaceCenter.worldDimensions.scaleAdjustment
         );
         const cornerDisplacements = calculateSurfaceCornerDisplacements({
           worldWidthMeters: surfaceCenter.worldDimensions.width,
@@ -23384,14 +23638,21 @@ const createSpriteLayer = (options) => {
             imageResource.height,
             baseMetersPerPixel,
             imageScale,
-            zoomScaleFactor
+            zoomScaleFactor,
+            {
+              effectivePixelsPerMeter,
+              spriteMinPixel,
+              spriteMaxPixel
+            }
           );
           const totalRotateDeg = Number.isFinite(imageEntry.displayedRotateDeg) ? imageEntry.displayedRotateDeg : normaliseAngleDeg(
             ((_e = imageEntry.resolvedBaseRotateDeg) != null ? _e : 0) + ((_f = imageEntry.rotateDeg) != null ? _f : 0)
           );
           const offsetMeters = calculateSurfaceOffsetMeters(
             offsetResolved,
-            imageScale
+            imageScale,
+            zoomScaleFactor,
+            worldDims.scaleAdjustment
           );
           const cornerDisplacements = calculateSurfaceCornerDisplacements({
             worldWidthMeters: worldDims.width,
@@ -23654,7 +23915,8 @@ const createSpriteLayer = (options) => {
         strokeHeight,
         strokeRadius,
         resolved.borderColor,
-        borderWidth
+        borderWidth,
+        resolved.borderSides
       );
       ctx.restore();
     }
@@ -24477,6 +24739,8 @@ const createSpriteLayer = (options) => {
   return spriteLayout;
 };
 export {
+  STANDARD_SPRITE_SCALING_OPTIONS,
+  UNLIMITED_SPRITE_SCALING_OPTIONS,
   applyAutoRotation,
   calculatePerspectiveRatio,
   cloneAnchor,