@navaramap/three 0.0.0

package/src/pick/pickTerrain.ts

@@ -0,0 +1,254 @@
+import type { Nullable } from "@navaramap/core";
+import {
+  WebGLRenderer,
+  WebGLRenderTarget,
+  Vector2,
+  Vector3,
+  Vector4,
+  PerspectiveCamera,
+  Scene,
+  RGBAFormat,
+  Texture,
+  ShaderMaterial,
+  PlaneGeometry,
+  Mesh,
+  OrthographicCamera,
+} from "three";
+
+class DepthPickPass {
+  private quad: Mesh;
+  private scene: Scene;
+  private camera: OrthographicCamera;
+  private sampleTarget: WebGLRenderTarget;
+  private material: ShaderMaterial;
+
+  constructor() {
+    // Create reusable resources
+    this.material = new ShaderMaterial({
+      uniforms: {
+        tDepth: { value: null },
+        samplePos: { value: new Vector2() },
+      },
+      vertexShader: `
+        varying vec2 vUv;
+        void main() {
+          vUv = uv;
+          gl_Position = vec4(position, 1.0);
+        }
+      `,
+      fragmentShader: `
+        uniform sampler2D tDepth;
+        uniform vec2 samplePos;
+        varying vec2 vUv;
+        
+        void main() {
+          vec4 depthColor = texture2D(tDepth, samplePos);
+          gl_FragColor = depthColor;
+        }
+      `,
+    });
+
+    const geometry = new PlaneGeometry(2, 2);
+    this.quad = new Mesh(geometry, this.material);
+
+    this.scene = new Scene();
+    this.scene.add(this.quad);
+
+    this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    this.sampleTarget = new WebGLRenderTarget(1, 1, { format: RGBAFormat });
+  }
+
+  update(depthTexture: Texture, samplePos: Vector2) {
+    this.material.uniforms.tDepth.value = depthTexture;
+    this.material.uniforms.samplePos.value.copy(samplePos);
+  }
+
+  render(renderer: WebGLRenderer): Uint8Array {
+    renderer.setRenderTarget(this.sampleTarget);
+    renderer.render(this.scene, this.camera);
+    renderer.setRenderTarget(null);
+
+    // Read the pixel
+    const pixels = new Uint8Array(4);
+    renderer.readRenderTargetPixels(this.sampleTarget, 0, 0, 1, 1, pixels);
+
+    return pixels;
+  }
+
+  dispose() {
+    this.quad.geometry.dispose();
+    this.material.dispose();
+    this.sampleTarget.dispose();
+  }
+}
+
+export class TerrainPicker {
+  private depthPickPass: DepthPickPass;
+
+  constructor() {
+    this.depthPickPass = new DepthPickPass();
+  }
+  pick(
+    x: number,
+    y: number,
+    renderer: WebGLRenderer,
+    depthTexture: Texture,
+    camera: PerspectiveCamera,
+  ): Nullable<Vector3> {
+    const logDepthOrDepth = this._sampleDepthAt(x, y, renderer, depthTexture);
+    if (logDepthOrDepth === null || logDepthOrDepth > 0.99) {
+      return null;
+    }
+
+    return this._reconstructWorldPosition(
+      x,
+      y,
+      logDepthOrDepth,
+      renderer,
+      camera,
+    );
+  }
+
+  // Ref: https://github.com/mrdoob/three.js/blob/f38421e7bf5bc37aac7d4ebbe66ad0cc15550c39/src/renderers/shaders/ShaderChunk/packing.glsl.js#L56-L58
+  private _unpackRGBAToDepth(rgba: Uint8Array): number {
+    // Constants
+    const UnpackDownscale = 255 / 256; // 0..1 -> fraction (excluding 1)
+    const PackFactors = [1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0];
+
+    // Calculate unpack factors
+    const UnpackFactors4 = [
+      UnpackDownscale / PackFactors[0],
+      UnpackDownscale / PackFactors[1],
+      UnpackDownscale / PackFactors[2],
+      1.0 / PackFactors[3],
+    ];
+
+    // Calculate dot product
+    return (
+      (rgba[0] / 256.0) * UnpackFactors4[0] +
+      (rgba[1] / 256.0) * UnpackFactors4[1] +
+      (rgba[2] / 256.0) * UnpackFactors4[2] +
+      (rgba[3] / 256.0) * UnpackFactors4[3]
+    );
+  }
+
+  // Helper function to sample depth from depth texture at screen position
+  private _sampleDepthAt(
+    x: number,
+    y: number,
+    renderer: WebGLRenderer,
+    depthTexture: Texture,
+  ): number | null {
+    if (!depthTexture) {
+      return null;
+    }
+
+    const width = renderer.getContext().drawingBufferWidth;
+    const height = renderer.getContext().drawingBufferHeight;
+    const pixelRatio = renderer.getPixelRatio();
+
+    // Clamp coordinates to screen bounds
+    const clampedX = Math.max(
+      0,
+      Math.min(width - 1, Math.floor(x * pixelRatio)),
+    );
+    const clampedY = Math.max(
+      0,
+      Math.min(height - 1, Math.floor(y * pixelRatio)),
+    );
+
+    // Update the depth pick pass with current parameters
+    const samplePos = new Vector2(clampedX / width, 1.0 - clampedY / height); // Flip Y
+    this.depthPickPass.update(depthTexture, samplePos);
+
+    // Render and get pixels
+    const pixels = this.depthPickPass.render(renderer);
+
+    // Unpack RGBA to depth using the same formula as the shader
+    return this._unpackRGBAToDepth(pixels);
+  }
+
+  dispose() {
+    this.depthPickPass.dispose();
+  }
+
+  private _reconstructWorldPosition(
+    x: number,
+    y: number,
+    depth: number,
+    renderer: WebGLRenderer,
+    camera: PerspectiveCamera,
+  ): Vector3 {
+    const near = camera.near;
+    const far = camera.far;
+
+    const width = renderer.getContext().drawingBufferWidth;
+    const height = renderer.getContext().drawingBufferHeight;
+    const pixelRatio = renderer.getPixelRatio();
+
+    // Convert screen coordinates to NDC [-1,1]
+    const screenCoords = new Vector2(
+      ((x * pixelRatio) / width) * 2.0 - 1.0,
+      -(((y * pixelRatio) / height) * 2.0 - 1.0),
+    );
+
+    let clipCoords: Vector4;
+
+    if (renderer.capabilities.logarithmicDepthBuffer) {
+      const logDepthBufFC = 2.0 / Math.log2(far + 1.0);
+
+      const linearDepth = Math.pow(2, depth / (logDepthBufFC * 0.5)) - 1.0;
+      const depthFromCamera = linearDepth + near;
+
+      clipCoords = new Vector4(
+        screenCoords.x,
+        screenCoords.y,
+        depth * 2.0 - 1.0, // Convert depth [0,1] to NDC [-1,1]
+        1.0,
+      );
+
+      const eyeCoordinate = clipCoords
+        .clone()
+        .applyMatrix4(camera.projectionMatrixInverse);
+
+      if (eyeCoordinate.w !== 0) {
+        eyeCoordinate.divideScalar(eyeCoordinate.w);
+      }
+
+      // For logarithmic depth, we need to scale the eye coordinate by the actual depth
+      const eyeZ = -depthFromCamera; // Negative because camera looks down -Z
+      const scaleFactor = eyeZ / eyeCoordinate.z;
+      eyeCoordinate.x *= scaleFactor;
+      eyeCoordinate.y *= scaleFactor;
+      eyeCoordinate.z = eyeZ;
+
+      // Transform to world space
+      return new Vector3(
+        eyeCoordinate.x,
+        eyeCoordinate.y,
+        eyeCoordinate.z,
+      ).applyMatrix4(camera.matrixWorld);
+    } else {
+      // Linear depth buffer case
+      clipCoords = new Vector4(
+        screenCoords.x,
+        screenCoords.y,
+        depth * 2.0 - 1.0,
+        1.0,
+      );
+
+      // Transform to eye coordinates
+      const eyeCoordinate = clipCoords
+        .clone()
+        .applyMatrix4(camera.projectionMatrixInverse);
+      eyeCoordinate.divideScalar(eyeCoordinate.w);
+
+      // Transform to world space
+      return new Vector3(
+        eyeCoordinate.x,
+        eyeCoordinate.y,
+        eyeCoordinate.z,
+      ).applyMatrix4(camera.matrixWorld);
+    }
+  }
+}

package/src/plugins/AttributionPlugin/AttributionPlugin.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+import { AttributionPlugin } from "./index";
+
+// Importing the real @navaramap/core touches WASM/os at module load, which fails
+// in the test environment. AttributionPlugin only needs `Plugin` as a runtime
+// base class (everything else it imports is type-only), so stub the module.
+/* eslint-disable @typescript-eslint/no-extraneous-class */
+vi.mock("@navaramap/core", () => ({
+  Plugin: class Plugin {},
+}));
+/* eslint-enable @typescript-eslint/no-extraneous-class */
+
+type Handler = (arg?: unknown) => void;
+
+function makeLayer(id: string) {
+  const handlers = new Map<string, Set<Handler>>();
+  return {
+    id,
+    on: vi.fn((e: string, cb: Handler) => {
+      const set = handlers.get(e) ?? new Set<Handler>();
+      set.add(cb);
+      handlers.set(e, set);
+    }),
+    off: vi.fn((e: string, cb: Handler) => {
+      handlers.get(e)?.delete(cb);
+    }),
+    emit(e: string, arg: unknown) {
+      handlers.get(e)?.forEach((cb) => cb(arg));
+    },
+  };
+}
+type FakeLayer = ReturnType<typeof makeLayer>;
+
+function makeView(layers: Record<string, FakeLayer> = {}) {
+  const handlers = new Map<string, Set<Handler>>();
+  return {
+    camera: { zoom: 10 },
+    on: vi.fn((e: string, cb: Handler) => {
+      const set = handlers.get(e) ?? new Set<Handler>();
+      set.add(cb);
+      handlers.set(e, set);
+    }),
+    off: vi.fn((e: string, cb: Handler) => {
+      handlers.get(e)?.delete(cb);
+    }),
+    findLayerById: vi.fn((id: string): FakeLayer | undefined => layers[id]),
+  };
+}
+
+const created: AttributionPlugin[] = [];
+async function setup(layers?: Record<string, FakeLayer>) {
+  const view = makeView(layers);
+  const plugin = new AttributionPlugin();
+  created.push(plugin);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await plugin.init(view as any, {} as any);
+  return { plugin, view };
+}
+
+afterEach(() => {
+  created.forEach((p) => p.dispose());
+  created.length = 0;
+  document.body.replaceChildren();
+});
+
+const q = (sel: string): Element | null => document.querySelector(sel);
+const isHidden = (sel: string): boolean =>
+  q(sel)?.hasAttribute("hidden") ?? true;
+
+/** All top-level source names currently rendered in the list. */
+function allTopLevelCredits(): string[] {
+  return Array.from(
+    document.querySelectorAll(
+      ".navara-attr-list > li.navara-attr-item > .navara-attr-name",
+    ),
+  ).map((el) => el.textContent?.trim() ?? "");
+}
+
+/**
+ * User-added top-level credits, i.e. everything except the built-in "Navara"
+ * credit that is always shown first.
+ */
+function topLevelCredits(): string[] {
+  return allTopLevelCredits().filter((name) => name !== "Navara");
+}
+
+/** Nested sub-credit texts (zoom-banded children + dynamic layer credits). */
+function subCredits(): string[] {
+  return Array.from(document.querySelectorAll(".navara-attr-related > li")).map(
+    (el) => el.textContent?.trim() ?? "",
+  );
+}
+
+describe("AttributionPlugin set management", () => {
+  it("renders added sources and drops exact duplicates", async () => {
+    const { plugin } = await setup();
+    plugin.add([{ attribution: "A" }, { attribution: "B" }]);
+    plugin.add([{ attribution: "A" }]); // duplicate — should not double
+    expect(topLevelCredits()).toEqual(["A", "B"]);
+  });
+
+  it("remove drops a structurally-matching entry and ignores unmatched", async () => {
+    const { plugin } = await setup();
+    plugin.add([{ attribution: "A" }, { attribution: "B" }]);
+    plugin.remove([{ attribution: "A" }]);
+    expect(topLevelCredits()).toEqual(["B"]);
+    plugin.remove([{ attribution: "does-not-exist" }]);
+    expect(topLevelCredits()).toEqual(["B"]);
+  });
+
+  it("clear drops user credits but keeps the dock + Navara; hides the logo frame", async () => {
+    const { plugin } = await setup();
+    plugin.add([{ attribution: "A", logo: "/a.png" }]);
+    expect(isHidden(".navara-attr-dock")).toBe(false);
+    expect(
+      document.querySelectorAll(".navara-attr-logoframe img"),
+    ).toHaveLength(1);
+
+    plugin.clear();
+    expect(topLevelCredits()).toEqual([]);
+    // Dock and the built-in Navara credit stay; the logo frame hides (no logos).
+    expect(isHidden(".navara-attr-dock")).toBe(false);
+    expect(allTopLevelCredits()).toEqual(["Navara"]);
+    expect(isHidden(".navara-attr-logoframe")).toBe(true);
+  });
+});
+
+describe("AttributionPlugin built-in Navara credit", () => {
+  it("shows the dock with the Navara credit even with no user credits", async () => {
+    await setup();
+    expect(q(".navara-attr-dock")).not.toBeNull();
+    expect(isHidden(".navara-attr-dock")).toBe(false);
+    expect(allTopLevelCredits()).toEqual(["Navara"]);
+    // No logos declared, so the logo frame stays hidden.
+    expect(isHidden(".navara-attr-logoframe")).toBe(true);
+  });
+
+  it("keeps the dock + Navara visible after all user credits are removed", async () => {
+    const { plugin } = await setup();
+    plugin.add([{ attribution: "A" }]);
+    expect(allTopLevelCredits()).toEqual(["Navara", "A"]);
+    plugin.remove([{ attribution: "A" }]);
+    expect(isHidden(".navara-attr-dock")).toBe(false);
+    expect(allTopLevelCredits()).toEqual(["Navara"]);
+  });
+});
+
+describe("AttributionPlugin popover visibility", () => {
+  it("is collapsed by default and show()/hide() toggle card + aria-expanded", async () => {
+    const { plugin } = await setup();
+    plugin.add([{ attribution: "A" }]);
+    expect(isHidden(".navara-attr-card")).toBe(true);
+    expect(q(".navara-attr-toggle")?.getAttribute("aria-expanded")).toBe(
+      "false",
+    );
+
+    plugin.show();
+    expect(isHidden(".navara-attr-card")).toBe(false);
+    expect(q(".navara-attr-toggle")?.getAttribute("aria-expanded")).toBe(
+      "true",
+    );
+
+    plugin.hide();
+    expect(isHidden(".navara-attr-card")).toBe(true);
+    expect(q(".navara-attr-toggle")?.getAttribute("aria-expanded")).toBe(
+      "false",
+    );
+  });
+
+  it("keeps an open/closed intent set before the DOM exists", async () => {
+    const view = makeView();
+    const plugin = new AttributionPlugin();
+    created.push(plugin);
+    plugin.show(); // recorded before init/DOM — must not be lost
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await plugin.init(view as any, {} as any);
+    plugin.add([{ attribution: "A" }]);
+    expect(isHidden(".navara-attr-card")).toBe(false);
+  });
+});
+
+describe("AttributionPlugin lifecycle", () => {
+  it("dispose removes the DOM and clears content", async () => {
+    const { plugin } = await setup();
+    plugin.add([{ attribution: "A" }]);
+    expect(q(".navara-attr-dock")).not.toBeNull();
+
+    plugin.dispose();
+    expect(q(".navara-attr-dock")).toBeNull();
+    expect(q(".navara-attr-logoframe")).toBeNull();
+  });
+});
+
+describe("AttributionPlugin dynamic layer credits", () => {
+  it("keeps tracked per-feature credits across an unrelated add", async () => {
+    const layer = makeLayer("L");
+    const { plugin } = await setup({ L: layer });
+    plugin.add([{ attribution: "Base", creditLayerId: "L" }]);
+    plugin.show(); // sub-credits only render while the popover is open
+
+    layer.emit("featureCreated", { featureSetId: 1n, credit: "DynCredit" });
+    expect(subCredits()).toContain("DynCredit");
+
+    // Adding an unrelated static source must not retrack (and wipe) layer L.
+    plugin.add([{ attribution: "Extra" }]);
+    expect(topLevelCredits()).toEqual(["Base", "Extra"]);
+    expect(subCredits()).toContain("DynCredit");
+  });
+});

package/src/plugins/AttributionPlugin/attribution.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect } from "vitest";
+
+import {
+  aggregateCredits,
+  appendSanitizedHtml,
+  dedupeAttributionItems,
+  isAttributionHtml,
+  matchesZoom,
+  safeHref,
+  type AttributionChild,
+} from "./attribution";
+
+describe("safeHref", () => {
+  it("allows http / https / mailto and relative URLs", () => {
+    expect(safeHref("https://example.test")).toBe("https://example.test");
+    expect(safeHref("http://example.test")).toBe("http://example.test");
+    expect(safeHref("mailto:a@example.test")).toBe("mailto:a@example.test");
+    expect(safeHref("/path")).toBe("/path");
+    expect(safeHref("#section")).toBe("#section");
+  });
+
+  it("blocks code-executing schemes", () => {
+    expect(safeHref("javascript:alert(1)")).toBeUndefined();
+    expect(
+      safeHref("data:text/html,<script>alert(1)</script>"),
+    ).toBeUndefined();
+    expect(safeHref("vbscript:msgbox(1)")).toBeUndefined();
+  });
+});
+
+describe("aggregateCredits", () => {
+  it("splits on ';', trims, dedups, and orders by frequency then name", () => {
+    expect(aggregateCredits(["Google;Airbus", "Airbus ; Maxar"])).toEqual([
+      "Airbus", // count 2 → first
+      "Google", // count 1, alpha before Maxar
+      "Maxar",
+    ]);
+  });
+
+  it("ignores empty parts and whitespace", () => {
+    expect(aggregateCredits([";; Google ;", ""])).toEqual(["Google"]);
+  });
+
+  it("returns an empty list when there are no credits", () => {
+    expect(aggregateCredits([])).toEqual([]);
+  });
+
+  it("does not split a ';' inside an <a> href (URL preserved verbatim)", () => {
+    expect(
+      aggregateCredits(['<a href="https://x.com?a=1;b=2">Map</a>;Other']),
+    ).toEqual(['<a href="https://x.com?a=1;b=2">Map</a>', "Other"]);
+  });
+
+  it("does not split a ';' that terminates an HTML entity", () => {
+    expect(aggregateCredits(["AT&amp;T;Foo"])).toEqual(["AT&amp;T", "Foo"]);
+  });
+
+  it("splits inside non-anchor tags and drops the tag from the key", () => {
+    // Split into "Google"/"Airbus" (tag dropped), then ordered alphabetically.
+    expect(aggregateCredits(["<b>Google;Airbus</b>"])).toEqual([
+      "Airbus",
+      "Google",
+    ]);
+  });
+});
+
+describe("isAttributionHtml", () => {
+  it("returns true for raw HTML credits", () => {
+    expect(isAttributionHtml({ attributionHtml: "<a>x</a>" })).toBe(true);
+  });
+
+  it("returns false for structured sources", () => {
+    expect(isAttributionHtml({ attribution: "国土地理院" })).toBe(false);
+  });
+});
+
+describe("matchesZoom", () => {
+  const band: AttributionChild = { attribution: "x", minZoom: 14, maxZoom: 18 };
+
+  it("matches everything when the level is undefined", () => {
+    expect(matchesZoom(band, undefined)).toBe(true);
+  });
+
+  it("matches within the band, inclusive of both bounds", () => {
+    expect(matchesZoom(band, 14)).toBe(true);
+    expect(matchesZoom(band, 16)).toBe(true);
+    expect(matchesZoom(band, 18)).toBe(true);
+  });
+
+  it("rejects levels outside the band", () => {
+    expect(matchesZoom(band, 13)).toBe(false);
+    expect(matchesZoom(band, 19)).toBe(false);
+  });
+
+  it("treats a missing bound as unbounded on that side", () => {
+    expect(matchesZoom({ attribution: "x" }, 0)).toBe(true);
+    expect(matchesZoom({ attribution: "x", minZoom: 10 }, 100)).toBe(true);
+    expect(matchesZoom({ attribution: "x", minZoom: 10 }, 9)).toBe(false);
+    expect(matchesZoom({ attribution: "x", maxZoom: 10 }, 0)).toBe(true);
+    expect(matchesZoom({ attribution: "x", maxZoom: 10 }, 11)).toBe(false);
+  });
+});
+
+describe("appendSanitizedHtml", () => {
+  function render(html: string): HTMLElement {
+    const el = document.createElement("div");
+    appendSanitizedHtml(el, html);
+    return el;
+  }
+
+  it("keeps plain text verbatim", () => {
+    expect(render("国土地理院").textContent).toBe("国土地理院");
+  });
+
+  it("keeps <a href> and forces safe target/rel", () => {
+    const el = render('see <a href="https://gsi.go.jp">GSI</a>');
+    const anchor = el.querySelector("a");
+    expect(anchor?.getAttribute("href")).toBe("https://gsi.go.jp");
+    expect(anchor?.target).toBe("_blank");
+    expect(anchor?.rel).toBe("noopener noreferrer");
+    expect(anchor?.textContent).toBe("GSI");
+  });
+
+  it("drops <a> with a javascript: href but keeps its text", () => {
+    const el = render('<a href="javascript:alert(1)">credit</a>');
+    expect(el.querySelector("a")).toBeNull();
+    expect(el.textContent).toBe("credit");
+  });
+
+  it("keeps all nodes even when the input injects a closing tag", () => {
+    const el = render('A</span><a href="https://x.test">B</a>');
+    expect(el.textContent).toContain("A");
+    expect(el.querySelector("a")?.textContent).toBe("B");
+    expect(el.querySelector("a")?.getAttribute("href")).toBe("https://x.test");
+  });
+
+  it("drops <script> elements (keeps only their text, never executes)", () => {
+    const el = render("a<script>alert(1)</script>b");
+    expect(el.querySelector("script")).toBeNull();
+    expect(el.textContent).toBe("aalert(1)b");
+  });
+
+  it("drops <img> entirely, removing event-handler attack surface", () => {
+    const el = render('<img src="x" onerror="alert(1)">');
+    expect(el.querySelector("img")).toBeNull();
+  });
+
+  it("unwraps unknown tags while preserving nested <a>", () => {
+    const el = render('<b>bold <a href="https://x.test">link</a></b>');
+    expect(el.querySelector("b")).toBeNull();
+    expect(el.querySelector("a")?.getAttribute("href")).toBe("https://x.test");
+    expect(el.textContent).toBe("bold link");
+  });
+
+  it("auto-links a bare http(s) URL, preserving the text verbatim", () => {
+    const el = render("see https://lpdaac.usgs.gov/data_access maintained by");
+    const anchor = el.querySelector("a");
+    expect(anchor?.getAttribute("href")).toBe(
+      "https://lpdaac.usgs.gov/data_access",
+    );
+    expect(anchor?.textContent).toBe("https://lpdaac.usgs.gov/data_access");
+    expect(anchor?.rel).toBe("noopener noreferrer");
+    expect(el.textContent).toBe(
+      "see https://lpdaac.usgs.gov/data_access maintained by",
+    );
+  });
+
+  it("keeps trailing punctuation outside an auto-linked URL", () => {
+    const el = render("(https://www.gebco.net) 海上保安庁");
+    expect(el.querySelector("a")?.textContent).toBe("https://www.gebco.net");
+    expect(el.textContent).toBe("(https://www.gebco.net) 海上保安庁");
+  });
+
+  it("does not nest a link when a bare URL sits inside an <a>", () => {
+    const el = render('<a href="https://x.test">https://y.test</a>');
+    expect(el.querySelectorAll("a")).toHaveLength(1);
+    expect(el.querySelector("a")?.getAttribute("href")).toBe("https://x.test");
+    expect(el.querySelector("a")?.textContent).toBe("https://y.test");
+  });
+});
+
+describe("dedupeAttributionItems", () => {
+  it("drops exact-duplicate sources, keeping first-seen order", () => {
+    const overture = {
+      attribution: "© OpenStreetMap contributors, © Overture Maps Foundation",
+      attributionUrl: "https://overturemaps.org",
+    };
+    expect(
+      dedupeAttributionItems([
+        { ...overture },
+        { ...overture },
+        { attribution: "© Overture Maps Foundation" },
+      ]),
+    ).toEqual([overture, { attribution: "© Overture Maps Foundation" }]);
+  });
+
+  it("keeps sources that differ only in creditLayerId", () => {
+    const items = [
+      { attribution: "Overture", creditLayerId: "buildings" },
+      { attribution: "Overture", creditLayerId: "divisions" },
+    ];
+    expect(dedupeAttributionItems(items)).toEqual(items);
+  });
+
+  it("keeps sources that differ only in zoom-banded children", () => {
+    const items = [
+      { attribution: "GSI", children: [{ attribution: "photo", minZoom: 14 }] },
+      { attribution: "GSI", children: [{ attribution: "photo", minZoom: 15 }] },
+    ];
+    expect(dedupeAttributionItems(items)).toEqual(items);
+  });
+
+  it("dedups identical HTML credits but keeps distinct ones", () => {
+    expect(
+      dedupeAttributionItems([
+        { attributionHtml: "<a>x</a>" },
+        { attributionHtml: "<a>x</a>" },
+        { attributionHtml: "<a>y</a>" },
+      ]),
+    ).toEqual([
+      { attributionHtml: "<a>x</a>" },
+      { attributionHtml: "<a>y</a>" },
+    ]);
+  });
+});