Merge branch 'relocate-e2e-tests' into replace-cypress-with-playwright

Make the driver page-lazy (it resolves the running test's page on demand via
an auto fixture) so it can be created a single time at describe scope and
reused across the block's tests, matching the pre-migration ergonomics:

  const { given, get, when, then } = new MaputnikDriver();

instead of pulling `driver` out of a fixture and destructuring it in every
test. Coverage collection and dialog handling move into the auto fixture.

Also inject a bare invalid token ("zzz") in the json-editor parse-error test:
CodeMirror auto-closes brackets/quotes, so " {" no longer reliably breaks the
JSON.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.github/workflows/ci.yml

@@ -96,6 +96,7 @@ jobs:
         with:
           node-version-file: '.nvmrc'
       - run: npm ci
+      - run: npx playwright install --with-deps chromium
       - run: npm run test-unit-ci
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
@@ -163,3 +164,8 @@ jobs:
         run: npm run test-e2e
         env:
           E2E_NO_WEBSERVER: "1"
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
+        with:
+          files: ${{ github.workspace }}/coverage/coverage-final.json
+          verbose: true

AGENTS.md

@@ -36,7 +36,7 @@ Then run the end-to-end tests (Playwright starts the dev server automatically):
 npm run test
 ```
 
-Run the unit tests with Vitest:
+Run the unit and component tests with Vitest:
 
 ```
 npm run test-unit
@@ -45,106 +45,3 @@ npm run test-unit
 ## Pull Requests
 
 - Pull requests should update `CHANGELOG.md` with a short description of the change.
-
-## Testing
-
-### Prefer end-to-end tests
-
-Most of this codebase is React components, and they are only reachable from an
-end-to-end test. E2E coverage is the primary signal.
-
-Reach for a unit test only for pure logic that e2e cannot cheaply reach (parsers,
-sorting, watchers, stores). Before writing one, check whether e2e already covers
-the file — a unit test that duplicates existing e2e coverage adds test code and
-almost no coverage:
-
-```
-npx nyc report --reporter=text --include="src/libs/style.ts"
-```
-
-Do **not** merge the Vitest (v8) and e2e (istanbul) coverage reports locally. They
-produce conflicting statement maps for the same files and the combined percentage
-is meaningless. Codecov merges the two uploads server-side; that is the number to
-trust. Locally, read them separately:
-
-- e2e: `npx playwright test` then `npx nyc report --reporter=text-summary` (reads `.nyc_output/`)
-- unit: `npx vitest run --coverage` (writes `coverage/`)
-
-### E2E layering
-
-Three layers, and the boundaries matter:
-
-- `e2e/playwright-helper.ts` — generic, app-agnostic browser actions. **The only
-  file allowed to import `@playwright/test`** (besides `e2e/utils/fixtures.ts`).
-- `e2e/maputnik-driver.ts` — domain actions (layers, filters, functions, the
-  style). Knows nothing about `page` or Playwright.
-- `e2e/modal-driver.ts` — actions scoped to a modal, exposed as `when.modal.*`.
-
-Specs get a driver at describe scope and assert fluently:
-
-```ts
-describe("layer editor", () => {
-  const { given, get, when, then } = new MaputnikDriver();
-  ...
-  await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({ layers: [{ id, type: "fill" }] });
-});
-```
-
-New UI interactions belong in a driver, not inline in a spec.
-
-### Writing assertions
-
-- `shouldDeepNestedInclude` is a recursive partial match (`toMatchObject`): nested
-  objects are matched as subsets, arrays and primitives must match exactly
-  (including array length).
-- Assert against the whole style, not an extracted slice. Avoid
-  `get.styleFromLocalStorage().then(style => style.layers.find(...))` — it moves
-  test logic into the test. Compare the real object instead.
-- `Query.then()` is lazy and returns a new `Query`, **not** a Promise. `await
-  get.styleFromLocalStorage()` hangs forever. Use `.get()` to await it directly,
-  or pass the Query to `then(...)`.
-
-### One behaviour per test
-
-If a test needs comments narrating "and now this…", it is several tests. Split it,
-and hoist the shared setup into a nested `describe` + `beforeEach`.
-
-### Test ids
-
-Test ids use the `data-wd-key` attribute and are read via `get.elementByTestId`.
-
-The `Input*` components already accept `data-wd-key` and render it on the real
-`<input>`; the `Field*` wrappers forward it through their `{...props}` spread. So
-passing `data-wd-key` to a `Field*` component is usually enough. Do **not** also
-add it to `Block`/`Fieldset` — the id then matches two elements and locators fail
-in strict mode.
-
-Note `InputNumber` renders `<key>-text` and `<key>-range` when `allowRange` is set,
-and `<key>` otherwise.
-
-### Input commit semantics (common source of "the value didn't save")
-
-- `InputString` only fires its `onChange` on **blur** or **Enter**. Typing alone
-  fires `onInput`. A driver that calls `fill()` must then call `blur()`, or the
-  value never reaches the style.
-- `InputNumber` commits on every change; no blur needed.
-- The autocomplete inputs (layer source, add-layer source) are controlled
-  downshift comboboxes. Keystroke typing is dropped/reordered — `{selectall}` then
-  typing `raster` yields `"exampleaster"`. Use `fill()`, which dispatches a single
-  input event, then pick from the filtered menu.
-- CodeMirror auto-closes brackets and quotes, and types over its own closers, so
-  inserting a well-formed JSON fragment stays well-formed. To break JSON on
-  purpose, insert a bare word.
-
-### Fixtures
-
-Style fixtures live in `e2e/fixtures/`. A new one must be registered in two places
-in `maputnik-driver.ts`: the list in `given.setupMockBackedResponses` and the
-`styleFileByKey` map in `when.setStyle`.
-
-### Verify a new test can fail
-
-A test that passes for the wrong reason is worse than no test. After writing one,
-mutate the expected value and confirm it fails. This has caught real mistakes
-(e.g. a driver that never committed its input, so the assertion was matching a
-value written by the *previous* step).

e2e/access-tokens.spec.ts

@@ -1,60 +0,0 @@
-import { test, expect, describe, beforeEach } from "./utils/fixtures";
-import { MaputnikDriver } from "./maputnik-driver";
-import tokens from "../src/config/tokens.json" with { type: "json" };
-
-describe("access tokens", () => {
-  const { given, when } = new MaputnikDriver();
-
-  const tileJson = {
-    tilejson: "2.2.0",
-    tiles: ["https://example.local/{z}/{x}/{y}.pbf"],
-    minzoom: 0,
-    maxzoom: 14,
-  };
-
-  beforeEach(async () => {
-    await given.setupMockBackedResponses();
-  });
-
-  test("uses the thunderforest token for a thunderforest source", async () => {
-    await given.interceptAndMockResponse({
-      method: "GET",
-      url: /tile\.thunderforest\.com\/.*/,
-      response: tileJson,
-      alias: "thunderforest",
-    });
-
-    await when.setStyle("access_tokens");
-
-    const request = await when.waitForResponse("thunderforest");
-    expect(request.url()).toContain(`apikey=${tokens.thunderforest}`);
-  });
-
-  test("uses the locationiq token for a locationiq source", async () => {
-    await given.interceptAndMockResponse({
-      method: "GET",
-      url: /tiles\.locationiq\.com\/.*/,
-      response: tileJson,
-      alias: "locationiq",
-    });
-
-    await when.setStyle("access_tokens");
-
-    const request = await when.waitForResponse("locationiq");
-    expect(request.url()).toContain(`key=${tokens.locationiq}`);
-  });
-
-  test("appends the stadia token as a query parameter", async () => {
-    await given.interceptAndMockResponse({
-      method: "GET",
-      url: /tiles\.stadiamaps\.com\/.*/,
-      response: tileJson,
-      alias: "stadia",
-    });
-
-    await when.setStyle("access_tokens");
-
-    const request = await when.waitForResponse("stadia");
-    expect(request.url()).toContain("?api_key=stadia-test-token");
-  });
-});

e2e/accessibility.spec.ts

@@ -1,16 +1,16 @@
-import { test, describe, beforeEach } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("accessibility", () => {
+test.describe("accessibility", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
   });
 
-  describe("skip links", () => {
+  test.describe("skip links", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.setStyle("layer");
     });
 

e2e/code-editor.spec.ts

@@ -1,10 +1,10 @@
-import { beforeEach, describe, test } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("code editor", () => {
+test.describe("code editor", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
   });

e2e/coverage.ts

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Page } from "@playwright/test";
+
+const OUTPUT_DIR = path.resolve(process.cwd(), ".nyc_output");
+
+/**
+ * Reads the istanbul coverage object (injected by vite-plugin-istanbul) from the
+ * given page. Returns `null` when the page has not been instrumented.
+ */
+export async function readCoverage(page: Page): Promise<unknown | null> {
+  try {
+    return await page.evaluate(() => (window as unknown as { __coverage__?: unknown }).__coverage__ ?? null);
+  } catch {
+    // Page might be navigating/closed.
+    return null;
+  }
+}
+
+/**
+ * Persists a coverage chunk to `.nyc_output` so that `nyc report` can merge it.
+ * istanbul-lib-coverage (used by nyc) sums the hit counts across every file it
+ * finds, so writing one file per chunk is enough to accumulate coverage across
+ * navigations and tests.
+ */
+export function writeCoverage(coverage: unknown, id: string): void {
+  if (!coverage) return;
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  fs.writeFileSync(path.join(OUTPUT_DIR, `playwright-${id}.json`), JSON.stringify(coverage));
+}

e2e/fixtures.ts

@@ -0,0 +1,46 @@
+import { test as base, expect, type Page } from "@playwright/test";
+import { readCoverage, writeCoverage } from "./coverage";
+
+let activePage: Page | undefined;
+const coverageChunks: unknown[] = [];
+
+/** The page for the currently running test. Throws if used outside a test. */
+export function currentPage(): Page {
+  if (!activePage) {
+    throw new Error("No active page: a MaputnikDriver method was called outside of a running test.");
+  }
+  return activePage;
+}
+
+/** Records a coverage snapshot (called before navigations, which reset __coverage__). */
+export function recordCoverageChunk(chunk: unknown): void {
+  if (chunk) coverageChunks.push(chunk);
+}
+
+/**
+ * Auto fixture that binds the current test's page for the (page-lazy)
+ * MaputnikDriver, auto-accepts confirm dialogs, and writes the istanbul
+ * coverage collected during the test to `.nyc_output`.
+ */
+export const test = base.extend<{ maputnikPage: void }>({
+  maputnikPage: [
+    async ({ page }, use, testInfo) => {
+      activePage = page;
+      coverageChunks.length = 0;
+      // Accept confirm dialogs (e.g. the "replace current style" prompt). These
+      // are dismissed by default, which would cancel loading a style via URL.
+      page.on("dialog", (dialog) => dialog.accept().catch(() => undefined));
+
+      await use();
+
+      const finalCoverage = await readCoverage(page);
+      if (finalCoverage) coverageChunks.push(finalCoverage);
+      coverageChunks.forEach((chunk, index) => writeCoverage(chunk, `${testInfo.testId}-${index}`));
+      coverageChunks.length = 0;
+      activePage = undefined;
+    },
+    { auto: true },
+  ],
+});
+
+export { expect };

e2e/fixtures/access-token-style.json

@@ -1,22 +0,0 @@
-{
-  "version": 8,
-  "name": "Access token style",
-  "metadata": {
-    "maputnik:stadia_access_token": "stadia-test-token"
-  },
-  "sources": {
-    "thunderforest_transport": {
-      "type": "vector",
-      "url": "https://tile.thunderforest.com/thunderforest.transport-v2.json?apikey={key}"
-    },
-    "stadia_outdoors": {
-      "type": "vector",
-      "url": "https://tiles.stadiamaps.com/data/openmaptiles.json"
-    },
-    "locationiq": {
-      "type": "vector",
-      "url": "https://tiles.locationiq.com/v3/pbf/tiles.json?key={key}"
-    }
-  },
-  "layers": []
-}

e2e/history.spec.ts

@@ -1,13 +1,13 @@
-import { beforeEach, describe, test } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("history", () => {
+test.describe("history", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
   const undoKeyCombo = process.platform === "darwin" ? "{meta}z" : "{ctrl}z";
   const redoKeyCombo = process.platform === "darwin" ? "{meta}{shift}z" : "{ctrl}y";
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
   });

e2e/i18n.spec.ts

@@ -1,15 +1,15 @@
-import { beforeEach, describe, test } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("i18n", () => {
+test.describe("i18n", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
   });
 
-  describe("language detector", () => {
+  test.describe("language detector", () => {
     test("English", async () => {
       await when.visit("?lng=en");
       await then(get.elementByTestId("maputnik-lang-select")).shouldHaveValue("en");
@@ -21,8 +21,8 @@ describe("i18n", () => {
     });
   });
 
-  describe("language switcher", () => {
+  test.describe("language switcher", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.setStyle("layer");
     });
 

e2e/keyboard.spec.ts

@@ -1,16 +1,16 @@
-import { beforeEach, describe, test } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("keyboard", () => {
+test.describe("keyboard", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
   });
 
-  describe("shortcuts", () => {
+  test.describe("shortcuts", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await given.setupMockBackedResponses();
       await when.setStyle("");
     });

e2e/layer-editor.spec.ts

@@ -1,11 +1,11 @@
 import { v1 as uuid } from "uuid";
-import { beforeEach, describe, test } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("layer editor", () => {
+test.describe("layer editor", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
     await when.modal.open();
@@ -25,18 +25,7 @@ describe("layer editor", () => {
     return id;
   }
 
-  test("expand/collapse", async () => {
+  test.skip("expand/collapse", () => {});
-    const bgId = await createBackground();
-    await when.click("layer-list-item:background:" + bgId);
-
-    await then(get.elementByTestId("layer-editor.layer-id.input")).shouldBeVisible();
-
-    await when.toggleGroupInLayerEditor("Layer");
-    await then(get.elementByTestId("layer-editor.layer-id.input")).shouldNotBeVisible();
-
-    await when.toggleGroupInLayerEditor("Layer");
-    await then(get.elementByTestId("layer-editor.layer-id.input")).shouldBeVisible();
-  });
 
   test("id", async () => {
     const bgId = await createBackground();
@@ -52,7 +41,7 @@ describe("layer editor", () => {
     });
   });
 
-  describe("source", () => {
+  test.describe("source", () => {
     test("should show error when the source is invalid", async () => {
       await when.modal.fillLayers({
         type: "circle",
@@ -64,10 +53,10 @@ describe("layer editor", () => {
     });
   });
 
-  describe("min-zoom", () => {
+  test.describe("min-zoom", () => {
     let bgId: string;
 
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       bgId = await createBackground();
       await when.click("layer-list-item:background:" + bgId);
       await when.setValue("min-zoom.input-text", "1");
@@ -87,20 +76,12 @@ describe("layer editor", () => {
         layers: [{ id: "background:" + bgId, type: "background", minzoom: 1 }],
       });
     });
-
-    test("the range slider adjusts min-zoom", async () => {
-      await when.focus("min-zoom.input-range");
-      await when.typeKeys("{rightarrow}");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id: "background:" + bgId, type: "background", minzoom: 2 }],
-      });
-    });
   });
 
-  describe("max-zoom", () => {
+  test.describe("max-zoom", () => {
     let bgId: string;
 
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       bgId = await createBackground();
       await when.click("layer-list-item:background:" + bgId);
       await when.setValue("max-zoom.input-text", "1");
@@ -114,11 +95,11 @@ describe("layer editor", () => {
     });
   });
 
-  describe("comments", () => {
+  test.describe("comments", () => {
     let bgId: string;
     const comment = "42";
 
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       bgId = await createBackground();
       await when.click("layer-list-item:background:" + bgId);
       await when.setValue("layer-comment.input", comment);
@@ -137,8 +118,8 @@ describe("layer editor", () => {
       });
     });
 
-    describe("when unsetting", () => {
+    test.describe("when unsetting", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         await when.clear("layer-comment.input");
         await when.click("min-zoom.input-text");
       });
@@ -151,9 +132,9 @@ describe("layer editor", () => {
     });
   });
 
-  describe("color", () => {
+  test.describe("color", () => {
     let bgId: string;
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       bgId = await createBackground();
       await when.click("layer-list-item:background:" + bgId);
       await when.click("spec-field:background-color");
@@ -164,18 +145,11 @@ describe("layer editor", () => {
         layers: [{ id: "background:" + bgId, type: "background" }],
       });
     });
-
-    test("typing a hex value updates the paint color", async () => {
-      await when.setColorValue("background-color", "#ff0000");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id: "background:" + bgId, type: "background", paint: { "background-color": "#ff0000" } }],
-      });
-    });
   });
 
-  describe("opacity", () => {
+  test.describe("opacity", () => {
     let bgId: string;
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       bgId = await createBackground();
       await when.click("layer-list-item:background:" + bgId);
       await when.type("spec-field-input:background-opacity", "0.");
@@ -191,343 +165,33 @@ describe("layer editor", () => {
     });
   });
 
-  describe("filter", () => {
+  test.describe("filter", () => {
-    let id: string;
+    test.skip("expand/collapse", () => {});
-
+    test.skip("compound filter", () => {});
-    beforeEach(async () => {
-      id = await when.modal.fillLayers({ type: "fill", layer: "example" });
-      await when.addFilter();
   });
 
-    test("should add a filter item", async () => {
+  test.describe("layout", () => {
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, type: "fill", source: "example", filter: ["all", ["==", "name", ""]] }],
-      });
-    });
-
-    test("should change the filter operator", async () => {
-      await when.selectFilterOperator("!=");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, filter: ["all", ["!=", "name", ""]] }],
-      });
-    });
-
-    test("should extend the compound filter with a second item", async () => {
-      await when.addFilter();
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, filter: ["all", ["==", "name", ""], ["==", "name", ""]] }],
-      });
-    });
-
-    test("should change the combining operator", async () => {
-      await when.selectFilterCombiningOperator("any");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, filter: ["any", ["==", "name", ""]] }],
-      });
-    });
-
-    test("should delete a filter item", async () => {
-      await when.addFilter();
-      await when.deleteFilterItem();
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, filter: ["all", ["==", "name", ""]] }],
-      });
-    });
-
-    describe("when converted to an expression", () => {
-      beforeEach(async () => {
-        await when.convertFilterToExpression();
-      });
-
-      test("should migrate the filter to an expression", async () => {
-        // A single-item "all" collapses to the bare comparison when migrated.
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, filter: ["==", ["get", "name"], ""] }],
-        });
-      });
-
-      test("should restore the default filter when the expression is deleted", async () => {
-        await when.deleteFilterExpression();
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, filter: ["all"] }],
-        });
-      });
-    });
-  });
-
-  describe("functions", () => {
-    let id: string;
-
-    describe("zoom function", () => {
-      beforeEach(async () => {
-        id = await when.modal.fillLayers({ type: "circle", layer: "example" });
-        await when.makeZoomFunction("circle-radius");
-      });
-
-      test("should convert the property to a zoom function", async () => {
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [
-            { id, type: "circle", source: "example", paint: { "circle-radius": { stops: [[6, 5], [10, 5]] } } },
-          ],
-        });
-      });
-
-      test("should add a stop", async () => {
-        await when.addFunctionStop("circle-radius");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-radius": { stops: [[6, 5], [10, 5], [11, 5]] } } }],
-        });
-      });
-
-      test("should delete the first stop", async () => {
-        // A function needs more than two stops, otherwise deleting one collapses
-        // it back into a plain value.
-        await when.addFunctionStop("circle-radius");
-        await when.deleteFunctionStop("circle-radius");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-radius": { stops: [[10, 5], [11, 5]] } } }],
-        });
-      });
-
-      test("should set the base", async () => {
-        await when.setFunctionBase("circle-radius", "2");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-radius": { base: 2, stops: [[6, 5], [10, 5]] } } }],
-        });
-      });
-
-      test("should edit the zoom of a stop", async () => {
-        await when.setFunctionStopValue("circle-radius", "Zoom", 0, "3");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-radius": { stops: [[3, 5], [10, 5]] } } }],
-        });
-      });
-
-      test("should edit the output value of a stop", async () => {
-        await when.setFunctionStopValue("circle-radius", "Output value", 0, "9");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-radius": { stops: [[6, 9], [10, 5]] } } }],
-        });
-      });
-
-      test("should convert to an expression", async () => {
-        await when.makeExpression("circle-radius");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-radius": ["interpolate", ["linear"], ["zoom"], 6, 5, 10, 5] } }],
-        });
-      });
-
-      describe("when converted to a data function", () => {
-        beforeEach(async () => {
-          // Any non-interpolate scale turns the zoom function into a data one.
-          await when.selectFunctionType("circle-radius", "categorical");
-        });
-
-        test("should carry the stops over as zoom/value pairs", async () => {
-          await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-            layers: [
-              {
-                id,
-                paint: {
-                  "circle-radius": {
-                    property: "",
-                    type: "exponential",
-                    stops: [[{ zoom: 6, value: 0 }, 5], [{ zoom: 10, value: 0 }, 5]],
-                  },
-                },
-              },
-            ],
-          });
-        });
-
-        test("should convert back to a zoom function", async () => {
-          await when.selectFunctionType("circle-radius", "interpolate");
-          await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-            layers: [{ id, paint: { "circle-radius": { stops: [[6, 5], [10, 5]] } } }],
-          });
-        });
-      });
-    });
-
-    describe("data function", () => {
-      beforeEach(async () => {
-        id = await when.modal.fillLayers({ type: "circle", layer: "example" });
-        await when.setValue("spec-field-input:circle-blur", "1");
-        await when.makeDataFunction("circle-blur");
-      });
-
-      test("should convert the property to a data function", async () => {
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [
-            {
-              id,
-              type: "circle",
-              source: "example",
-              paint: {
-                "circle-blur": {
-                  property: "",
-                  type: "exponential",
-                  stops: [[{ zoom: 6, value: 0 }, 1], [{ zoom: 10, value: 0 }, 1]],
-                },
-              },
-            },
-          ],
-        });
-      });
-
-      test("should add a stop", async () => {
-        await when.addFunctionStop("circle-blur");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [
-            {
-              id,
-              paint: {
-                "circle-blur": {
-                  stops: [[{ zoom: 6, value: 0 }, 1], [{ zoom: 10, value: 0 }, 1], [{ zoom: 11, value: 0 }, 1]],
-                },
-              },
-            },
-          ],
-        });
-      });
-
-      test("should delete the first stop", async () => {
-        await when.addFunctionStop("circle-blur");
-        await when.deleteFunctionStop("circle-blur");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [
-            {
-              id,
-              paint: {
-                "circle-blur": {
-                  stops: [[{ zoom: 10, value: 0 }, 1], [{ zoom: 11, value: 0 }, 1]],
-                },
-              },
-            },
-          ],
-        });
-      });
-
-      test("should set the property", async () => {
-        await when.setFunctionProperty("circle-blur", "myprop");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-blur": { property: "myprop" } } }],
-        });
-      });
-
-      test("should set the default", async () => {
-        await when.setFunctionDefault("circle-blur", "0.5");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-blur": { default: 0.5 } } }],
-        });
-      });
-
-      test("should edit the input value of a stop", async () => {
-        await when.setFunctionStopValue("circle-blur", "Input value", 0, "7");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [
-            {
-              id,
-              paint: {
-                "circle-blur": {
-                  stops: [[{ zoom: 6, value: 7 }, 1], [{ zoom: 10, value: 0 }, 1]],
-                },
-              },
-            },
-          ],
-        });
-      });
-
-      test("should change the function type", async () => {
-        await when.selectFunctionType("circle-blur", "categorical");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-blur": { type: "categorical" } } }],
-        });
-      });
-    });
-
-    describe("expression", () => {
-      beforeEach(async () => {
-        id = await when.modal.fillLayers({ type: "circle", layer: "example" });
-        await when.setValue("spec-field-input:circle-blur", "1");
-        await when.makeExpression("circle-blur");
-      });
-
-      test("should wrap the property value in a literal expression", async () => {
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-blur": ["literal", 1] } }],
-        });
-      });
-
-      test("should restore the plain value when reverted", async () => {
-        await when.undoExpression("circle-blur");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-blur": 1 } }],
-        });
-      });
-
-      test("should fall back to the spec default when deleted", async () => {
-        await when.deleteExpression("circle-blur");
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-          layers: [{ id, paint: { "circle-blur": 0 } }],
-        });
-      });
-    });
-  });
-
-  describe("layout", () => {
     test("text-font", async () => {
       await when.setStyle("font");
       await when.collapseGroupInLayerEditor();
       await when.collapseGroupInLayerEditor(1);
       await when.collapseGroupInLayerEditor(2);
-      await when.clickWithin("spec-field:text-font", ".maputnik-autocomplete input");
+      await when.doWithin("spec-field:text-font", async () => {
+        await get.element(".maputnik-autocomplete input").first().click();
+      });
       await then(get.element(".maputnik-autocomplete-menu-item")).shouldBeVisible();
       await then(get.element(".maputnik-autocomplete-menu-item")).shouldHaveLength(3);
     });
   });
 
-  describe("paint", () => {
+  test.describe("paint", () => {
-    let id: string;
+    test.skip("expand/collapse", () => {});
-
+    test.skip("color", () => {});
-    beforeEach(async () => {
+    test.skip("pattern", () => {});
-      id = await when.modal.fillLayers({ type: "fill", layer: "example" });
+    test.skip("opacity", () => {});
   });
 
-    test("expand/collapse", async () => {
+  test.describe("json-editor", () => {
-      await then(get.elementByTestId("spec-field:fill-color")).shouldBeVisible();
-
-      await when.toggleGroupInLayerEditor("Paint properties");
-      await then(get.elementByTestId("spec-field:fill-color")).shouldNotBeVisible();
-
-      await when.toggleGroupInLayerEditor("Paint properties");
-      await then(get.elementByTestId("spec-field:fill-color")).shouldBeVisible();
-    });
-
-    test("color", async () => {
-      await when.setColorValue("fill-color", "#ff0000");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, type: "fill", source: "example", paint: { "fill-color": "#ff0000" } }],
-      });
-    });
-
-    test("pattern", async () => {
-      await when.setStringValue("fill-pattern", "some-pattern");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, type: "fill", source: "example", paint: { "fill-pattern": "some-pattern" } }],
-      });
-    });
-
-    test("opacity", async () => {
-      await when.setValue("spec-field-input:fill-opacity", "0.4");
-      await when.click("layer-editor.layer-id");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, type: "fill", source: "example", paint: { "fill-opacity": 0.4 } }],
-      });
-    });
-  });
-
-  describe("json-editor", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({
         type: "circle",
@@ -538,34 +202,15 @@ describe("layer editor", () => {
         layers: [{ id, type: "circle", source: "example" }],
       });
 
-      await when.clickByText('"source"');
+      const sourceText = get.elementByText('"source"');
+      await sourceText.click();
       await when.typeKeys('"');
 
       await then(get.element(".cm-lint-marker-error")).shouldExist();
     });
 
-    test("expand/collapse", async () => {
+    test.skip("expand/collapse", () => {});
-      const bgId = await createBackground();
+    test.skip("modify", () => {});
-      await when.click("layer-list-item:background:" + bgId);
-
-      await then(get.element(".cm-content")).shouldBeVisible();
-
-      await when.toggleGroupInLayerEditor("JSON Editor");
-      await then(get.element(".cm-content")).shouldNotBeVisible();
-
-      await when.toggleGroupInLayerEditor("JSON Editor");
-      await then(get.element(".cm-content")).shouldBeVisible();
-    });
-
-    test("modify", async () => {
-      const bgId = await createBackground();
-      await when.click("layer-list-item:background:" + bgId);
-
-      await when.appendToJsonEditorLine('"background"', ',\n"minzoom": 5');
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id: "background:" + bgId, type: "background", minzoom: 5 }],
-      });
-    });
 
     test("parse error", async () => {
       const bgId = await createBackground();
@@ -582,7 +227,7 @@ describe("layer editor", () => {
     });
   });
 
-  describe("sticky header", () => {
+  test.describe("sticky header", () => {
     test("should keep layer header visible when scrolling properties", async () => {
       // Setup: Create a layer with many properties (e.g. symbol layer)
       await when.modal.fillLayers({
@@ -594,7 +239,9 @@ describe("layer editor", () => {
       const header = get.elementByTestId("layer-editor.header");
       await then(header).shouldBeVisible();
 
-      await when.scrollToBottom(get.element(".maputnik-scroll-container"));
+      await get
+        .element(".maputnik-scroll-container")
+        .evaluate((el) => el.scrollTo(0, el.scrollHeight));
       await when.wait(200);
 
       await then(header).shouldBeVisible();

e2e/layers-list.spec.ts

@@ -1,18 +1,18 @@
-import { beforeEach, describe, test } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("layers list", () => {
+test.describe("layers list", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
     await when.modal.open();
   });
 
-  describe("ops", () => {
+  test.describe("ops", () => {
     let id: string;
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       id = await when.modal.fillLayers({ type: "background" });
     });
 
@@ -22,8 +22,8 @@ describe("layers list", () => {
       });
     });
 
-    describe("when clicking delete", () => {
+    test.describe("when clicking delete", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         await when.click("layer-list-item:" + id + ":delete");
       });
       test("should empty layers in local storage", async () => {
@@ -33,8 +33,8 @@ describe("layers list", () => {
       });
     });
 
-    describe("when clicking duplicate", () => {
+    test.describe("when clicking duplicate", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         await when.click("layer-list-item:" + id + ":copy");
       });
       test("should add copy layer in local storage", async () => {
@@ -47,8 +47,8 @@ describe("layers list", () => {
       });
     });
 
-    describe("when clicking hide", () => {
+    test.describe("when clicking hide", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         await when.click("layer-list-item:" + id + ":toggle-visibility");
       });
 
@@ -58,8 +58,8 @@ describe("layers list", () => {
         });
       });
 
-      describe("when clicking show", () => {
+      test.describe("when clicking show", () => {
-        beforeEach(async () => {
+        test.beforeEach(async () => {
           await when.click("layer-list-item:" + id + ":toggle-visibility");
         });
 
@@ -70,9 +70,9 @@ describe("layers list", () => {
         });
       });
 
-      describe("when selecting a layer", () => {
+      test.describe("when selecting a layer", () => {
         let secondId: string;
-        beforeEach(async () => {
+        test.beforeEach(async () => {
           await when.modal.open();
           secondId = await when.modal.fillLayers({
             id: "second-layer",
@@ -89,7 +89,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("background", () => {
+  test.describe("background", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "background" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -97,18 +97,10 @@ describe("layers list", () => {
       });
     });
 
-    test("modify", async () => {
+    test.skip("modify", () => {});
-      const id = await when.modal.fillLayers({ type: "background" });
-      await when.click("layer-list-item:" + id);
-      await when.setValue("spec-field-input:background-opacity", "0.4");
-      await when.click("layer-editor.layer-id");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, type: "background", paint: { "background-opacity": 0.4 } }],
-      });
-    });
   });
 
-  describe("fill", () => {
+  test.describe("fill", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "fill", layer: "example" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -116,16 +108,11 @@ describe("layers list", () => {
       });
     });
 
-    test("change source", async () => {
+    // TODO: Change source
-      const id = await when.modal.fillLayers({ type: "fill", layer: "example" });
+    test.skip("change source", () => {});
-      await when.changeLayerSource("raster");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        layers: [{ id, type: "fill", source: "raster" }],
-      });
-    });
   });
 
-  describe("line", () => {
+  test.describe("line", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "line", layer: "example" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -134,6 +121,7 @@ describe("layers list", () => {
     });
 
     test("groups", async () => {
+      await when.modal.open();
       const id1 = await when.modal.fillLayers({ id: "aa", type: "line", layer: "example" });
 
       await when.modal.open();
@@ -163,7 +151,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("symbol", () => {
+  test.describe("symbol", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "symbol", layer: "example" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -201,7 +189,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("raster", () => {
+  test.describe("raster", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "raster", layer: "raster" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -210,7 +198,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("circle", () => {
+  test.describe("circle", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "circle", layer: "example" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -219,7 +207,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("fill extrusion", () => {
+  test.describe("fill extrusion", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "fill-extrusion", layer: "example" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -228,7 +216,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("hillshade", () => {
+  test.describe("hillshade", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "hillshade", layer: "example" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -279,7 +267,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("color-relief", () => {
+  test.describe("color-relief", () => {
     test("add", async () => {
       const id = await when.modal.fillLayers({ type: "color-relief", layer: "example" });
       await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
@@ -297,7 +285,7 @@ describe("layers list", () => {
     });
   });
 
-  describe("groups", () => {
+  test.describe("groups", () => {
     test("simple", async () => {
       await when.setStyle("geojson");
 
@@ -320,8 +308,9 @@ describe("layers list", () => {
     });
   });
 
-  describe("drag and drop", () => {
+  test.describe("drag and drop", () => {
     test("move layer should update local storage", async () => {
+      await when.modal.open();
       const firstId = await when.modal.fillLayers({ id: "a", type: "background" });
       await when.modal.open();
       const secondId = await when.modal.fillLayers({ id: "b", type: "background" });
@@ -340,12 +329,10 @@ describe("layers list", () => {
     });
   });
 
-  describe("sticky header", () => {
+  test.describe("sticky header", () => {
     test("should keep header visible when scrolling layer list", async () => {
       // Setup: Create multiple layers to enable scrolling
-      // The modal is already open (beforeEach) for the first layer.
+      for (let i = 0; i < 20; i++) {
-      await when.modal.fillLayers({ id: "layer-0", type: "background" });
-      for (let i = 1; i < 20; i++) {
         await when.modal.open();
         await when.modal.fillLayers({ id: `layer-${i}`, type: "background" });
       }
@@ -355,7 +342,7 @@ describe("layers list", () => {
       await then(header).shouldBeVisible();
 
       // Scroll the layer list container
-      await when.scrollToBottom(get.elementByTestId("layer-list"));
+      await get.elementByTestId("layer-list").evaluate((el) => el.scrollTo(0, el.scrollHeight));
       await when.wait(200);
       await then(header).shouldBeVisible();
       await then(get.elementByTestId("layer-list:add-layer")).shouldBeVisible();

e2e/map.spec.ts

@@ -1,15 +1,15 @@
-import { beforeEach, describe, test } from "./utils/fixtures";
+import { test } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 
-describe("map", () => {
+test.describe("map", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
     await when.setStyle("both");
   });
 
-  describe("zoom level", () => {
+  test.describe("zoom level", () => {
     test("via url", async () => {
       const zoomLevel = 12.37;
       await when.setStyle("geojson", zoomLevel);
@@ -38,14 +38,14 @@ describe("map", () => {
     });
   });
 
-  describe("search", () => {
+  test.describe("search", () => {
     test("should exist", async () => {
       await then(get.searchControl()).shouldBeVisible();
     });
   });
 
-  describe("popup", () => {
+  test.describe("popup", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.setStyle("rectangles");
       await then(get.locationHash()).shouldExist();
     });

e2e/maputnik-driver.ts

@@ -1,31 +1,270 @@
-import { PlaywrightHelper } from "./playwright-helper";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect, type Locator, type Page, type Request } from "@playwright/test";
+import { readCoverage } from "./coverage";
+import { currentPage, recordCoverageChunk } from "./fixtures";
 import { ModalDriver } from "./modal-driver";
 
 const baseUrl = "http://localhost:8888/";
+const FIXTURES_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures");
+const DATA_ATTRIBUTE = "data-wd-key";
+
 const isMac = process.platform === "darwin";
 
-/**
+function testIdSelector(testId: string): string {
- * The maputnik-specific driver. It builds on the generic {@link PlaywrightHelper}
+  return `[${DATA_ATTRIBUTE}="${testId}"]`;
- * — spreading its `given`/`when`/`get` primitives and adding domain concepts
+}
- * (loading a style, the add-layer modal, the JSON editor, …). All Playwright
- * access goes through the helper; the driver never touches `page` directly.
- */
-export class MaputnikDriver {
-  private readonly helper = new PlaywrightHelper();
-  private readonly modalDriver = new ModalDriver();
 
-  then = this.helper.then;
+export function readFixture(name: string): any {
+  const contents = fs.readFileSync(path.join(FIXTURES_DIR, name), "utf-8");
+  return JSON.parse(contents);
+}
 
-  /** Reads the maputnik style currently persisted in localStorage. */
+/** Reads the maputnik style currently persisted in localStorage. */
-  private async readStoredStyle(): Promise<any> {
+function styleFromLocalStorage(page: Page): Promise<any> {
-    const styleId = await this.helper.get.localStorageItem("maputnik:latest_style");
+  return page.evaluate(() => {
-    const styleItem = await this.helper.get.localStorageItem(`maputnik:style:${styleId}`);
+    const styleId = window.localStorage.getItem("maputnik:latest_style");
+    const styleItemKey = `maputnik:style:${styleId}`;
+    const styleItem = window.localStorage.getItem(styleItemKey);
     if (!styleItem) throw new Error("Could not get styleItem from localStorage");
     return JSON.parse(styleItem);
+  });
+}
+
+async function retry(assertion: () => Promise<void> | void, timeout = 10000, interval = 100): Promise<void> {
+  const start = Date.now();
+  let lastError: unknown;
+  for (;;) {
+    try {
+      await assertion();
+      return;
+    } catch (error) {
+      lastError = error;
+      if (Date.now() - start > timeout) throw lastError;
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  }
+}
+
+/**
+ * A lazily-evaluated value (e.g. the style in localStorage). Assertions on a
+ * Query re-read the value until they pass, mirroring Cypress' retry-ability.
+ */
+export class Query<T> {
+  readonly __maputnikQuery = true as const;
+  constructor(private readonly getter: () => Promise<T>) {}
+
+  get(): Promise<T> {
+    return this.getter();
   }
 
+  then<U>(mapper: (value: T) => U | Promise<U>): Query<U> {
+    return new Query<U>(async () => mapper(await this.getter()));
+  }
+}
+
+function isQuery(target: unknown): target is Query<unknown> {
+  return typeof target === "object" && target !== null && (target as Query<unknown>).__maputnikQuery === true;
+}
+
+function isLocator(target: unknown): target is Locator {
+  return (
+    typeof target === "object" &&
+    target !== null &&
+    typeof (target as Locator).count === "function" &&
+    typeof (target as Locator).boundingBox === "function"
+  );
+}
+
+/** Asserts that every top-level key in `expected` deep-equals its counterpart in `actual`. */
+function assertDeepNestedInclude(actual: any, expected: Record<string, unknown>): void {
+  for (const key of Object.keys(expected)) {
+    expect(actual?.[key], `property "${key}"`).toEqual(expected[key]);
+  }
+}
+
+export class MaputnikAssertable<T> {
+  constructor(private readonly target: T, private readonly page?: Page) {}
+
+  private locator(): Locator {
+    if (!isLocator(this.target)) throw new Error("Expected a Locator target for this assertion");
+    return this.target;
+  }
+
+  private async assertValue(assertion: (value: any) => void): Promise<void> {
+    const target = this.target;
+    if (isQuery(target)) {
+      await retry(async () => assertion(await target.get()));
+    } else {
+      assertion(await (target as any));
+    }
+  }
+
+  // Element assertions (auto-retrying via Playwright web-first assertions).
+  shouldBeVisible = () => expect(this.locator().first()).toBeVisible();
+  // Some testids resolve to many elements that are always rendered but hidden
+  // (e.g. per-field documentation panels); "not visible" means none is visible.
+  shouldNotBeVisible = () => expect(this.locator().filter({ visible: true })).toHaveCount(0);
+  shouldExist = async () => {
+    if (isLocator(this.target)) {
+      await expect(this.locator().first()).toBeAttached();
+    } else {
+      await this.assertValue((value) => expect(value).toBeTruthy());
+    }
+  };
+  shouldNotExist = () => expect(this.locator()).toHaveCount(0);
+  shouldBeFocused = () => expect(this.locator().first()).toBeFocused();
+  shouldNotBeFocused = () => expect(this.locator().first()).not.toBeFocused();
+  shouldHaveValue = (value: string) => expect(this.locator().first()).toHaveValue(value);
+  shouldContainText = async (text: string) => {
+    const locator = this.locator();
+    // Prefer the visible element when a testid resolves to several (only the
+    // open documentation panel is visible; the rest are hidden in the DOM).
+    const target = (await locator.count()) > 1 ? locator.filter({ visible: true }).first() : locator.first();
+    await expect(target).toContainText(text);
+  };
+  shouldHaveText = (text: string) => expect(this.locator().first()).toHaveText(text);
+  shouldHaveLength = (length: number) => expect(this.locator()).toHaveCount(length);
+  shouldHaveCss = (property: string, value: string) => expect(this.locator().first()).toHaveCSS(property, value);
+
+  // Value assertions (auto-retrying for Query targets).
+  shouldEqual = (value: any) => this.assertValue((actual) => expect(actual).toBe(value));
+
+  shouldInclude = (value: any) =>
+    this.assertValue((actual) => {
+      if (typeof value === "object" && value !== null) {
+        expect(actual).toMatchObject(value);
+      } else {
+        expect(String(actual)).toContain(String(value));
+      }
+    });
+
+  shouldDeepNestedInclude = (value: Record<string, unknown>) =>
+    this.assertValue((actual) => assertDeepNestedInclude(actual, value));
+
+  /**
+   * Asserts that the object under test (a fixture / response body) contains every
+   * top-level property of the style currently stored in localStorage.
+   */
+  shouldEqualToStoredStyle = async () => {
+    if (!this.page) throw new Error("shouldEqualToStoredStyle requires a page-bound assertable");
+    const expected = await (this.target as any);
+    await retry(async () => {
+      const stored = await styleFromLocalStorage(this.page!);
+      assertDeepNestedInclude(expected, stored);
+    });
+  };
+}
+
+/**
+ * Translates a Cypress-style key sequence (e.g. "{meta}z", "{esc}", "0.") into
+ * Playwright keyboard actions on the currently focused element.
+ */
+async function typeSequence(page: Page, text: string): Promise<void> {
+  const tokens = text.match(/\{[^}]+\}|[^{]+/g) ?? [];
+  const modifierMap: Record<string, string> = { meta: "Meta", ctrl: "Control", shift: "Shift", alt: "Alt" };
+  const namedKeys: Record<string, string> = {
+    esc: "Escape",
+    enter: "Enter",
+    backspace: "Backspace",
+    del: "Delete",
+    tab: "Tab",
+  };
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token.startsWith("{") || !token.endsWith("}")) {
+      await page.keyboard.type(token);
+      continue;
+    }
+    const name = token.slice(1, -1).toLowerCase();
+    if (name === "selectall") {
+      await page.keyboard.press(isMac ? "Meta+a" : "Control+a");
+    } else if (namedKeys[name]) {
+      await page.keyboard.press(namedKeys[name]);
+    } else if (modifierMap[name]) {
+      const modifiers = [modifierMap[name]];
+      let j = i + 1;
+      while (j < tokens.length && /^\{(meta|ctrl|shift|alt)\}$/i.test(tokens[j])) {
+        modifiers.push(modifierMap[tokens[j].slice(1, -1).toLowerCase()]);
+        j++;
+      }
+      const key = tokens[j] ?? "";
+      await page.keyboard.press([...modifiers, key].join("+"));
+      i = j;
+    }
+  }
+}
+
+async function centerOf(locator: Locator): Promise<{ x: number; y: number }> {
+  const box = await locator.boundingBox();
+  if (!box) throw new Error("Element has no bounding box");
+  return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+}
+
+export class MaputnikDriver {
+  private scope: Locator | null = null;
+  private readonly recordedRequests = new Map<string, Request[]>();
+  private readonly modalDriver = new ModalDriver(this);
+
+  /**
+   * The page for the currently running test. Resolved lazily so a single driver
+   * instance can be created once per `describe` and reused across its tests.
+   */
+  private get page(): Page {
+    return currentPage();
+  }
+
+  // ---- Element access ------------------------------------------------------
+
+  private root(): Page | Locator {
+    return this.scope ?? this.page;
+  }
+
+  private testId(testId: string): Locator {
+    return this.root().locator(testIdSelector(testId));
+  }
+
+  then = <T>(target: T) => new MaputnikAssertable(target, this.page);
+
+  // ---- given ---------------------------------------------------------------
+
   public given = {
-    ...this.helper.given,
+    fixture: (_name: string, _alias?: string) => {
+      // Fixtures are read directly from disk in Playwright, no registration needed.
+    },
+
+    intercept: async (url: string, alias: string, _method = "GET") => {
+      this.recordedRequests.set(alias, []);
+      // Convert the Cypress-style glob (which may contain "?" in a query string)
+      // into a regex so query parameters match reliably.
+      const pattern = new RegExp(
+        "^" + url.replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*/g, ".*") + "$"
+      );
+      await this.page.route(pattern, (route) => {
+        this.recordedRequests.get(alias)!.push(route.request());
+        route.continue();
+      });
+    },
+
+    interceptAndMockResponse: async (options: {
+      method?: string;
+      url: string | RegExp;
+      response: unknown | { fixture: string };
+      alias?: string;
+    }) => {
+      const { url, response, alias } = options;
+      if (alias) this.recordedRequests.set(alias, []);
+      await this.page.route(url, (route) => {
+        if (alias) this.recordedRequests.get(alias)!.push(route.request());
+        const body =
+          response && typeof response === "object" && "fixture" in (response as any)
+            ? readFixture((response as { fixture: string }).fixture)
+            : response;
+        route.fulfill({ json: body });
+      });
+    },
 
     setupMockBackedResponses: async () => {
       const styleFixtures = [
@@ -38,19 +277,18 @@ export class MaputnikDriver {
         "example-style-with-fonts.json",
         "example-style-with-zoom-7-and-center-0-51.json",
         "example-style-with-zoom-5-and-center-50-50.json",
-        "access-token-style.json",
       ];
       for (const fixture of styleFixtures) {
-        await this.helper.given.interceptAndMockResponse({
+        await this.given.interceptAndMockResponse({
           method: "GET",
           url: baseUrl + fixture,
           response: { fixture },
           alias: fixture === "example-style.json" ? "example-style.json" : undefined,
         });
       }
-      await this.helper.given.interceptAndMockResponse({ method: "GET", url: /example\.local\//, response: [] });
+      await this.given.interceptAndMockResponse({ method: "GET", url: /example\.local\//, response: [] });
-      await this.helper.given.interceptAndMockResponse({ method: "GET", url: /example\.com\//, response: [] });
+      await this.given.interceptAndMockResponse({ method: "GET", url: /example\.com\//, response: [] });
-      await this.helper.given.interceptAndMockResponse({
+      await this.given.interceptAndMockResponse({
         method: "GET",
         url: "https://www.glyph-server.com/*",
         response: ["Font 1", "Font 2", "Font 3"],
@@ -58,11 +296,97 @@ export class MaputnikDriver {
     },
   };
 
-  public when = {
+  // ---- when ----------------------------------------------------------------
-    ...this.helper.when,
 
+  public when = {
     modal: this.modalDriver.when,
 
+    visit: async (url: string) => {
+      // Snapshot coverage before navigating, since a full page load resets it.
+      recordCoverageChunk(await readCoverage(this.page));
+      const target = url.startsWith("http") ? url : new URL(url, baseUrl).toString();
+      await this.page.goto(target);
+    },
+
+    wait: (ms: number) => this.page.waitForTimeout(ms),
+
+    tab: () => this.page.keyboard.press("Tab"),
+
+    typeKeys: (keys: string) => typeSequence(this.page, keys),
+
+    doWithin: async (selector: string, fn: () => Promise<void> | void) => {
+      const previous = this.scope;
+      this.scope = (previous ?? this.page).locator(testIdSelector(selector));
+      try {
+        await fn();
+      } finally {
+        this.scope = previous;
+      }
+    },
+
+    click: async (testId: string, index = 0) => {
+      // Documentation buttons are wrapped in a <label>/.maputnik-doc-target that
+      // Playwright treats as intercepting the click; bypass the check for them.
+      const force = testId.startsWith("field-doc-button-");
+      await this.testId(testId).nth(index).click({ force });
+    },
+
+    realClick: async (testId: string) => {
+      await this.testId(testId).click();
+    },
+
+    hover: async (testId: string) => {
+      await this.testId(testId).hover();
+    },
+
+    focus: async (testId: string) => {
+      await this.testId(testId).focus();
+    },
+
+    clear: async (testId: string) => {
+      await this.testId(testId).clear();
+    },
+
+    select: async (testId: string, value: string) => {
+      await this.testId(testId).selectOption(value);
+    },
+
+    selectWithin: async (selector: string, value: string) => {
+      await this.root().locator(testIdSelector(selector)).locator("select").selectOption(value);
+    },
+
+    setValue: async (testId: string, text: string) => {
+      const input = this.testId(testId);
+      await input.fill("");
+      await input.fill(text);
+    },
+
+    type: async (testId: string, text: string) => {
+      await this.testId(testId).focus();
+      // Place the caret at the start of the field (matching how the original
+      // Cypress suite typed), so a leading "{backspace}" is a no-op rather than
+      // clearing an already-committed value.
+      await this.page.keyboard.press("Home");
+      await typeSequence(this.page, text);
+    },
+
+    setValueToPropertyArray: async (selector: string, value: string) => {
+      await this.when.doWithin(selector, async () => {
+        const input = this.root().locator(".maputnik-array-block-content input").last();
+        await input.focus();
+        await typeSequence(this.page, "{selectall}" + value);
+      });
+    },
+
+    addValueToPropertyArray: async (selector: string, value: string) => {
+      await this.when.doWithin(selector, async () => {
+        await this.root().locator(".maputnik-array-add-value").click();
+        const input = this.root().locator(".maputnik-array-block-content input").last();
+        await input.focus();
+        await typeSequence(this.page, "{selectall}" + value);
+      });
+    },
+
     setStyle: async (
       styleProperties:
         | "geojson"
@@ -72,7 +396,6 @@ export class MaputnikDriver {
         | "rectangles"
         | "font"
         | "zoom_7_center_0_51"
-        | "access_tokens"
         | "",
       zoom?: number
     ) => {
@@ -84,7 +407,6 @@ export class MaputnikDriver {
         rectangles: "rectangles-style.json",
         font: "example-style-with-fonts.json",
         zoom_7_center_0_51: "example-style-with-zoom-7-and-center-0-51.json",
-        access_tokens: "access-token-style.json",
       };
 
       const url = new URL(baseUrl);
@@ -95,264 +417,163 @@ export class MaputnikDriver {
         url.hash = `${zoom}/41.3805/2.1635`;
       }
 
-      await this.helper.when.visit(url.toString());
+      await this.when.visit(url.toString());
 
-      const toolbarLink = this.helper.get.elementByTestId("toolbar:link");
+      const toolbarLink = this.testId("toolbar:link");
       await toolbarLink.scrollIntoViewIfNeeded();
-      await this.then(toolbarLink).shouldBeVisible();
+      await expect(toolbarLink).toBeVisible();
     },
 
     openASecondStyleWithDifferentZoomAndCenter: async () => {
-      await this.helper.when.clickButtonByName("Open");
+      await this.page.getByRole("button", { name: "Open" }).click();
-      const input = this.helper.get.elementByTestId("modal:open.url.input");
+      const input = this.testId("modal:open.url.input");
+      await expect(input).toBeEnabled();
       await input.fill("http://localhost:8888/example-style-with-zoom-5-and-center-50-50.json");
       await input.press("Enter");
     },
 
     chooseExampleFile: async () => {
-      await this.helper.when.openFileByFixture("example-style.json", "modal:open.dropzone");
+      await this.openFileByFixture("example-style.json", "modal:open.dropzone", "modal:open.file.input");
-      await this.helper.when.wait(200);
+      await this.when.wait(200);
-    },
-
-    /** Picks the example style through the browser's native file chooser. */
-    chooseExampleFileFromPicker: async () => {
-      await this.helper.when.chooseFileFromPicker("example-style.json", "modal:open.dropzone");
-      await this.helper.when.wait(200);
     },
 
     dropExampleFile: async () => {
-      await this.helper.when.dropFileByFixture("example-style.json", "modal:open.dropzone");
+      await this.dropFileByFixture("example-style.json", "modal:open.dropzone");
-      await this.helper.when.wait(200);
+      await this.when.wait(200);
     },
 
     clickZoomIn: async () => {
-      await this.helper.get.element(".maplibregl-ctrl-zoom-in").click();
+      await this.page.locator(".maplibregl-ctrl-zoom-in").click();
     },
 
     closePopup: async () => {
-      await this.helper.get.element(".maplibregl-popup-close-button").click();
+      await this.page.locator(".maplibregl-popup-close-button").click();
+    },
+
+    clickCenter: async (testId: string) => {
+      const { x, y } = await centerOf(this.testId(testId));
+      await this.page.mouse.move(x, y);
+      await this.page.mouse.down();
+      await this.when.wait(200);
+      await this.page.mouse.up();
     },
 
     collapseGroupInLayerEditor: async (index = 0) => {
-      await this.helper.get.element(".maputnik-layer-editor-group__button").nth(index).click();
+      await this.page.locator(".maputnik-layer-editor-group__button").nth(index).click();
-    },
-
-    /** Expands/collapses a layer-editor group by its title, e.g. "Paint properties". */
-    toggleGroupInLayerEditor: async (title: string) => {
-      await this.helper.when.click("layer-editor-group:" + title);
-    },
-
-    /**
-     * Picks a source for the selected layer from the source autocomplete.
-     * The autocomplete is a controlled (downshift) input, so the value has to be
-     * filled rather than typed key by key, then chosen from the filtered menu.
-     */
-    changeLayerSource: async (sourceId: string) => {
-      const input = this.helper.get.elementByTestId("layer-editor.layer-source").locator("input");
-      await input.fill(sourceId);
-      await this.helper.get.element(".maputnik-autocomplete-menu-item").first().click();
     },
 
     appendTextInJsonEditor: async (text: string) => {
-      await this.helper.get.element(".cm-line").first().click();
+      await this.page.locator(".cm-line").first().click();
       // Move to the very start of the document so the inserted text breaks the
       // root JSON structure (CodeMirror auto-closes brackets otherwise).
-      await this.helper.when.typeKeys("{home}");
+      await this.page.keyboard.press("Home");
-      await this.helper.when.typeText(text);
+      await typeSequence(this.page, text);
     },
 
     setTextInJsonEditor: async (text: string) => {
-      await this.helper.get.element(".cm-line").first().click();
+      const firstLine = this.page.locator(".cm-line").first();
-      await this.helper.when.typeKeys("{selectall}");
+      await firstLine.click();
-      await this.helper.when.typeText(text);
+      await this.page.keyboard.press(isMac ? "Meta+a" : "Control+a");
+      await this.page.keyboard.type(text);
     },
 
-    setValueToPropertyArray: async (selector: string, value: string) => {
+    dragAndDropWithWait: async (source: string, target: string) => {
-      const input = this.helper.get.elementByTestId(selector).locator(".maputnik-array-block-content input").last();
+      const from = await centerOf(this.testId(source));
-      await input.focus();
+      const to = await centerOf(this.testId(target));
-      await this.helper.when.typeKeys("{selectall}");
+      await this.page.mouse.move(from.x, from.y);
-      await this.helper.when.typeText(value);
+      await this.page.mouse.down();
+      await this.page.mouse.move(from.x, from.y + 10);
+      await this.page.mouse.move(to.x, to.y, { steps: 10 });
+      await this.when.wait(100);
+      await this.page.mouse.up();
     },
 
-    addValueToPropertyArray: async (selector: string, value: string) => {
+    waitForResponse: async (alias: string) => {
-      const block = this.helper.get.elementByTestId(selector);
+      const requests = this.recordedRequests.get(alias);
-      await block.locator(".maputnik-array-add-value").click();
+      if (!requests) throw new Error(`No intercept registered for alias "${alias}"`);
-      const input = block.locator(".maputnik-array-block-content input").last();
+      await retry(async () => {
-      await input.focus();
+        if (requests.length === 0) throw new Error(`No request recorded for alias "${alias}"`);
-      await this.helper.when.typeKeys("{selectall}");
+      });
-      await this.helper.when.typeText(value);
+      return requests[requests.length - 1];
     },
 
-    makeZoomFunction: async (fieldName: string) => {
+    waitForExampleFileResponse: () => this.when.waitForResponse("example-style.json"),
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.scrollIntoViewIfNeeded();
-      await container.locator(".maputnik-make-zoom-function").last().click({ force: true });
-    },
 
-    makeDataFunction: async (fieldName: string) => {
+    clearLocalStorage: () => this.page.evaluate(() => window.localStorage.clear()),
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.scrollIntoViewIfNeeded();
-      await container.locator(".maputnik-make-data-function").click({ force: true });
-    },
-
-    addFunctionStop: async (fieldName: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator(".maputnik-add-stop").first().click({ force: true });
-    },
-
-    deleteFunctionStop: async (fieldName: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator(".maputnik-delete-stop").first().click({ force: true });
-    },
-
-    /** Turns the property into a raw style expression. */
-    makeExpression: async (fieldName: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.scrollIntoViewIfNeeded();
-      // In the plain spec field the expression button shares the zoom-function
-      // class and comes first; inside a function editor it has its own test id.
-      const inFunctionEditor = container.locator("[data-wd-key='convert-to-expression']");
-      const button =
-        (await inFunctionEditor.count()) > 0
-          ? inFunctionEditor
-          : container.locator(".maputnik-make-zoom-function").first();
-      await button.click({ force: true });
-    },
-
-    /** Reverts an expression back to a plain value. */
-    undoExpression: async (fieldName: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator("[data-wd-key='undo-expression']").click({ force: true });
-    },
-
-    /** Removes an expression, restoring the property's spec default. */
-    deleteExpression: async (fieldName: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator("[data-wd-key='delete-expression']").click({ force: true });
-    },
-
-    /** Picks the function scale (categorical/interval/exponential/identity/interpolate). */
-    selectFunctionType: async (fieldName: string, type: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator("[data-wd-key='function-type'] select").selectOption(type);
-    },
-
-    /** Sets the "Base" input of a zoom/data function. */
-    setFunctionBase: async (fieldName: string, value: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator("[data-wd-key='function-base'] input").fill(value);
-    },
-
-    /**
-     * Sets the data property a data function keys off of. This is an InputString,
-     * which only commits its value on blur, so typing alone is not enough.
-     */
-    setFunctionProperty: async (fieldName: string, value: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      const input = container.locator("[data-wd-key='function-property'] input");
-      await input.fill(value);
-      await input.blur();
-    },
-
-    /** Sets the fallback value used when a feature has no matching stop. */
-    setFunctionDefault: async (fieldName: string, value: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator("[data-wd-key='function-default'] input").fill(value);
-    },
-
-    /** Edits one cell of a function's stop table ("Zoom", "Input value" or "Output value"). */
-    setFunctionStopValue: async (fieldName: string, column: string, index: number, value: string) => {
-      const container = this.helper.get.elementByTestId("spec-field-container:" + fieldName);
-      await container.locator(`[aria-label="${column}"]`).nth(index).fill(value);
-    },
-
-    addFilter: async () => {
-      const button = this.helper.get.elementByTestId("layer-filter-button");
-      await button.scrollIntoViewIfNeeded();
-      await button.click({ force: true });
-    },
-
-    selectFilterOperator: async (value: string) => {
-      await this.helper.get.element(".maputnik-filter-editor-operator select").first().selectOption(value);
-    },
-
-    /** Chooses how the filter items combine: all / none / any. */
-    selectFilterCombiningOperator: async (value: string) => {
-      await this.helper.when.selectWithin("filter-combining-operator", value);
-    },
-
-    deleteFilterItem: async (index = 0) => {
-      await this.helper.get
-        .element(".maputnik-filter-editor-block-action .maputnik-icon-button")
-        .nth(index)
-        .click();
-    },
-
-    /** Converts the simple filter editor into a raw expression editor. */
-    convertFilterToExpression: async () => {
-      await this.helper.when.click("filter-convert-to-expression");
-    },
-
-    /**
-     * Deletes the filter expression, restoring the simple filter editor.
-     * The filter group precedes the paint group, so its button comes first.
-     */
-    deleteFilterExpression: async () => {
-      await this.helper.get.element("[data-wd-key='delete-expression']").first().click();
-    },
-
-    setColorValue: async (fieldName: string, value: string) => {
-      const input = this.helper.get.elementByTestId("spec-field:" + fieldName).locator(".maputnik-color");
-      await input.fill(value);
-    },
-
-    /** Sets a plain string spec field (e.g. a pattern), which has no dedicated input test id. */
-    setStringValue: async (fieldName: string, value: string) => {
-      const input = this.helper.get.elementByTestId("spec-field:" + fieldName).locator("input.maputnik-string");
-      await input.fill(value);
-      await input.blur();
-    },
-
-    /**
-     * Appends text to the end of the JSON editor line holding `lineText`.
-     * CodeMirror types over its own auto-inserted closing quotes/brackets, so a
-     * well-formed fragment stays well-formed.
-     */
-    appendToJsonEditorLine: async (lineText: string, text: string) => {
-      await this.helper.when.clickByText(lineText);
-      await this.helper.when.typeKeys("{end}");
-      await this.helper.when.typeText(text);
-    },
-
-    waitForExampleFileResponse: () => this.helper.when.waitForResponse("example-style.json"),
-
-    /** Fill localStorage until we get a QuotaExceededError. */
-    fillLocalStorage: () => this.helper.when.fillLocalStorageUntilQuota("maputnik:fill-"),
   };
 
-  public get = {
+  // ---- get -----------------------------------------------------------------
-    ...this.helper.get,
 
+  public get = {
     isMac: () => isMac,
 
-    canvas: () => this.helper.get.element("canvas"),
+    element: (selector: string) => this.root().locator(selector),
 
-    searchControl: () => this.helper.get.element(".maplibregl-ctrl-geocoder"),
+    elementByTestId: (testId: string) => this.testId(testId),
 
-    skipTargetLayerList: () => this.helper.get.elementByTestId("skip-target-layer-list"),
+    elementByText: (text: string) => this.root().getByText(text),
 
-    skipTargetLayerEditor: () => this.helper.get.elementByTestId("skip-target-layer-editor"),
+    elementByAttribute: (attribute: string, value: string) =>
+      this.root().locator(`[${attribute}="${value}"]`),
 
-    styleFromLocalStorage: () => this.helper.query(() => this.readStoredStyle()),
+    canvas: () => this.page.locator("canvas"),
 
-    fixture: (name: string) => this.helper.readFixture(name),
+    searchControl: () => this.page.locator(".maplibregl-ctrl-geocoder"),
+
+    skipTargetLayerList: () => this.testId("skip-target-layer-list"),
+
+    skipTargetLayerEditor: () => this.testId("skip-target-layer-editor"),
+
+    inputValue: (testId: string) => new Query<string>(() => this.testId(testId).first().inputValue()),
+
+    elementsText: (testId: string) => new Query<string>(() => this.testId(testId).first().innerText()),
+
+    locationHash: () => new Query<string>(async () => new URL(this.page.url()).hash),
+
+    styleFromLocalStorage: () => new Query<any>(() => styleFromLocalStorage(this.page)),
+
+    fixture: (name: string) => Promise.resolve(readFixture(name)),
 
     responseBody: (alias: string) => {
       // Our mocked style responses always return the matching fixture.
       const name = alias.endsWith(".json") ? alias : `${alias}.json`;
-      return this.helper.readFixture(name);
+      return Promise.resolve(readFixture(name));
     },
 
     exampleFileUrl: () => baseUrl + "example-style.json",
   };
+
+  // ---- file open helpers ---------------------------------------------------
+
+  private async openFileByFixture(fixture: string, buttonTestId: string, inputTestId: string): Promise<void> {
+    const content = JSON.stringify(readFixture(fixture));
+    const hasPicker = await this.page.evaluate(() => "showOpenFilePicker" in window);
+    if (hasPicker) {
+      await this.page.evaluate((fileContent) => {
+        (window as any).showOpenFilePicker = async () => [
+          { getFile: async () => ({ text: async () => fileContent }) },
+        ];
+      }, content);
+      await this.testId(buttonTestId).click();
+    } else {
+      await this.testId(inputTestId).setInputFiles({
+        name: fixture,
+        mimeType: "application/json",
+        buffer: Buffer.from(content),
+      });
+    }
+  }
+
+  private async dropFileByFixture(fixture: string, dropzoneTestId: string): Promise<void> {
+    const content = JSON.stringify(readFixture(fixture));
+    const dataTransfer = await this.page.evaluateHandle((fileContent) => {
+      const dt = new DataTransfer();
+      dt.items.add(new File([fileContent], "example-style.json", { type: "application/json" }));
+      return dt;
+    }, content);
+    const dropzone = this.testId(dropzoneTestId);
+    await dropzone.dispatchEvent("dragenter", { dataTransfer });
+    await dropzone.dispatchEvent("dragover", { dataTransfer });
+    await dropzone.dispatchEvent("drop", { dataTransfer });
+  }
 }

e2e/modal-driver.ts

@@ -1,24 +1,27 @@
 import { v1 as uuid } from "uuid";
-import { PlaywrightHelper } from "./playwright-helper";
+import { expect } from "@playwright/test";
+import type { MaputnikDriver } from "./maputnik-driver";
 
 export class ModalDriver {
-  private readonly helper = new PlaywrightHelper();
+  constructor(private readonly driver: MaputnikDriver) {}
 
   public when = {
     fillLayers: async (opts: { type: string; layer?: string; id?: string }) => {
-      const { when, get, then } = this.helper;
+      const { when, get } = this.driver;
       const id = opts.id ?? `${opts.type}:${uuid()}`;
 
       await when.select("add-layer.layer-type.select", opts.type);
       await when.type("add-layer.layer-id.input", id);
 
       if (opts.layer) {
-        const input = get.elementByTestId("add-layer.layer-source-block").locator("input");
+        await when.doWithin("add-layer.layer-source-block", async () => {
+          const input = get.element("input");
           await input.click();
-        await input.fill(opts.layer);
+          await input.fill(opts.layer!);
-        // The source input is a controlled downshift combobox; wait for React to
+          // The source input is a controlled downshift combobox; wait for React
-        // settle on the typed value before submitting.
+          // to settle on the typed value before submitting.
-        await then(input).shouldHaveValue(opts.layer);
+          await expect(input).toHaveValue(opts.layer!);
+        });
         // Close the autocomplete menu so it does not intercept the add button.
         await get.elementByTestId("add-layer.layer-id.input").click();
       }
@@ -28,51 +31,15 @@ export class ModalDriver {
     },
 
     open: async () => {
-      await this.helper.when.click("layer-list:add-layer");
+      // No-op when the add-layer modal is already open (some specs call open()
+      // both in a beforeEach and at the start of the test body).
+      const modal = this.driver.get.elementByTestId("modal:add-layer").first();
+      if (await modal.isVisible()) return;
+      await this.driver.when.click("layer-list:add-layer");
     },
 
     close: async (key: string) => {
-      await this.helper.when.click(key + ".close-modal");
+      await this.driver.when.click(key + ".close-modal");
-    },
-
-    /**
-     * Adds a source of the given type from the sources modal, keeping whatever
-     * defaults that type's editor prefills.
-     */
-    addSource: async (sourceId: string, sourceType: string) => {
-      const { when } = this.helper;
-      await when.setValue("modal:sources.add.source_id", sourceId);
-      await when.select("modal:sources.add.source_type", sourceType);
-      await when.click("modal:sources.add.add_source");
-      await when.wait(200);
-    },
-
-    /** Adds one of the predefined public sources listed in the sources modal. */
-    addPublicSource: async (index = 0) => {
-      await this.helper.get.element(".maputnik-public-source-select").nth(index).click();
-    },
-
-    deleteFirstActiveSource: async () => {
-      await this.helper.get.element(".maputnik-active-source-type-editor-header-delete").first().click();
-    },
-
-    /** Fills one number box of a coordinate pair in the image/video source editor. */
-    setCoordinateValue: async (index: number, value: string) => {
-      const input = this.helper.get
-        .elementByTestId("modal:sources")
-        .locator(".maputnik-array input")
-        .nth(index);
-      await input.fill(value);
-      await input.blur();
-    },
-
-    exportCreateHtml: async () => {
-      await this.helper.get.element(".maputnik-modal-export-buttons button").last().click();
-    },
-
-    exportSaveStyle: async () => {
-      await this.helper.stubSaveFilePicker();
-      await this.helper.get.element(".maputnik-modal-export-buttons button").first().click();
     },
   };
 }

e2e/modals.spec.ts

@@ -1,18 +1,20 @@
-import { test, expect, describe, beforeEach } from "./utils/fixtures";
+import { test, expect } from "./fixtures";
 import { MaputnikDriver } from "./maputnik-driver";
 import tokens from "../src/config/tokens.json" with { type: "json" };
 
-describe("modals", () => {
+test.describe("modals", () => {
   const { given, get, when, then } = new MaputnikDriver();
 
-  beforeEach(async () => {
+  test.beforeEach(async () => {
     await given.setupMockBackedResponses();
+    // Load a style first so it is persisted to localStorage, then reset the URL
+    // to the root (no style param) — several tests read the stored style.
     await when.setStyle("both");
     await when.setStyle("");
   });
 
-  describe("open", () => {
+  test.describe("open", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.click("nav:open");
     });
 
@@ -23,16 +25,16 @@ describe("modals", () => {
 
     test("upload", async () => {
       await when.chooseExampleFile();
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude(get.fixture("example-style.json"));
+      await then(get.fixture("example-style.json")).shouldEqualToStoredStyle();
     });
 
     test("upload via drag and drop", async () => {
       await when.dropExampleFile();
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude(get.fixture("example-style.json"));
+      await then(get.fixture("example-style.json")).shouldEqualToStoredStyle();
     });
 
-    describe("when click open url", () => {
+    test.describe("when click open url", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         const styleFileUrl = get.exampleFileUrl();
 
         await when.setValue("modal:open.url.input", styleFileUrl);
@@ -40,22 +42,12 @@ describe("modals", () => {
         await when.wait(200);
       });
       test("load from url", async () => {
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude(get.responseBody("example-style.json"));
+        await then(get.responseBody("example-style.json")).shouldEqualToStoredStyle();
-      });
-    });
-
-    describe("without the File System Access API", () => {
-      test("upload via the file chooser", async () => {
-        await given.noFileSystemAccessApi();
-        await when.setStyle("");
-        await when.click("nav:open");
-        await when.chooseExampleFileFromPicker();
-        await then(get.styleFromLocalStorage()).shouldDeepNestedInclude(get.fixture("example-style.json"));
       });
     });
   });
 
-  describe("shortcuts", () => {
+  test.describe("shortcuts", () => {
     test("open/close", async () => {
       await when.setStyle("");
       await when.typeKeys("?");
@@ -64,8 +56,8 @@ describe("modals", () => {
     });
   });
 
-  describe("export", () => {
+  test.describe("export", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.click("nav:export");
     });
 
@@ -74,44 +66,18 @@ describe("modals", () => {
       await then(get.elementByTestId("modal:export")).shouldNotExist();
     });
 
-    test("download HTML and save the style", async () => {
+    // TODO: Work out how to download a file and check the contents
-      // Generate the standalone HTML export (triggers a file download).
+    test.skip("download", () => {});
-      await when.modal.exportCreateHtml();
-      await then(get.elementByTestId("modal:export")).shouldExist();
-
-      // Saving the style closes the export modal.
-      await when.modal.exportSaveStyle();
-      await then(get.elementByTestId("modal:export")).shouldNotExist();
-    });
   });
 
-  describe("sources", () => {
+  test.describe("sources", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.setStyle("layer");
       await when.click("nav:sources");
     });
 
-    test("active sources are listed and can be deleted", async () => {
+    test.skip("active sources", () => {});
-      await when.setStyle("both");
+    test.skip("public source", () => {});
-      await when.click("nav:sources");
-      const before = Object.keys(get.fixture("geojson-raster-style.json").sources).length;
-      await when.modal.deleteFirstActiveSource();
-      await then(
-        get.styleFromLocalStorage().then((style) => Object.keys(style.sources).length)
-      ).shouldEqual(before - 1);
-    });
-
-    test("public source", async () => {
-      await when.modal.addPublicSource();
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          openmaptiles: {
-            type: "vector",
-            url: `https://api.maptiler.com/tiles/v3-openmaptiles/tiles.json?key=${tokens.openmaptiles}`,
-          },
-        },
-      });
-    });
 
     test("add new source", async () => {
       const sourceId = "n1z2v3r";
@@ -120,8 +86,8 @@ describe("modals", () => {
       await when.select("modal:sources.add.scheme_type", "tms");
       await when.click("modal:sources.add.add_source");
       await when.wait(200);
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.sources[sourceId])).shouldInclude({
-        sources: { [sourceId]: { scheme: "tms" } },
+        scheme: "tms",
       });
     });
 
@@ -154,115 +120,13 @@ describe("modals", () => {
       await when.setValue("modal:sources.add.tile_size", "128");
       await when.click("modal:sources.add.add_source");
       await when.wait(200);
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.sources[sourceId])).shouldInclude({
-        sources: { [sourceId]: { tileSize: 128 } },
+        tileSize: 128,
-      });
-    });
-
-    test("add new geojson url source", async () => {
-      await when.modal.addSource("geojsonurl", "geojson_url");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          geojsonurl: { type: "geojson", data: "http://localhost:3000/geojson.json" },
-        },
-      });
-    });
-
-    test("add new geojson json source", async () => {
-      await when.modal.addSource("geojsonjson", "geojson_json");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          geojsonjson: { type: "geojson", cluster: false, data: "" },
-        },
-      });
-    });
-
-    test("add new tilejson vector source", async () => {
-      await when.modal.addSource("tilejsonvector", "tilejson_vector");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          tilejsonvector: { type: "vector", url: "http://localhost:3000/tilejson.json" },
-        },
-      });
-    });
-
-    test("add new tilejson raster source", async () => {
-      await when.modal.addSource("tilejsonraster", "tilejson_raster");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          tilejsonraster: { type: "raster", url: "http://localhost:3000/tilejson.json" },
-        },
-      });
-    });
-
-    test("add new tilejson raster-dem source", async () => {
-      await when.modal.addSource("tilejsonrasterdem", "tilejson_raster-dem");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          tilejsonrasterdem: { type: "raster-dem", url: "http://localhost:3000/tilejson.json" },
-        },
-      });
-    });
-
-    test("add new tile xyz raster-dem source", async () => {
-      await when.modal.addSource("tilexyzrasterdem", "tilexyz_raster-dem");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          tilexyzrasterdem: {
-            type: "raster-dem",
-            tiles: ["http://localhost:3000/{x}/{y}/{z}.png"],
-            minzoom: 0,
-            maxzoom: 14,
-            tileSize: 512,
-          },
-        },
-      });
-    });
-
-    test("add new image source", async () => {
-      await when.modal.addSource("imagesource", "image");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          imagesource: {
-            type: "image",
-            url: "http://localhost:3000/image.png",
-            coordinates: [[0, 0], [0, 0], [0, 0], [0, 0]],
-          },
-        },
-      });
-    });
-
-    test("add new video source", async () => {
-      await when.modal.addSource("videosource", "video");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          videosource: {
-            type: "video",
-            urls: ["http://localhost:3000/movie.mp4"],
-            coordinates: [[0, 0], [0, 0], [0, 0], [0, 0]],
-          },
-        },
-      });
-    });
-
-    test("edit the corner coordinates of an image source", async () => {
-      const sourceId = "imagecoords";
-      await when.setValue("modal:sources.add.source_id", sourceId);
-      await when.select("modal:sources.add.source_type", "image");
-      // The first corner is the first two number boxes of the coordinate arrays.
-      await when.modal.setCoordinateValue(0, "1");
-      await when.modal.setCoordinateValue(1, "2");
-      await when.click("modal:sources.add.add_source");
-      await when.wait(200);
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        sources: {
-          [sourceId]: { type: "image", coordinates: [[1, 2], [0, 0], [0, 0], [0, 0]] },
-        },
       });
     });
   });
 
-  describe("inspect", () => {
+  test.describe("inspect", () => {
     test("toggle", async () => {
       // There is no assertion in this test
       await when.setStyle("geojson");
@@ -270,13 +134,13 @@ describe("modals", () => {
     });
   });
 
-  describe("style settings", () => {
+  test.describe("style settings", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.click("nav:settings");
     });
 
-    describe("when click name filed spec information", () => {
+    test.describe("when click name filed spec information", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         await when.click("field-doc-button-Name");
       });
 
@@ -285,8 +149,8 @@ describe("modals", () => {
       });
     });
 
-    describe("when set name and click owner", () => {
+    test.describe("when set name and click owner", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         await when.setValue("modal:settings.name", "foobar");
         await when.click("modal:settings.owner");
         await when.wait(200);
@@ -299,8 +163,8 @@ describe("modals", () => {
       });
     });
 
-    describe("when set owner and click name", () => {
+    test.describe("when set owner and click name", () => {
-      beforeEach(async () => {
+      test.beforeEach(async () => {
         await when.setValue("modal:settings.owner", "foobar");
         await when.click("modal:settings.name");
         await when.wait(200);
@@ -342,8 +206,8 @@ describe("modals", () => {
       const apiKey = "testing123";
       await when.setValue("modal:settings.maputnik:openmaptiles_access_token", apiKey);
       await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.metadata)).shouldInclude({
-        metadata: { "maputnik:openmaptiles_access_token": apiKey },
+        "maputnik:openmaptiles_access_token": apiKey,
       });
     });
 
@@ -351,8 +215,8 @@ describe("modals", () => {
       const apiKey = "testing123";
       await when.setValue("modal:settings.maputnik:thunderforest_access_token", apiKey);
       await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.metadata)).shouldInclude({
-        metadata: { "maputnik:thunderforest_access_token": apiKey },
+        "maputnik:thunderforest_access_token": apiKey,
       });
     });
 
@@ -360,8 +224,8 @@ describe("modals", () => {
       const apiKey = "testing123";
       await when.setValue("modal:settings.maputnik:stadia_access_token", apiKey);
       await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.metadata)).shouldInclude({
-        metadata: { "maputnik:stadia_access_token": apiKey },
+        "maputnik:stadia_access_token": apiKey,
       });
     });
 
@@ -369,67 +233,29 @@ describe("modals", () => {
       const apiKey = "testing123";
       await when.setValue("modal:settings.maputnik:locationiq_access_token", apiKey);
       await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.metadata)).shouldInclude({
-        metadata: { "maputnik:locationiq_access_token": apiKey },
+        "maputnik:locationiq_access_token": apiKey,
-      });
-    });
-
-    test("map view defaults", async () => {
-      await when.setValue("modal:settings.zoom", "4");
-      await when.setValue("modal:settings.bearing", "12");
-      await when.setValue("modal:settings.pitch", "30");
-      await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        zoom: 4,
-        bearing: 12,
-        pitch: 30,
-      });
-    });
-
-    test("light intensity", async () => {
-      await when.setValue("modal:settings.light-intensity", "0.7");
-      await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        light: { intensity: 0.7 },
-      });
-    });
-
-    test("terrain source and exaggeration", async () => {
-      await when.setValue("modal:settings.maputnik:terrain_source", "terrain");
-      await when.setValue("modal:settings.terrain-exaggeration", "1.5");
-      await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        terrain: { source: "terrain", exaggeration: 1.5 },
-      });
-    });
-
-    test("transition delay and duration", async () => {
-      await when.setValue("modal:settings.transition-delay", "100");
-      await when.setValue("modal:settings.transition-duration", "500");
-      await when.click("modal:settings.name");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
-        transition: { delay: 100, duration: 500 },
       });
     });
 
     test("style projection mercator", async () => {
       await when.select("modal:settings.projection", "mercator");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.projection)).shouldInclude({
-        projection: { type: "mercator" },
+        type: "mercator",
       });
     });
 
     test("style projection globe", async () => {
       await when.select("modal:settings.projection", "globe");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.projection)).shouldInclude({
-        projection: { type: "globe" },
+        type: "globe",
       });
     });
 
     test("style projection vertical-perspective", async () => {
       await when.select("modal:settings.projection", "vertical-perspective");
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude({
+      await then(get.styleFromLocalStorage().then((style) => style.projection)).shouldInclude({
-        projection: { type: "vertical-perspective" },
+        type: "vertical-perspective",
       });
     });
 
@@ -447,7 +273,7 @@ describe("modals", () => {
       await when.click("modal:settings.close-modal");
       await when.click("nav:open");
 
-      await when.clickByAttribute("aria-label", "MapTiler Basic");
+      await get.elementByAttribute("aria-label", "MapTiler Basic").click();
       await when.wait(1000);
       await when.click("nav:settings");
 
@@ -458,7 +284,7 @@ describe("modals", () => {
       await then(get.inputValue("modal:settings.maputnik:renderer")).shouldEqual("ol");
 
       await given.intercept(
-        /https:\/\/api\.maptiler\.com\/tiles\/v3-openmaptiles\/tiles\.json\?key=.*/,
+        "https://api.maptiler.com/tiles/v3-openmaptiles/tiles.json?key=*",
         "tileRequest",
         "GET"
       );
@@ -473,8 +299,8 @@ describe("modals", () => {
     });
   });
 
-  describe("add layer", () => {
+  test.describe("add layer", () => {
-    beforeEach(async () => {
+    test.beforeEach(async () => {
       await when.setStyle("layer");
       await when.modal.open();
     });
@@ -487,8 +313,12 @@ describe("modals", () => {
     });
   });
 
-  describe("global state", () => {
+  test.describe("sources placeholder", () => {
-    beforeEach(async () => {
+    test.skip("toggle", () => {});
+  });
+
+  test.describe("global state", () => {
+    test.beforeEach(async () => {
       await when.click("nav:global-state");
     });
 
@@ -544,7 +374,7 @@ describe("modals", () => {
     });
   });
 
-  describe("error panel", () => {
+  test.describe("error panel", () => {
     test("not visible when no errors", async () => {
       await then(get.element("maputnik-message-panel-error")).shouldNotExist();
     });
@@ -559,18 +389,40 @@ describe("modals", () => {
     });
   });
 
-  describe("Handle localStorage QuotaExceededError", () => {
+  test.describe("Handle localStorage QuotaExceededError", () => {
-    test("handles quota exceeded error when opening style from URL", async () => {
+    test("handles quota exceeded error when opening style from URL", async ({ page }) => {
       // Clear localStorage to start fresh
       await when.clearLocalStorage();
-      await when.fillLocalStorage();
+
+      // fill localStorage until we get a QuotaExceededError
+      await page.evaluate(() => {
+        let chunkSize = 1000;
+        const chunk = new Array(chunkSize).join("x");
+        let index = 0;
+
+        // Keep adding until we hit the quota
+        for (;;) {
+          try {
+            const key = `maputnik:fill-${index++}`;
+            window.localStorage.setItem(key, chunk);
+          } catch (e: any) {
+            // Verify it's a quota error
+            if (e.name === "QuotaExceededError") {
+              if (chunkSize <= 1) return;
+              chunkSize /= 2;
+              continue;
+            }
+            throw e; // Unexpected error
+          }
+        }
+      });
 
       // Open the style via URL input
       await when.click("nav:open");
       await when.setValue("modal:open.url.input", get.exampleFileUrl());
       await when.click("modal:open.url.button");
 
-      await then(get.styleFromLocalStorage()).shouldDeepNestedInclude(get.responseBody("example-style.json"));
+      await then(get.responseBody("example-style.json")).shouldEqualToStoredStyle();
       await then(get.styleFromLocalStorage()).shouldExist();
     });
   });

e2e/playwright-helper.ts

@@ -1,453 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { expect, type Locator, type Page, type Request } from "@playwright/test";
-import { currentPage, recordCoverageChunk } from "./utils/fixtures";
-
-const DATA_ATTRIBUTE = "data-wd-key";
-const FIXTURES_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures");
-const isMac = process.platform === "darwin";
-
-function testIdSelector(testId: string): string {
-  return `[${DATA_ATTRIBUTE}="${testId}"]`;
-}
-
-/** Retries `assertion` until it stops throwing */
-async function retry(
-  assertion: () => Promise<void> | void,
-  timeout = 10000,
-  interval = 100
-): Promise<void> {
-  const start = Date.now();
-  let lastError: unknown;
-  while (true) {
-    try {
-      await assertion();
-      return;
-    } catch (error) {
-      lastError = error;
-      if (Date.now() - start > timeout) throw lastError;
-      await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-  }
-}
-
-/**
- * A lazily-evaluated value (e.g. the style in localStorage). Assertions on a
- * Query re-read the value until they pass.
- */
-class Query<T> {
-  readonly __query = true as const;
-  constructor(private readonly getter: () => Promise<T>) {}
-
-  get(): Promise<T> {
-    return this.getter();
-  }
-
-  then<U>(mapper: (value: T) => U | Promise<U>): Query<U> {
-    return new Query<U>(async () => mapper(await this.getter()));
-  }
-}
-
-function isQuery(target: unknown): target is Query<unknown> {
-  return typeof target === "object" && target !== null && (target as Query<unknown>).__query === true;
-}
-
-function isLocator(target: unknown): target is Locator {
-  return (
-    typeof target === "object" &&
-    target !== null &&
-    typeof (target as Locator).count === "function" &&
-    typeof (target as Locator).boundingBox === "function"
-  );
-}
-
-/**
- * Asserts that `actual` recursively contains everything in `expected`: nested
- * objects are matched as subsets, while arrays and primitives must match exactly.
- */
-function assertDeepNestedInclude(actual: any, expected: Record<string, unknown> | unknown[]): void {
-  expect(actual).toMatchObject(expected);
-}
-
-/**
- * Fluent, auto-retrying assertions over a Playwright Locator or a lazily
- * evaluated value/Query. This is the generic base that the maputnik-specific
- * assertable extends.
- */
-export class Assertable<T> {
-  constructor(private readonly target: T) {}
-
-  private locator(): Locator {
-    if (!isLocator(this.target)) throw new Error("Expected a Locator target for this assertion");
-    return this.target;
-  }
-
-  protected async assertValue(assertion: (value: any) => void): Promise<void> {
-    const target = this.target;
-    if (isQuery(target)) {
-      await retry(async () => assertion(await target.get()));
-    } else {
-      assertion(await (target as any));
-    }
-  }
-
-  // Element assertions (auto-retrying via Playwright web-first assertions).
-  shouldBeVisible = () => expect(this.locator().first()).toBeVisible();
-  // Some testids resolve to many elements that are always rendered but hidden
-  // (e.g. per-field documentation panels); "not visible" means none is visible.
-  shouldNotBeVisible = () => expect(this.locator().filter({ visible: true })).toHaveCount(0);
-  shouldExist = async () => {
-    if (isLocator(this.target)) {
-      await expect(this.locator().first()).toBeAttached();
-    } else {
-      await this.assertValue((value) => expect(value).toBeTruthy());
-    }
-  };
-  shouldNotExist = () => expect(this.locator()).toHaveCount(0);
-  shouldBeFocused = () => expect(this.locator().first()).toBeFocused();
-  shouldNotBeFocused = () => expect(this.locator().first()).not.toBeFocused();
-  shouldHaveValue = (value: string) => expect(this.locator().first()).toHaveValue(value);
-  shouldContainText = async (text: string) => {
-    const locator = this.locator();
-    // Prefer the visible element when a testid resolves to several (only the
-    // open documentation panel is visible; the rest are hidden in the DOM).
-    const target = (await locator.count()) > 1 ? locator.filter({ visible: true }).first() : locator.first();
-    await expect(target).toContainText(text);
-  };
-  shouldHaveText = (text: string) => expect(this.locator().first()).toHaveText(text);
-  shouldHaveLength = (length: number) => expect(this.locator()).toHaveCount(length);
-  shouldHaveCss = (property: string, value: string) => expect(this.locator().first()).toHaveCSS(property, value);
-
-  // Value assertions (auto-retrying for Query targets).
-  shouldEqual = (value: any) => this.assertValue((actual) => expect(actual).toBe(value));
-
-  shouldInclude = (value: any) =>
-    this.assertValue((actual) => {
-      if (typeof value === "object" && value !== null) {
-        expect(actual).toMatchObject(value);
-      } else {
-        expect(String(actual)).toContain(String(value));
-      }
-    });
-
-  shouldDeepNestedInclude = (value: Record<string, unknown> | unknown[]) =>
-    this.assertValue((actual) => assertDeepNestedInclude(actual, value));
-}
-
-async function typeSequence(page: Page, text: string): Promise<void> {
-  const tokens = text.match(/\{[^}]+\}|[^{]+/g) ?? [];
-  const modifierMap: Record<string, string> = { meta: "Meta", ctrl: "Control", shift: "Shift", alt: "Alt" };
-  const namedKeys: Record<string, string> = {
-    esc: "Escape",
-    enter: "Enter",
-    backspace: "Backspace",
-    del: "Delete",
-    tab: "Tab",
-    home: "Home",
-    end: "End",
-    rightarrow: "ArrowRight",
-  };
-
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (!token.startsWith("{") || !token.endsWith("}")) {
-      await page.keyboard.type(token);
-      continue;
-    }
-    const name = token.slice(1, -1).toLowerCase();
-    if (name === "selectall") {
-      await page.keyboard.press(isMac ? "Meta+a" : "Control+a");
-    } else if (namedKeys[name]) {
-      await page.keyboard.press(namedKeys[name]);
-    } else if (modifierMap[name]) {
-      const modifiers = [modifierMap[name]];
-      let j = i + 1;
-      while (j < tokens.length && /^\{(meta|ctrl|shift|alt)\}$/i.test(tokens[j])) {
-        modifiers.push(modifierMap[tokens[j].slice(1, -1).toLowerCase()]);
-        j++;
-      }
-      const key = tokens[j] ?? "";
-      await page.keyboard.press([...modifiers, key].join("+"));
-      i = j;
-    }
-  }
-}
-
-async function centerOf(locator: Locator): Promise<{ x: number; y: number }> {
-  const box = await locator.boundingBox();
-  if (!box) throw new Error("Element has no bounding box");
-  return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
-}
-
-/**
- * This is where all plywright-specific test helpers live.
- * It is used by the MaputnikDriver to implement the Maputnik-specific test helpers.
- */
-export class PlaywrightHelper {
-  private readonly recordedRequests = new Map<string, Request[]>();
-
-  private get page(): Page {
-    return currentPage();
-  }
-
-  private testId(testId: string): Locator {
-    return this.page.locator(testIdSelector(testId));
-  }
-
-  /** Reads and parses a JSON fixture from the fixtures directory. */
-  public readFixture(name: string): any {
-    return JSON.parse(fs.readFileSync(path.join(FIXTURES_DIR, name), "utf-8"));
-  }
-
-  /** Wraps a lazily-evaluated value so assertions on it auto-retry. */
-  public query<T>(getter: () => Promise<T>): Query<T> {
-    return new Query<T>(getter);
-  }
-
-  /** Stubs the File System Access "save" picker so file saves complete headlessly. */
-  public stubSaveFilePicker(): Promise<void> {
-    return this.page.evaluate(() => {
-      (window as any).showSaveFilePicker = async () => ({
-        createWritable: async () => ({ write: async () => {}, close: async () => {} }),
-      });
-    });
-  }
-
-  /** Entry point for fluent assertions over a Locator or a value/Query. */
-  public then = <T>(target: T): Assertable<T> => new Assertable(target);
-
-  public given = {
-    /**
-     * Removes the File System Access API so the app falls back to a plain
-     * <input type="file">, the way Firefox and Safari behave. Must be called
-     * before the page under test is loaded.
-     */
-    noFileSystemAccessApi: async () => {
-      await this.page.addInitScript(() => {
-        delete (window as any).showOpenFilePicker;
-        delete (window as any).showSaveFilePicker;
-      });
-    },
-
-    intercept: async (pattern: RegExp, alias: string, _method = "GET") => {
-      this.recordedRequests.set(alias, []);
-      await this.page.route(pattern, (route) => {
-        this.recordedRequests.get(alias)!.push(route.request());
-        route.continue();
-      });
-    },
-
-    interceptAndMockResponse: async (options: {
-      method?: string;
-      url: string | RegExp;
-      response: unknown | { fixture: string };
-      alias?: string;
-    }) => {
-      const { url, response, alias } = options;
-      if (alias) this.recordedRequests.set(alias, []);
-      await this.page.route(url, (route) => {
-        if (alias) this.recordedRequests.get(alias)!.push(route.request());
-        const body =
-          response && typeof response === "object" && "fixture" in (response as any)
-            ? this.readFixture((response as { fixture: string }).fixture)
-            : response;
-        route.fulfill({ json: body });
-      });
-    },
-  };
-
-  public when = {
-    visit: async (url: string) => {
-      // Snapshot coverage before navigating, since a full page load resets it.
-      await recordCoverageChunk(this.page);
-      await this.page.goto(url);
-    },
-
-    wait: (ms: number) => this.page.waitForTimeout(ms),
-
-    tab: () => this.page.keyboard.press("Tab"),
-
-    typeKeys: (keys: string) => typeSequence(this.page, keys),
-
-    /** Types raw text into the focused element (no "{key}" sequence parsing). */
-    typeText: (text: string) => this.page.keyboard.type(text),
-
-    clickButtonByName: async (name: string) => {
-      await this.page.getByRole("button", { name }).click();
-    },
-
-    click: async (testId: string, index = 0) => {
-      // Documentation buttons are wrapped in a <label>/.maputnik-doc-target that
-      // Playwright treats as intercepting the click; bypass the check for them.
-      const force = testId.startsWith("field-doc-button-");
-      await this.testId(testId).nth(index).click({ force });
-    },
-
-    realClick: async (testId: string) => {
-      await this.testId(testId).click();
-    },
-
-    hover: async (testId: string) => {
-      await this.testId(testId).hover();
-    },
-
-    focus: async (testId: string) => {
-      await this.testId(testId).focus();
-    },
-
-    clear: async (testId: string) => {
-      await this.testId(testId).clear();
-    },
-
-    select: async (testId: string, value: string) => {
-      await this.testId(testId).selectOption(value);
-    },
-
-    selectWithin: async (parentTestId: string, value: string) => {
-      await this.testId(parentTestId).locator("select").selectOption(value);
-    },
-
-    clickWithin: async (parentTestId: string, selector: string) => {
-      await this.testId(parentTestId).locator(selector).first().click();
-    },
-
-    clickByText: async (text: string) => {
-      await this.page.getByText(text).click();
-    },
-
-    clickByAttribute: async (attribute: string, value: string) => {
-      await this.page.locator(`[${attribute}="${value}"]`).click();
-    },
-
-    scrollToBottom: async (element: Locator) => {
-      await element.evaluate((el) => el.scrollTo(0, el.scrollHeight));
-    },
-
-    setValue: async (testId: string, text: string) => {
-      const input = this.testId(testId);
-      await input.fill("");
-      await input.fill(text);
-    },
-
-    type: async (testId: string, text: string) => {
-      await this.testId(testId).focus();
-      // Place the caret at the start of the field, so a leading "{backspace}"
-      // is a no-op rather than clearing an already-committed value.
-      await this.page.keyboard.press("Home");
-      await typeSequence(this.page, text);
-    },
-
-    dragAndDropWithWait: async (source: string, target: string) => {
-      const from = await centerOf(this.testId(source));
-      const to = await centerOf(this.testId(target));
-      await this.page.mouse.move(from.x, from.y);
-      await this.page.mouse.down();
-      await this.page.mouse.move(from.x, from.y + 10);
-      await this.page.mouse.move(to.x, to.y, { steps: 10 });
-      await this.page.waitForTimeout(100);
-      await this.page.mouse.up();
-    },
-
-    clickCenter: async (testId: string) => {
-      const { x, y } = await centerOf(this.testId(testId));
-      await this.page.mouse.move(x, y);
-      await this.page.mouse.down();
-      await this.page.waitForTimeout(200);
-      await this.page.mouse.up();
-    },
-
-    /**
-     * Opens a fixture through the File System Access API, which raises no
-     * "filechooser" event and so has to be stubbed. For the <input type="file">
-     * fallback that browsers without the API use, see chooseFileFromPicker.
-     */
-    openFileByFixture: async (fixture: string, buttonTestId: string) => {
-      const content = JSON.stringify(this.readFixture(fixture));
-      await this.page.evaluate((fileContent) => {
-        (window as any).showOpenFilePicker = async () => [
-          { getFile: async () => ({ text: async () => fileContent }) },
-        ];
-      }, content);
-      await this.testId(buttonTestId).click();
-    },
-
-    /**
-     * Clicks a control that opens the browser's native file chooser and answers
-     * it with a fixture. Only works on the <input type="file"> path — the File
-     * System Access API does not raise a "filechooser" event, so pair this with
-     * given.noFileSystemAccessApi().
-     */
-    chooseFileFromPicker: async (fixture: string, triggerTestId: string) => {
-      const content = JSON.stringify(this.readFixture(fixture));
-      const [fileChooser] = await Promise.all([
-        this.page.waitForEvent("filechooser"),
-        this.testId(triggerTestId).click(),
-      ]);
-      await fileChooser.setFiles({
-        name: fixture,
-        mimeType: "application/json",
-        buffer: Buffer.from(content),
-      });
-    },
-
-    dropFileByFixture: async (fixture: string, dropzoneTestId: string) => {
-      const content = JSON.stringify(this.readFixture(fixture));
-      const dataTransfer = await this.page.evaluateHandle((fileContent) => {
-        const dt = new DataTransfer();
-        dt.items.add(new File([fileContent], "example-style.json", { type: "application/json" }));
-        return dt;
-      }, content);
-      const dropzone = this.testId(dropzoneTestId);
-      await dropzone.dispatchEvent("dragenter", { dataTransfer });
-      await dropzone.dispatchEvent("dragover", { dataTransfer });
-      await dropzone.dispatchEvent("drop", { dataTransfer });
-    },
-
-    waitForResponse: async (alias: string) => {
-      const requests = this.recordedRequests.get(alias);
-      if (!requests) throw new Error(`No intercept registered for alias "${alias}"`);
-      await retry(async () => {
-        if (requests.length === 0) throw new Error(`No request recorded for alias "${alias}"`);
-      });
-      return requests[requests.length - 1];
-    },
-
-    clearLocalStorage: () => this.page.evaluate(() => window.localStorage.clear()),
-
-    /** Writes to localStorage under `keyPrefix` until a QuotaExceededError is hit. */
-    fillLocalStorageUntilQuota: (keyPrefix: string) =>
-      this.page.evaluate((prefix) => {
-        let chunkSize = 1000;
-        const chunk = new Array(chunkSize).join("x");
-        let index = 0;
-        while (true) {
-          try {
-            window.localStorage.setItem(`${prefix}${index++}`, chunk);
-          } catch (e: any) {
-            if (e.name === "QuotaExceededError") {
-              if (chunkSize <= 1) return;
-              chunkSize /= 2;
-              continue;
-            }
-            throw e; // Unexpected error
-          }
-        }
-      }, keyPrefix),
-  };
-
-  public get = {
-    element: (selector: string) => this.page.locator(selector),
-
-    localStorageItem: (key: string) =>
-      this.page.evaluate((k) => window.localStorage.getItem(k), key),
-
-    elementByTestId: (testId: string) => this.testId(testId),
-
-    inputValue: (testId: string) => new Query<string>(() => this.testId(testId).first().inputValue()),
-
-    elementsText: (testId: string) => new Query<string>(() => this.testId(testId).first().innerText()),
-
-    locationHash: () => new Query<string>(async () => new URL(this.page.url()).hash),
-  };
-}

e2e/utils/fixtures.ts

@@ -1,82 +0,0 @@
-import { test, expect, type Page } from "@playwright/test";
-import fs from "node:fs";
-import path from "node:path";
-
-let activePage: Page | undefined;
-const coverageChunks: unknown[] = [];
-
-/** The page for the currently running test. Throws if used outside a test. */
-export function currentPage(): Page {
-  if (!activePage) {
-    throw new Error("No active page: a MaputnikDriver method was called outside of a running test.");
-  }
-  return activePage;
-}
-
-const OUTPUT_DIR = path.resolve(process.cwd(), ".nyc_output");
-
-/**
- * Reads the istanbul coverage object (injected by vite-plugin-istanbul) from the
- * given page. Returns `null` when the page has not been instrumented.
- */
-async function readCoverage(page: Page): Promise<unknown | null> {
-  try {
-    return await page.evaluate(() => (window as unknown as { __coverage__?: unknown }).__coverage__ ?? null);
-  } catch {
-    // Page might be navigating/closed.
-    return null;
-  }
-}
-
-/**
- * Persists a coverage chunk to `.nyc_output` so that `nyc report` can merge it.
- * istanbul-lib-coverage (used by nyc) sums the hit counts across every file it
- * finds, so writing one file per chunk is enough to accumulate coverage across
- * navigations and tests.
- */
-export function writeCoverage(coverage: unknown, id: string): void {
-  if (!coverage) return;
-  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
-  fs.writeFileSync(path.join(OUTPUT_DIR, `playwright-${id}.json`), JSON.stringify(coverage));
-}
-
-/** Records a coverage snapshot (called before navigations, which reset __coverage__). */
-export async function recordCoverageChunk(page: Page): Promise<void> {
-  const chunk = await readCoverage(page);
-  if (chunk) coverageChunks.push(chunk);
-}
-
-/**
- * Auto fixture that binds the current test's page for the (page-lazy)
- * MaputnikDriver, auto-accepts confirm dialogs, and writes the istanbul
- * coverage collected during the test to `.nyc_output`.
- */
-const extendedTest = test.extend<{ maputnikPage: void }>({
-  maputnikPage: [
-    async ({ page }, use, testInfo) => {
-      activePage = page;
-      coverageChunks.length = 0;
-      // Accept confirm dialogs (e.g. the "replace current style" prompt). These
-      // are dismissed by default, which would cancel loading a style via URL.
-      page.on("dialog", (dialog) => dialog.accept().catch(() => undefined));
-
-      await use();
-
-      const finalCoverage = await readCoverage(page);
-      if (finalCoverage) coverageChunks.push(finalCoverage);
-      coverageChunks.forEach((chunk, index) => writeCoverage(chunk, `${testInfo.testId}-${index}`));
-      coverageChunks.length = 0;
-      activePage = undefined;
-    },
-    { auto: true },
-  ],
-});
-
-const describe = extendedTest.describe;
-const beforeEach = extendedTest.beforeEach;
-export {
-  expect,
-  describe,
-  extendedTest as test,
-  beforeEach,
-};

eslint.config.js

@@ -32,11 +32,9 @@ export default defineConfig({
     "@stylistic": stylisticTs
   },
   rules: {
-    "react-hooks/rules-of-hooks": "error",
-    "react-hooks/exhaustive-deps": "warn",
     "react-refresh/only-export-components": [
       "warn",
-      { allowConstantExport: true, extraHOCs: ["withTranslation"] }
+      { allowConstantExport: true }
     ],
     "@typescript-eslint/no-explicit-any": "off",
     "@typescript-eslint/no-unused-vars": [

package.json

@@ -28,9 +28,9 @@
   "dependencies": {
     "@codemirror/lang-json": "^6.0.2",
     "@codemirror/lint": "^6.9.7",
-    "@codemirror/state": "^6.7.1",
+    "@codemirror/state": "^6.7.0",
     "@codemirror/theme-one-dark": "^6.1.3",
-    "@codemirror/view": "^6.43.6",
+    "@codemirror/view": "^6.43.5",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
@@ -124,6 +124,8 @@
     "@types/string-hash": "^1.1.3",
     "@types/wicg-file-system-access": "^2023.10.7",
     "@vitejs/plugin-react": "5.2",
+    "@vitest/browser": "^4.1.10",
+    "@vitest/browser-playwright": "^4.1.10",
     "@vitest/coverage-v8": "^4.1.10",
     "cors": "^2.8.6",
     "eslint": "^10.6.0",
@@ -145,6 +147,7 @@
     "uuid": "^14.0.1",
     "vite": "^7.3.2",
     "vite-plugin-istanbul": "^9.0.1",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "vitest-browser-react": "^2.2.0"
   }
 }

playwright.config.ts

@@ -9,8 +9,8 @@ const baseURL = process.env.E2E_BASE_URL ?? "http://localhost:8888/";
 export default defineConfig({
   testDir: "./e2e",
   testMatch: "**/*.spec.ts",
-  globalSetup: "./e2e/utils/e2e-setup.ts",
+  globalSetup: "./e2e/global-setup.ts",
-  globalTeardown: "./e2e/utils/e2e-teardown.ts",
+  globalTeardown: "./e2e/global-teardown.ts",
   fullyParallel: true,
   forbidOnly: isCI,
   retries: isCI ? 2 : 0,

src/components/AppLayout.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { ScrollContainer } from "./ScrollContainer";
+import ScrollContainer from "./ScrollContainer";
 import { type WithTranslation, withTranslation } from "react-i18next";
 import { IconContext } from "react-icons";
 
@@ -13,38 +13,42 @@ type AppLayoutInternalProps = {
   modals?: React.ReactNode
 } & WithTranslation;
 
-const AppLayoutInternal: React.FC<AppLayoutInternalProps> = (props) => {
+class AppLayoutInternal extends React.Component<AppLayoutInternalProps> {
-  document.body.dir = props.i18n.dir();
+
+  render() {
+    document.body.dir = this.props.i18n.dir();
 
     return <IconContext.Provider value={{size: "14px"}}>
       <div className="maputnik-layout">
-      {props.toolbar}
+        {this.props.toolbar}
         <div className="maputnik-layout-main">
-        {props.codeEditor && <div className="maputnik-layout-code-editor">
+          {this.props.codeEditor && <div className="maputnik-layout-code-editor">
             <ScrollContainer>
-            {props.codeEditor}
+              {this.props.codeEditor}
             </ScrollContainer>
           </div>
           }
-        {!props.codeEditor && <>
+          {!this.props.codeEditor && <>
             <div className="maputnik-layout-list">
-            {props.layerList}
+              {this.props.layerList}
             </div>
             <div className="maputnik-layout-drawer">
               <ScrollContainer>
-              {props.layerEditor}
+                {this.props.layerEditor}
               </ScrollContainer>
             </div>
           </>}
-        {props.map}
+          {this.props.map}
         </div>
-      {props.bottom && <div className="maputnik-layout-bottom">
+        {this.props.bottom && <div className="maputnik-layout-bottom">
-        {props.bottom}
+          {this.props.bottom}
         </div>
         }
-      {props.modals}
+        {this.props.modals}
       </div>
     </IconContext.Provider>;
-};
+  }
+}
 
-export const AppLayout = withTranslation()(AppLayoutInternal);
+const AppLayout = withTranslation()(AppLayoutInternal);
+export default AppLayout;

src/components/AppMessagePanel.tsx

@@ -13,16 +13,18 @@ type AppMessagePanelInternalProps = {
   selectedLayerIndex?: number
 } & WithTranslation;
 
-const AppMessagePanelInternal: React.FC<AppMessagePanelInternalProps> = ({
+class AppMessagePanelInternal extends React.Component<AppMessagePanelInternalProps> {
-  onLayerSelect = () => { },
+  static defaultProps = {
-  ...props
+    onLayerSelect: () => { },
-}) => {
+  };
-  const { t, selectedLayerIndex } = props;
+
-  const errors = props.errors?.map((error, idx) => {
+  render() {
+    const { t, selectedLayerIndex } = this.props;
+    const errors = this.props.errors?.map((error, idx) => {
       let content;
       if (error.parsed && error.parsed.type === "layer") {
         const { parsed } = error;
-      const layerId = props.mapStyle?.layers[parsed.data.index].id;
+        const layerId = this.props.mapStyle?.layers[parsed.data.index].id;
         content = (
           <>
             {t("Layer")} <span>{formatLayerId(layerId)}</span>: {parsed.data.message}
@@ -31,7 +33,7 @@ const AppMessagePanelInternal: React.FC<AppMessagePanelInternalProps> = ({
                 &nbsp;&mdash;&nbsp;
                 <button
                   className="maputnik-message-panel__switch-button"
-                onClick={() => onLayerSelect!(parsed.data.index)}
+                  onClick={() => this.props.onLayerSelect!(parsed.data.index)}
                 >
                   {t("switch to layer")}
                 </button>
@@ -48,7 +50,7 @@ const AppMessagePanelInternal: React.FC<AppMessagePanelInternalProps> = ({
       </p>;
     });
 
-  const infos = props.infos?.map((m, i) => {
+    const infos = this.props.infos?.map((m, i) => {
       return <p key={"info-" + i}>{m}</p>;
     });
 
@@ -56,6 +58,8 @@ const AppMessagePanelInternal: React.FC<AppMessagePanelInternalProps> = ({
       {errors}
       {infos}
     </div>;
-};
+  }
+}
 
-export const AppMessagePanel = withTranslation()(AppMessagePanelInternal);
+const AppMessagePanel = withTranslation()(AppMessagePanelInternal);
+export default AppMessagePanel;

src/components/AppToolbar.tsx

@@ -31,9 +31,11 @@ type IconTextProps = {
 };
 
 
-const IconText: React.FC<IconTextProps> = (props) => {
+class IconText extends React.Component<IconTextProps> {
-  return <span className="maputnik-icon-text">{props.children}</span>;
+  render() {
-};
+    return <span className="maputnik-icon-text">{this.props.children}</span>;
+  }
+}
 
 type ToolbarLinkProps = {
   className?: string
@@ -41,31 +43,35 @@ type ToolbarLinkProps = {
   href?: string
 };
 
-const ToolbarLink: React.FC<ToolbarLinkProps> = (props) => {
+class ToolbarLink extends React.Component<ToolbarLinkProps> {
+  render() {
     return <a
-    className={classnames("maputnik-toolbar-link", props.className)}
+      className={classnames("maputnik-toolbar-link", this.props.className)}
-    href={props.href}
+      href={this.props.href}
       rel="noopener noreferrer"
       target="_blank"
       data-wd-key="toolbar:link"
     >
-    {props.children}
+      {this.props.children}
     </a>;
-};
+  }
+}
 
 type ToolbarSelectProps = {
   children?: React.ReactNode
   wdKey?: string
 };
 
-const ToolbarSelect: React.FC<ToolbarSelectProps> = (props) => {
+class ToolbarSelect extends React.Component<ToolbarSelectProps> {
+  render() {
     return <div
       className='maputnik-toolbar-select'
-    data-wd-key={props.wdKey}
+      data-wd-key={this.props.wdKey}
     >
-    {props.children}
+      {this.props.children}
     </div>;
-};
+  }
+}
 
 type ToolbarActionProps = {
   children?: React.ReactNode
@@ -73,15 +79,17 @@ type ToolbarActionProps = {
   wdKey?: string
 };
 
-const ToolbarAction: React.FC<ToolbarActionProps> = (props) => {
+class ToolbarAction extends React.Component<ToolbarActionProps> {
+  render() {
     return <button
       className='maputnik-toolbar-action'
-    data-wd-key={props.wdKey}
+      data-wd-key={this.props.wdKey}
-    onClick={props.onClick}
+      onClick={this.props.onClick}
     >
-    {props.children}
+      {this.props.children}
     </button>;
-};
+  }
+}
 
 export type MapState = "map" | "inspect" | "filter-achromatopsia" | "filter-deuteranopia" | "filter-protanopia" | "filter-tritanopia";
 
@@ -100,16 +108,26 @@ type AppToolbarInternalProps = {
   renderer?: string
 } & WithTranslation;
 
-const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
+class AppToolbarInternal extends React.Component<AppToolbarInternalProps> {
-  function handleSelection(val: MapState) {
+  state = {
-    props.onSetMapState(val);
+    isOpen: {
+      settings: false,
+      sources: false,
+      open: false,
+      add: false,
+      export: false,
+    }
+  };
+
+  handleSelection(val: MapState) {
+    this.props.onSetMapState(val);
   }
 
-  function handleLanguageChange(val: string) {
+  handleLanguageChange(val: string) {
-    props.i18n.changeLanguage(val);
+    this.props.i18n.changeLanguage(val);
   }
 
-  const onSkip = (target: string) => {
+  onSkip = (target: string) => {
     if (target === "map") {
       (document.querySelector(".maplibregl-canvas") as HTMLCanvasElement).focus();
     }
@@ -119,7 +137,8 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
     }
   };
 
-  const t = props.t;
+  render() {
+    const t = this.props.t;
     const views = [
       {
         id: "map",
@@ -130,7 +149,7 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
         id: "inspect",
         group: "general",
         title: t("Inspect"),
-      disabled: props.renderer === "ol",
+        disabled: this.props.renderer === "ol",
       },
       {
         id: "filter-deuteranopia",
@@ -159,7 +178,7 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
     ];
 
     const currentView = views.find((view) => {
-    return view.id === props.mapState;
+      return view.id === this.props.mapState;
     });
 
     return <nav className='maputnik-toolbar'>
@@ -171,21 +190,21 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
           <button
             data-wd-key="root:skip:layer-list"
             className="maputnik-toolbar-skip"
-          onClick={_e => onSkip("layer-list")}
+            onClick={_e => this.onSkip("layer-list")}
           >
             {t("Layers list")}
           </button>
           <button
             data-wd-key="root:skip:layer-editor"
             className="maputnik-toolbar-skip"
-          onClick={_e => onSkip("layer-editor")}
+            onClick={_e => this.onSkip("layer-editor")}
           >
             {t("Layer editor")}
           </button>
           <button
             data-wd-key="root:skip:map-view"
             className="maputnik-toolbar-skip"
-          onClick={_e => onSkip("map")}
+            onClick={_e => this.onSkip("map")}
           >
             {t("Map view")}
           </button>
@@ -203,27 +222,27 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
           </a>
         </div>
         <div className="maputnik-toolbar__actions" role="navigation" aria-label="Toolbar">
-        <ToolbarAction wdKey="nav:open" onClick={() => props.onToggleModal("open")}>
+          <ToolbarAction wdKey="nav:open" onClick={() => this.props.onToggleModal("open")}>
             <MdOpenInBrowser />
             <IconText>{t("Open")}</IconText>
           </ToolbarAction>
-        <ToolbarAction wdKey="nav:export" onClick={() => props.onToggleModal("export")}>
+          <ToolbarAction wdKey="nav:export" onClick={() => this.props.onToggleModal("export")}>
             <MdSave />
             <IconText>{t("Save")}</IconText>
           </ToolbarAction>
-        <ToolbarAction wdKey="nav:code-editor" onClick={() => props.onToggleModal("codeEditor")}>
+          <ToolbarAction wdKey="nav:code-editor" onClick={() => this.props.onToggleModal("codeEditor")}>
             <MdCode />
             <IconText>{t("Code Editor")}</IconText>
           </ToolbarAction>
-        <ToolbarAction wdKey="nav:sources" onClick={() => props.onToggleModal("sources")}>
+          <ToolbarAction wdKey="nav:sources" onClick={() => this.props.onToggleModal("sources")}>
             <MdLayers />
             <IconText>{t("Data Sources")}</IconText>
           </ToolbarAction>
-        <ToolbarAction wdKey="nav:settings" onClick={() => props.onToggleModal("settings")}>
+          <ToolbarAction wdKey="nav:settings" onClick={() => this.props.onToggleModal("settings")}>
             <MdSettings />
             <IconText>{t("Style Settings")}</IconText>
           </ToolbarAction>
-        <ToolbarAction wdKey="nav:global-state" onClick={() => props.onToggleModal("globalState")}>
+          <ToolbarAction wdKey="nav:global-state" onClick={() => this.props.onToggleModal("globalState")}>
             <MdPublic />
             <IconText>{t("Global State")}</IconText>
           </ToolbarAction>
@@ -234,7 +253,7 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
               <select
                 className="maputnik-select"
                 data-wd-key="maputnik-select"
-              onChange={(e) => handleSelection(e.target.value as MapState)}
+                onChange={(e) => this.handleSelection(e.target.value as MapState)}
                 value={currentView?.id}
               >
                 {views.filter(v => v.group === "general").map((item) => {
@@ -263,8 +282,8 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
               <select
                 className="maputnik-select"
                 data-wd-key="maputnik-lang-select"
-              onChange={(e) => handleLanguageChange(e.target.value)}
+                onChange={(e) => this.handleLanguageChange(e.target.value)}
-              value={props.i18n.language}
+                value={this.props.i18n.language}
               >
                 {Object.entries(supportedLanguages).map(([code, name]) => {
                   return (
@@ -284,6 +303,8 @@ const AppToolbarInternal: React.FC<AppToolbarInternalProps> = (props) => {
         </div>
       </div>
     </nav>;
-};
+  }
+}
 
-export const AppToolbar = withTranslation()(AppToolbarInternal);
+const AppToolbar = withTranslation()(AppToolbarInternal);
+export default AppToolbar;

src/components/Block.tsx

@@ -1,7 +1,7 @@
-import React, {type CSSProperties, type PropsWithChildren, type SyntheticEvent, useRef, useState} from "react";
+import React, {type CSSProperties, type PropsWithChildren, type SyntheticEvent} from "react";
 import classnames from "classnames";
-import { FieldDocLabel } from "./FieldDocLabel";
+import FieldDocLabel from "./FieldDocLabel";
-import { Doc } from "./Doc";
+import Doc from "./Doc";
 
 export type BlockProps = PropsWithChildren & {
   "data-wd-key"?: string
@@ -14,13 +14,32 @@ export type BlockProps = PropsWithChildren & {
   error?: {message: string}
 };
 
-/** Wrap a component with a label */
+type BlockState = {
-export const Block: React.FC<BlockProps> = (props) => {
+  showDoc: boolean
-  const [showDoc, setShowDoc] = useState(false);
+};
-  const blockEl = useRef<HTMLDivElement | null>(null);
 
-  const onToggleDoc = (val: boolean) => {
+/** Wrap a component with a label */
-    setShowDoc(val);
+export default class Block extends React.Component<BlockProps, BlockState> {
+  _blockEl: HTMLDivElement | null = null;
+
+  constructor (props: BlockProps) {
+    super(props);
+    this.state = {
+      showDoc: false,
+    };
+  }
+
+  onChange(e: React.BaseSyntheticEvent<Event, HTMLInputElement, HTMLInputElement>) {
+    const value = e.target.value;
+    if (this.props.onChange) {
+      return this.props.onChange(value === "" ? undefined : value);
+    }
+  }
+
+  onToggleDoc = (val: boolean) => {
+    this.setState({
+      showDoc: val
+    });
   };
 
   /**
@@ -29,9 +48,9 @@ export const Block: React.FC<BlockProps> = (props) => {
    * causing the picker to reopen. This causes a scenario where the picker can
    * never be closed once open.
    */
-  const onLabelClick = (event: SyntheticEvent<any, any>) => {
+  onLabelClick = (event: SyntheticEvent<any, any>) => {
     const el = event.nativeEvent.target;
-    const contains = blockEl.current?.contains(el);
+    const contains = this._blockEl?.contains(el);
 
     if (event.nativeEvent.target.nodeName !== "INPUT" && !contains) {
       event.stopPropagation();
@@ -41,43 +60,45 @@ export const Block: React.FC<BlockProps> = (props) => {
     }
   };
 
-  return <label style={props.style}
+  render() {
-    data-wd-key={props["data-wd-key"]}
+    return <label style={this.props.style}
+      data-wd-key={this.props["data-wd-key"]}
       className={classnames({
         "maputnik-input-block": true,
-      "maputnik-input-block--wide": props.wideMode,
+        "maputnik-input-block--wide": this.props.wideMode,
-      "maputnik-action-block": props.action,
+        "maputnik-action-block": this.props.action,
-      "maputnik-input-block--error": props.error
+        "maputnik-input-block--error": this.props.error
       })}
-    onClick={onLabelClick}
+      onClick={this.onLabelClick}
     >
-    {props.fieldSpec &&
+      {this.props.fieldSpec &&
         <div className="maputnik-input-block-label">
           <FieldDocLabel
-          label={props.label}
+            label={this.props.label}
-          onToggleDoc={onToggleDoc}
+            onToggleDoc={this.onToggleDoc}
-          fieldSpec={props.fieldSpec}
+            fieldSpec={this.props.fieldSpec}
           />
         </div>
       }
-    {!props.fieldSpec &&
+      {!this.props.fieldSpec &&
         <div className="maputnik-input-block-label">
-        {props.label}
+          {this.props.label}
         </div>
       }
       <div className="maputnik-input-block-action">
-      {props.action}
+        {this.props.action}
       </div>
-    <div className="maputnik-input-block-content" ref={blockEl}>
+      <div className="maputnik-input-block-content" ref={el => {this._blockEl = el;}}>
-      {props.children}
+        {this.props.children}
       </div>
-    {props.fieldSpec &&
+      {this.props.fieldSpec &&
         <div
           className="maputnik-doc-inline"
-        style={{display: showDoc ? "" : "none"}}
+          style={{display: this.state.showDoc ? "" : "none"}}
         >
-        <Doc fieldSpec={props.fieldSpec} />
+          <Doc fieldSpec={this.props.fieldSpec} />
         </div>
       }
     </label>;
-};
+  }
+}

src/components/CodeEditor.tsx

@@ -1,4 +1,4 @@
-import { InputJson } from "./InputJson";
+import InputJson from "./InputJson";
 import React from "react";
 import { withTranslation, type WithTranslation } from "react-i18next";
 import { type StyleSpecification } from "maplibre-gl";
@@ -24,4 +24,6 @@ const CodeEditorInternal: React.FC<CodeEditorProps> = (props) => {
   </>;
 };
 
-export const CodeEditor = withTranslation()(CodeEditorInternal);
+const CodeEditor = withTranslation()(CodeEditorInternal);
+
+export default CodeEditor;

src/components/Collapse.tsx

@@ -9,19 +9,25 @@ type CollapseProps = {
 };
 
 
-export const Collapse: React.FC<CollapseProps> = ({isActive = true, children}) => {
+export default class Collapse extends React.Component<CollapseProps> {
+  static defaultProps = {
+    isActive: true
+  };
+
+  render() {
     if (reducedMotionEnabled()) {
       return (
-      <div style={{display: isActive ? "block" : "none"}}>
+        <div style={{display: this.props.isActive ? "block" : "none"}}>
-        {children}
+          {this.props.children}
         </div>
       );
     }
     else {
       return (
-      <ReactCollapse isOpened={isActive}>
+        <ReactCollapse isOpened={this.props.isActive}>
-        {children}
+          {this.props.children}
         </ReactCollapse>
       );
     }
-};
+  }
+}

src/components/Collapser.tsx

@@ -6,11 +6,13 @@ type CollapserProps = {
   style?: object
 };
 
-export const Collapser: React.FC<CollapserProps> = (props) => {
+export default class Collapser extends React.Component<CollapserProps> {
+  render() {
     const iconStyle = {
       width: 20,
       height: 20,
-    ...props.style,
+      ...this.props.style,
     };
-  return props.isCollapsed ? <MdArrowDropUp style={iconStyle}/> : <MdArrowDropDown style={iconStyle} />;
+    return this.props.isCollapsed ? <MdArrowDropUp style={iconStyle}/> : <MdArrowDropDown style={iconStyle} />;
-};
+  }
+}

src/components/DataProperty.tsx

@@ -1,371 +0,0 @@
-import React, { useRef } from "react";
-import {PiListPlusBold} from "react-icons/pi";
-import {TbMathFunction} from "react-icons/tb";
-import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
-
-import { InputButton } from "./InputButton";
-import { InputSpec } from "./InputSpec";
-import { InputNumber } from "./InputNumber";
-import { InputString } from "./InputString";
-import { InputSelect } from "./InputSelect";
-import { Block } from "./Block";
-import { generateUniqueId as docUid } from "../libs/document-uid";
-import { sortNumerically } from "../libs/sort-numerically";
-import {findDefaultFromSpec} from "../libs/spec-helper";
-import { type WithTranslation, withTranslation } from "react-i18next";
-
-import { labelFromFieldName } from "../libs/label-from-field-name";
-import { DeleteStopButton } from "./DeleteStopButton";
-import { type MappedLayerErrors } from "../libs/definitions";
-
-
-
-function setStopRefs(props: DataPropertyInternalProps, state: DataPropertyState) {
-  // This is initialised below only if required to improved performance.
-  let newRefs: {[key: number]: string} | undefined;
-
-  if(props.value && props.value.stops) {
-    props.value.stops.forEach((_val, idx) => {
-      if(!Object.prototype.hasOwnProperty.call(state.refs, idx)) {
-        if(!newRefs) {
-          newRefs = {...state};
-        }
-        newRefs[idx] = docUid("stop-");
-      }
-    });
-  }
-
-  return newRefs;
-}
-
-type DataPropertyInternalProps = {
-  onChange?(fieldName: string, value: any): unknown
-  onDeleteStop?(...args: unknown[]): unknown
-  onAddStop?(...args: unknown[]): unknown
-  onExpressionClick?(...args: unknown[]): unknown
-  onChangeToZoomFunction?(...args: unknown[]): unknown
-  fieldName: string
-  fieldType?: string
-  fieldSpec?: object
-  value?: DataPropertyValue
-  errors?: MappedLayerErrors
-} & WithTranslation;
-
-type DataPropertyState = {
-  refs: {[key: number]: string}
-};
-
-type DataPropertyValue = {
-  default?: any
-  property?: string
-  base?: number
-  type?: string
-  stops: Stop[]
-};
-
-export type Stop = [{
-  zoom: number
-  value: number
-}, number];
-
-const DataPropertyInternal: React.FC<DataPropertyInternalProps> = (props) => {
-  // Kept in a ref rather than state: the original recomputed these on every
-  // render via getDerivedStateFromProps, which as state would mean setting
-  // state during render on every pass.
-  const refs = useRef<{[key: number]: string}>({});
-  // setStopRefs returns undefined when no new stop needs a ref; as in the
-  // original, only replace the map when it actually produced one.
-  const newStopRefs = setStopRefs(props, { refs: refs.current });
-  if (newStopRefs) {
-    refs.current = newStopRefs;
-  }
-
-  function getFieldFunctionType(fieldSpec: any) {
-    if (fieldSpec.expression.interpolated) {
-      return "exponential";
-    }
-    if (fieldSpec.type === "number") {
-      return "interval";
-    }
-    return "categorical";
-  }
-
-  function getDataFunctionTypes(fieldSpec: any) {
-    if (fieldSpec.expression.interpolated) {
-      return ["interpolate", "categorical", "interval", "exponential", "identity"];
-    }
-    else {
-      return ["categorical", "interval", "identity"];
-    }
-  }
-
-  // Order the stops altering the refs to reflect their new position.
-  function orderStopsByZoom(stops: Stop[]) {
-    const mappedWithRef = stops
-      .map((stop, idx) => {
-        return {
-          ref: refs.current[idx],
-          data: stop
-        };
-      })
-    // Sort by zoom
-      .sort((a, b) => sortNumerically(a.data[0].zoom, b.data[0].zoom));
-
-    // Fetch the new position of the stops
-    const newRefs = {} as {[key: number]: string};
-    mappedWithRef
-      .forEach((stop, idx) =>{
-        newRefs[idx] = stop.ref;
-      });
-
-    refs.current = newRefs;
-
-    return mappedWithRef.map((item) => item.data);
-  }
-
-  const onChange = (fieldName: string, value: any) => {
-    if (value.type === "identity") {
-      value = {
-        type: value.type,
-        property: value.property,
-      };
-    }
-    else {
-      const stopValue = value.type === "categorical" ? "" : 0;
-      value = {
-        property: "",
-        type: value.type,
-        // Default props if they don't already exist.
-        stops: [
-          [{zoom: 6, value: stopValue}, findDefaultFromSpec(props.fieldSpec as any)],
-          [{zoom: 10, value: stopValue}, findDefaultFromSpec(props.fieldSpec as any)]
-        ],
-        ...value,
-      };
-    }
-    props.onChange!(fieldName, value);
-  };
-
-  function changeStop(changeIdx: number, stopData: { zoom: number | undefined, value: number }, value: number) {
-    const stops = props.value?.stops.slice(0) || [];
-    // const changedStop = stopData.zoom === undefined ? stopData.value : stopData
-    stops[changeIdx] = [
-      {
-        value: stopData.value,
-        zoom: (stopData.zoom === undefined) ? 0 : stopData.zoom,
-      },
-      value
-    ];
-
-    const orderedStops = orderStopsByZoom(stops);
-
-    const changedValue = {
-      ...props.value,
-      stops: orderedStops,
-    };
-    onChange(props.fieldName, changedValue);
-  }
-
-  function changeBase(newValue: number | undefined) {
-    const changedValue = {
-      ...props.value,
-      base: newValue
-    };
-
-    if (changedValue.base === undefined) {
-      delete changedValue["base"];
-    }
-    props.onChange!(props.fieldName, changedValue);
-  }
-
-  function changeDataType(propVal: string) {
-    if (propVal === "interpolate" && props.onChangeToZoomFunction) {
-      props.onChangeToZoomFunction();
-    }
-    else {
-      onChange(props.fieldName, {
-        ...props.value,
-        type: propVal,
-      });
-    }
-  }
-
-  function changeDataProperty(propName: "property" | "default", propVal: any) {
-    if (propVal) {
-      props.value![propName] = propVal;
-    }
-    else {
-      delete props.value![propName];
-    }
-    onChange(props.fieldName, props.value);
-  }
-
-  const t = props.t;
-
-  if (typeof props.value?.type === "undefined") {
-    props.value!.type = getFieldFunctionType(props.fieldSpec);
-  }
-
-  let dataFields;
-  if (props.value?.stops) {
-    dataFields = props.value.stops.map((stop, idx) => {
-      const zoomLevel = typeof stop[0] === "object" ? stop[0].zoom : undefined;
-      const key  = refs.current[idx];
-      const dataLevel = typeof stop[0] === "object" ? stop[0].value : stop[0];
-      const value = stop[1];
-      const deleteStopBtn = <DeleteStopButton onClick={props.onDeleteStop?.bind(null, idx)} />;
-
-      const dataProps = {
-        "aria-label": t("Input value"),
-        label: t("Data value"),
-        value: dataLevel as any,
-        onChange: (newData: string | number | undefined) => changeStop(idx, { zoom: zoomLevel, value: newData as number }, value)
-      };
-
-      let dataInput;
-      if(props.value?.type === "categorical") {
-        dataInput = <InputString {...dataProps} />;
-      }
-      else {
-        dataInput = <InputNumber {...dataProps} />;
-      }
-
-      let zoomInput = null;
-      if(zoomLevel !== undefined) {
-        zoomInput = <div>
-          <InputNumber
-            aria-label="Zoom"
-            value={zoomLevel}
-            onChange={newZoom => changeStop(idx, {zoom: newZoom, value: dataLevel}, value)}
-            min={0}
-            max={22}
-          />
-        </div>;
-      }
-
-      return <tr key={key}>
-        <td>
-          {zoomInput}
-        </td>
-        <td>
-          {dataInput}
-        </td>
-        <td>
-          <InputSpec
-            aria-label={t("Output value")}
-            fieldName={props.fieldName}
-            fieldSpec={props.fieldSpec}
-            value={value}
-            onChange={(_, newValue) => changeStop(idx, {zoom: zoomLevel, value: dataLevel}, newValue as number)}
-          />
-        </td>
-        <td>
-          {deleteStopBtn}
-        </td>
-      </tr>;
-    });
-  }
-
-  return <div className="maputnik-data-spec-block">
-    <fieldset className="maputnik-data-spec-property">
-      <legend>{labelFromFieldName(props.fieldName)}</legend>
-      <div className="maputnik-data-fieldset-inner">
-        <Block
-          label={t("Function")}
-          key="function"
-          data-wd-key="function-type"
-        >
-          <div className="maputnik-data-spec-property-input">
-            <InputSelect
-              value={props.value!.type}
-              onChange={(propVal: string) => changeDataType(propVal)}
-              title={t("Select a type of data scale (default is 'categorical').")}
-              options={getDataFunctionTypes(props.fieldSpec)}
-            />
-          </div>
-        </Block>
-        {props.value?.type !== "identity" &&
-            <Block
-              label={t("Base")}
-              key="base"
-              data-wd-key="function-base"
-            >
-              <div className="maputnik-data-spec-property-input">
-                <InputSpec
-                  fieldName={"base"}
-                  fieldSpec={latest.function.base as typeof latest.function.base & { type: "number" }}
-                  value={props.value?.base}
-                  onChange={(_, newValue) => changeBase(newValue as number)}
-                />
-              </div>
-            </Block>
-        }
-        <Block
-          label={"Property"}
-          key="property"
-          data-wd-key="function-property"
-        >
-          <div className="maputnik-data-spec-property-input">
-            <InputString
-              value={props.value?.property}
-              title={t("Input a data property to base styles off of.")}
-              onChange={propVal => changeDataProperty("property", propVal)}
-            />
-          </div>
-        </Block>
-        {dataFields &&
-            <Block
-              label={t("Default")}
-              key="default"
-              data-wd-key="function-default"
-            >
-              <InputSpec
-                fieldName={props.fieldName}
-                fieldSpec={props.fieldSpec}
-                value={props.value?.default}
-                onChange={(_, propVal) => changeDataProperty("default", propVal)}
-              />
-            </Block>
-        }
-        {dataFields &&
-            <div className="maputnik-function-stop">
-              <table className="maputnik-function-stop-table">
-                <caption>{t("Stops")}</caption>
-                <thead>
-                  <tr>
-                    <th>{t("Zoom")}</th>
-                    <th>{t("Input value")}</th>
-                    <th rowSpan={2}>{t("Output value")}</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  {dataFields}
-                </tbody>
-              </table>
-            </div>
-        }
-        <div className="maputnik-toolbox">
-          {dataFields &&
-              <InputButton
-                className="maputnik-add-stop"
-                onClick={props.onAddStop?.bind(null)}
-              >
-                <PiListPlusBold style={{ verticalAlign: "text-bottom" }} />
-                {t("Add stop")}
-              </InputButton>
-          }
-          <InputButton
-            className="maputnik-add-stop"
-            data-wd-key="convert-to-expression"
-            onClick={props.onExpressionClick?.bind(null)}
-          >
-            <TbMathFunction style={{ verticalAlign: "text-bottom" }} />
-            {t("Convert to expression")}
-          </InputButton>
-        </div>
-      </div>
-    </fieldset>
-  </div>;
-};
-
-export const DataProperty = withTranslation()(DataPropertyInternal);

src/components/DeleteStopButton.tsx

@@ -1,24 +0,0 @@
-import React from "react";
-
-import { InputButton } from "./InputButton";
-import {MdDelete} from "react-icons/md";
-import { type WithTranslation, withTranslation } from "react-i18next";
-
-
-type DeleteStopButtonInternalProps = {
-  onClick?(...args: unknown[]): unknown
-} & WithTranslation;
-
-
-const DeleteStopButtonInternal: React.FC<DeleteStopButtonInternalProps> = (props) => {
-  const t = props.t;
-  return <InputButton
-    className="maputnik-delete-stop"
-    onClick={props.onClick}
-    title={t("Remove zoom level from stop")}
-  >
-    <MdDelete />
-  </InputButton>;
-};
-
-export const DeleteStopButton = withTranslation()(DeleteStopButtonInternal);

src/components/Doc.tsx

@@ -23,7 +23,10 @@ type DocProps = {
   }
 };
 
-export const Doc: React.FC<DocProps> = ({fieldSpec}) => {
+export default class Doc extends React.Component<DocProps> {
+  render () {
+    const {fieldSpec} = this.props;
+
     const {doc, values, docUrl, docUrlLinkText} = fieldSpec;
     const sdkSupport = fieldSpec["sdk-support"];
 
@@ -103,4 +106,5 @@ export const Doc: React.FC<DocProps> = ({fieldSpec}) => {
         }
       </>
     );
-};
+  }
+}

src/components/ExpressionProperty.tsx

@@ -1,85 +0,0 @@
-import React from "react";
-import {MdDelete, MdUndo} from "react-icons/md";
-import { type WithTranslation, withTranslation } from "react-i18next";
-
-import { Block } from "./Block";
-import { InputButton } from "./InputButton";
-import { labelFromFieldName } from "../libs/label-from-field-name";
-import { FieldJson } from "./FieldJson";
-import type { StylePropertySpecification } from "maplibre-gl";
-import { type MappedLayerErrors } from "../libs/definitions";
-
-
-type ExpressionPropertyInternalProps = {
-  fieldName: string
-  fieldType?: string
-  fieldSpec?: StylePropertySpecification
-  value?: any
-  errors?: MappedLayerErrors
-  onDelete?(...args: unknown[]): unknown
-  onChange(value: object): void
-  onUndo?(...args: unknown[]): unknown
-  canUndo?(...args: unknown[]): unknown
-  onFocus?(...args: unknown[]): unknown
-  onBlur?(...args: unknown[]): unknown
-} & WithTranslation;
-
-const ExpressionPropertyInternal: React.FC<ExpressionPropertyInternalProps> = ({
-  errors = {},
-  onFocus = () => {},
-  onBlur = () => {},
-  ...props
-}) => {
-  const {t, value, canUndo} = props;
-  const undoDisabled = canUndo ? !canUndo() : true;
-
-  const deleteStopBtn = (
-    <>
-      {props.onUndo &&
-        <InputButton
-          key="undo_action"
-          onClick={props.onUndo}
-          disabled={undoDisabled}
-          className="maputnik-delete-stop"
-          data-wd-key="undo-expression"
-          title={t("Revert from expression")}
-        >
-          <MdUndo />
-        </InputButton>
-      }
-      <InputButton
-        key="delete_action"
-        onClick={props.onDelete}
-        className="maputnik-delete-stop"
-        data-wd-key="delete-expression"
-        title={t("Delete expression")}
-      >
-        <MdDelete />
-      </InputButton>
-    </>
-  );
-  let error = undefined;
-  if (errors) {
-    const fieldKey = props.fieldType ? props.fieldType + "." + props.fieldName : props.fieldName;
-    error = errors[fieldKey];
-  }
-  return <Block
-    fieldSpec={props.fieldSpec}
-    label={t(labelFromFieldName(props.fieldName))}
-    action={deleteStopBtn}
-    wideMode={true}
-    error={error}
-  >
-    <FieldJson
-      lintType="expression"
-      spec={props.fieldSpec}
-      className="maputnik-expression-editor"
-      onFocus={onFocus}
-      onBlur={onBlur}
-      value={value}
-      onChange={props.onChange}
-    />
-  </Block>;
-};
-
-export const ExpressionProperty = withTranslation()(ExpressionPropertyInternal);

src/components/FieldArray.tsx

@@ -1,5 +1,5 @@
-import { InputArray, type InputArrayProps } from "./InputArray";
+import InputArray, { type InputArrayProps } from "./InputArray";
-import { Fieldset } from "./Fieldset";
+import Fieldset from "./Fieldset";
 
 type FieldArrayProps = InputArrayProps & {
   name?: string
@@ -8,10 +8,12 @@ type FieldArrayProps = InputArrayProps & {
   }
 };
 
-export const FieldArray: React.FC<FieldArrayProps> = (props) => {
+const FieldArray: React.FC<FieldArrayProps> = (props) => {
   return (
     <Fieldset label={props.label} fieldSpec={props.fieldSpec}>
       <InputArray {...props} />
     </Fieldset>
   );
 };
+
+export default FieldArray;

src/components/FieldAutocomplete.tsx

@@ -1,5 +1,5 @@
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputAutocomplete, type InputAutocompleteProps } from "./InputAutocomplete";
+import InputAutocomplete, { type InputAutocompleteProps } from "./InputAutocomplete";
 
 
 type FieldAutocompleteProps = InputAutocompleteProps & {
@@ -7,10 +7,12 @@ type FieldAutocompleteProps = InputAutocompleteProps & {
 };
 
 
-export const FieldAutocomplete: React.FC<FieldAutocompleteProps> = (props) => {
+const FieldAutocomplete: React.FC<FieldAutocompleteProps> = (props) => {
   return (
     <Block label={props.label}>
       <InputAutocomplete {...props} />
     </Block>
   );
 };
+
+export default FieldAutocomplete;

src/components/FieldCheckbox.tsx

@@ -1,5 +1,5 @@
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputCheckbox, type InputCheckboxProps } from "./InputCheckbox";
+import InputCheckbox, {type InputCheckboxProps} from "./InputCheckbox";
 
 
 type FieldCheckboxProps = InputCheckboxProps & {
@@ -7,10 +7,12 @@ type FieldCheckboxProps = InputCheckboxProps & {
 };
 
 
-export const FieldCheckbox: React.FC<FieldCheckboxProps> = (props) => {
+const FieldCheckbox: React.FC<FieldCheckboxProps> = (props) => {
   return (
     <Block label={props.label}>
       <InputCheckbox {...props} />
     </Block>
   );
 };
+
+export default FieldCheckbox;

src/components/FieldColor.tsx

@@ -1,5 +1,5 @@
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputColor, type InputColorProps } from "./InputColor";
+import InputColor, {type InputColorProps} from "./InputColor";
 
 
 type FieldColorProps = InputColorProps & {
@@ -10,10 +10,12 @@ type FieldColorProps = InputColorProps & {
 };
 
 
-export const FieldColor: React.FC<FieldColorProps> = (props) => {
+const FieldColor: React.FC<FieldColorProps> = (props) => {
   return (
     <Block label={props.label} fieldSpec={props.fieldSpec}>
       <InputColor {...props} />
     </Block>
   );
 };
+
+export default FieldColor;

src/components/FieldComment.tsx

@@ -1,7 +1,7 @@
 import React from "react";
 
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputString } from "./InputString";
+import InputString from "./InputString";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
 type FieldCommentInternalProps = {
@@ -36,4 +36,5 @@ const FieldCommentInternal: React.FC<FieldCommentInternalProps> = (props) => {
   );
 };
 
-export const FieldComment = withTranslation()(FieldCommentInternal);
+const FieldComment = withTranslation()(FieldCommentInternal);
+export default FieldComment;

src/components/FieldDocLabel.tsx

@@ -10,7 +10,7 @@ type FieldDocLabelProps = {
 };
 
 
-export const FieldDocLabel: React.FC<FieldDocLabelProps> = (props) => {
+const FieldDocLabel: React.FC<FieldDocLabelProps> = (props) => {
   const [open, setOpen] = React.useState(false);
 
   const onToggleDoc = (state: boolean) => {
@@ -49,3 +49,5 @@ export const FieldDocLabel: React.FC<FieldDocLabelProps> = (props) => {
   }
   return <div />;
 };
+
+export default FieldDocLabel;

src/components/FieldDynamicArray.tsx

@@ -1,14 +1,16 @@
-import { InputDynamicArray, type InputDynamicArrayProps } from "./InputDynamicArray";
+import InputDynamicArray, {type InputDynamicArrayProps} from "./InputDynamicArray";
-import { Fieldset } from "./Fieldset";
+import Fieldset from "./Fieldset";
 
 type FieldDynamicArrayProps = InputDynamicArrayProps & {
   name?: string
 };
 
-export const FieldDynamicArray: React.FC<FieldDynamicArrayProps> = (props) => {
+const FieldDynamicArray: React.FC<FieldDynamicArrayProps> = (props) => {
   return (
     <Fieldset label={props.label}>
       <InputDynamicArray {...props} />
     </Fieldset>
   );
 };
+
+export default FieldDynamicArray;

src/components/FieldEnum.tsx

@@ -1,5 +1,5 @@
-import { InputEnum, type InputEnumProps } from "./InputEnum";
+import InputEnum, {type InputEnumProps} from "./InputEnum";
-import { Fieldset } from "./Fieldset";
+import Fieldset from "./Fieldset";
 
 
 type FieldEnumProps = InputEnumProps & {
@@ -10,10 +10,12 @@ type FieldEnumProps = InputEnumProps & {
 };
 
 
-export const FieldEnum: React.FC<FieldEnumProps> = (props) => {
+const FieldEnum: React.FC<FieldEnumProps> = (props) => {
   return (
     <Fieldset label={props.label} fieldSpec={props.fieldSpec}>
       <InputEnum {...props} />
     </Fieldset>
   );
 };
+
+export default FieldEnum;

src/components/FieldFunction.tsx

@@ -1,9 +1,9 @@
 import React from "react";
 
-import { SpecProperty } from "./SpecProperty";
+import SpecProperty from "./_SpecProperty";
-import { DataProperty, type Stop } from "./DataProperty";
+import DataProperty, { type Stop } from "./_DataProperty";
-import { ZoomProperty } from "./ZoomProperty";
+import ZoomProperty from "./_ZoomProperty";
-import { ExpressionProperty } from "./ExpressionProperty";
+import ExpressionProperty from "./_ExpressionProperty";
 import {function as styleFunction} from "@maplibre/maplibre-gl-style-spec";
 import {findDefaultFromSpec} from "../libs/spec-helper";
 import { type MappedLayerErrors } from "../libs/definitions";
@@ -128,7 +128,7 @@ type FieldFunctionProps = {
 /** Supports displaying spec field for zoom function objects
  * https://www.mapbox.com/mapbox-gl-style-spec/#types-function-zoom-property
  */
-export const FieldFunction: React.FC<FieldFunctionProps> = (props) => {
+const FieldFunction: React.FC<FieldFunctionProps> = (props) => {
   const [dataType, setDataType] = React.useState(
     getDataType(props.value, props.fieldSpec)
   );
@@ -402,3 +402,5 @@ export const FieldFunction: React.FC<FieldFunctionProps> = (props) => {
     </div>
   );
 };
+
+export default FieldFunction;

src/components/FieldId.tsx

@@ -1,7 +1,7 @@
 
 import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputString } from "./InputString";
+import InputString from "./InputString";
 
 type FieldIdProps = {
   value: string
@@ -10,7 +10,7 @@ type FieldIdProps = {
   error?: {message: string}
 };
 
-export const FieldId: React.FC<FieldIdProps> = (props) => {
+const FieldId: React.FC<FieldIdProps> = (props) => {
   return (
     <Block label="ID" fieldSpec={latest.layer.id}
       data-wd-key={props.wdKey}
@@ -24,3 +24,5 @@ export const FieldId: React.FC<FieldIdProps> = (props) => {
     </Block>
   );
 };
+
+export default FieldId;

src/components/FieldJson.tsx

@@ -1,9 +1,11 @@
-import { InputJson, type InputJsonProps } from "./InputJson";
+import InputJson, {type InputJsonProps} from "./InputJson";
 
 
 type FieldJsonProps = InputJsonProps & {};
 
 
-export const FieldJson: React.FC<FieldJsonProps> = (props) => {
+const FieldJson: React.FC<FieldJsonProps> = (props) => {
   return <InputJson {...props} />;
 };
+
+export default FieldJson;

src/components/FieldMaxZoom.tsx

@@ -1,8 +1,8 @@
 import React from "react";
 
 import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputNumber } from "./InputNumber";
+import InputNumber from "./InputNumber";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
 type FieldMaxZoomInternalProps = {
@@ -31,4 +31,5 @@ const FieldMaxZoomInternal: React.FC<FieldMaxZoomInternalProps> = (props) => {
   );
 };
 
-export const FieldMaxZoom = withTranslation()(FieldMaxZoomInternal);
+const FieldMaxZoom = withTranslation()(FieldMaxZoomInternal);
+export default FieldMaxZoom;

src/components/FieldMinZoom.tsx

@@ -1,8 +1,8 @@
 import React from "react";
 
 import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputNumber } from "./InputNumber";
+import InputNumber from "./InputNumber";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
 type FieldMinZoomInternalProps = {
@@ -31,4 +31,5 @@ const FieldMinZoomInternal: React.FC<FieldMinZoomInternalProps> = (props) => {
   );
 };
 
-export const FieldMinZoom = withTranslation()(FieldMinZoomInternal);
+const FieldMinZoom = withTranslation()(FieldMinZoomInternal);
+export default FieldMinZoom;

src/components/FieldMultiInput.tsx

@@ -1,5 +1,5 @@
-import { InputMultiInput, type InputMultiInputProps } from "./InputMultiInput";
+import InputMultiInput, {type InputMultiInputProps} from "./InputMultiInput";
-import { Fieldset } from "./Fieldset";
+import Fieldset from "./Fieldset";
 
 
 type FieldMultiInputProps = InputMultiInputProps & {
@@ -7,10 +7,12 @@ type FieldMultiInputProps = InputMultiInputProps & {
 };
 
 
-export const FieldMultiInput: React.FC<FieldMultiInputProps> = (props) => {
+const FieldMultiInput: React.FC<FieldMultiInputProps> = (props) => {
   return (
     <Fieldset label={props.label}>
       <InputMultiInput {...props} />
     </Fieldset>
   );
 };
+
+export default FieldMultiInput;

src/components/FieldNumber.tsx

@@ -1,5 +1,5 @@
-import { InputNumber, type InputNumberProps } from "./InputNumber";
+import InputNumber, {type InputNumberProps} from "./InputNumber";
-import { Block } from "./Block";
+import Block from "./Block";
 
 
 type FieldNumberProps = InputNumberProps & {
@@ -10,10 +10,12 @@ type FieldNumberProps = InputNumberProps & {
 };
 
 
-export const FieldNumber: React.FC<FieldNumberProps> = (props) => {
+const FieldNumber: React.FC<FieldNumberProps> = (props) => {
   return (
     <Block label={props.label} fieldSpec={props.fieldSpec}>
       <InputNumber {...props} />
     </Block>
   );
 };
+
+export default FieldNumber;

src/components/FieldSelect.tsx

@@ -1,5 +1,5 @@
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputSelect, type InputSelectProps } from "./InputSelect";
+import InputSelect, {type InputSelectProps} from "./InputSelect";
 
 
 type FieldSelectProps = InputSelectProps & {
@@ -10,10 +10,12 @@ type FieldSelectProps = InputSelectProps & {
 };
 
 
-export const FieldSelect: React.FC<FieldSelectProps> = (props) => {
+const FieldSelect: React.FC<FieldSelectProps> = (props) => {
   return (
     <Block label={props.label} fieldSpec={props.fieldSpec}>
       <InputSelect {...props} />
     </Block>
   );
 };
+
+export default FieldSelect;

src/components/FieldSource.tsx

@@ -1,8 +1,8 @@
 import React from "react";
 
 import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputAutocomplete } from "./InputAutocomplete";
+import InputAutocomplete from "./InputAutocomplete";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
 type FieldSourceInternalProps = {
@@ -38,4 +38,5 @@ const FieldSourceInternal: React.FC<FieldSourceInternalProps> = ({
 };
 
 
-export const FieldSource = withTranslation()(FieldSourceInternal);
+const FieldSource = withTranslation()(FieldSourceInternal);
+export default FieldSource;

src/components/FieldSourceLayer.tsx

@@ -1,8 +1,8 @@
 import React from "react";
 
 import {latest} from "@maplibre/maplibre-gl-style-spec";
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputAutocomplete } from "./InputAutocomplete";
+import InputAutocomplete from "./InputAutocomplete";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
 type FieldSourceLayerInternalProps = {
@@ -35,4 +35,5 @@ const FieldSourceLayerInternal: React.FC<FieldSourceLayerInternalProps> = ({
   );
 };
 
-export const FieldSourceLayer = withTranslation()(FieldSourceLayerInternal);
+const FieldSourceLayer = withTranslation()(FieldSourceLayerInternal);
+export default FieldSourceLayer;

src/components/FieldSpec.tsx

@@ -1,6 +1,6 @@
-import { Block, type BlockProps } from "./Block";
+import Block, { type BlockProps } from "./Block";
-import { InputSpec, type FieldSpecType, type InputSpecProps } from "./InputSpec";
+import InputSpec, { type FieldSpecType, type InputSpecProps } from "./InputSpec";
-import { Fieldset, type FieldsetProps } from "./Fieldset";
+import Fieldset, { type FieldsetProps } from "./Fieldset";
 
 function getElementFromType(fieldSpec: { type?: FieldSpecType, values?: unknown[] }): typeof Fieldset | typeof Block {
   switch(fieldSpec.type) {
@@ -36,7 +36,7 @@ function getElementFromType(fieldSpec: { type?: FieldSpecType, values?: unknown[
 
 export type FieldSpecProps = InputSpecProps & BlockProps & FieldsetProps;
 
-export const FieldSpec: React.FC<FieldSpecProps> = (props) => {
+const FieldSpec: React.FC<FieldSpecProps> = (props) => {
   const TypeBlock = getElementFromType(props.fieldSpec!);
 
   return (
@@ -45,3 +45,5 @@ export const FieldSpec: React.FC<FieldSpecProps> = (props) => {
     </TypeBlock>
   );
 };
+
+export default FieldSpec;

src/components/FieldString.tsx

@@ -1,5 +1,5 @@
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputString, type InputStringProps } from "./InputString";
+import InputString, {type InputStringProps} from "./InputString";
 
 type FieldStringProps = InputStringProps & {
   name?: string
@@ -9,10 +9,12 @@ type FieldStringProps = InputStringProps & {
   }
 };
 
-export const FieldString: React.FC<FieldStringProps> = (props) => {
+const FieldString: React.FC<FieldStringProps> = (props) => {
   return (
     <Block label={props.label} fieldSpec={props.fieldSpec}>
       <InputString {...props} />
     </Block>
   );
 };
+
+export default FieldString;

src/components/FieldType.tsx

@@ -1,8 +1,8 @@
 import React from "react";
 import {v8} from "@maplibre/maplibre-gl-style-spec";
-import { Block } from "./Block";
+import Block from "./Block";
-import { InputSelect } from "./InputSelect";
+import InputSelect from "./InputSelect";
-import { InputString } from "./InputString";
+import InputString from "./InputString";
 import { type WithTranslation, withTranslation } from "react-i18next";
 import { startCase } from "lodash";
 
@@ -43,4 +43,5 @@ const FieldTypeInternal: React.FC<FieldTypeInternalProps> = ({
   );
 };
 
-export const FieldType = withTranslation()(FieldTypeInternal);
+const FieldType = withTranslation()(FieldTypeInternal);
+export default FieldType;

src/components/FieldUrl.tsx

@@ -1,5 +1,5 @@
-import { InputUrl, type FieldUrlProps as InputUrlProps } from "./InputUrl";
+import InputUrl, {type FieldUrlProps as InputUrlProps} from "./InputUrl";
-import { Block } from "./Block";
+import Block from "./Block";
 
 
 type FieldUrlProps = InputUrlProps & {
@@ -10,10 +10,12 @@ type FieldUrlProps = InputUrlProps & {
 };
 
 
-export const FieldUrl: React.FC<FieldUrlProps> = (props) => {
+const FieldUrl: React.FC<FieldUrlProps> = (props) => {
   return (
     <Block label={props.label} fieldSpec={props.fieldSpec}>
       <InputUrl {...props} />
     </Block>
   );
 };
+
+export default FieldUrl;

src/components/Fieldset.tsx

@@ -1,8 +1,8 @@
 import React, { type PropsWithChildren, type ReactElement } from "react";
 import classnames from "classnames";
-import { FieldDocLabel } from "./FieldDocLabel";
+import FieldDocLabel from "./FieldDocLabel";
-import { Doc } from "./Doc";
+import Doc from "./Doc";
-import { generateUniqueId } from "../libs/document-uid";
+import generateUniqueId from "../libs/document-uid";
 
 export type FieldsetProps = PropsWithChildren & {
   label?: string,
@@ -12,7 +12,7 @@ export type FieldsetProps = PropsWithChildren & {
 };
 
 
-export const Fieldset: React.FC<FieldsetProps> = (props) => {
+const Fieldset: React.FC<FieldsetProps> = (props) => {
   const [showDoc, setShowDoc] = React.useState(false);
   const labelId = React.useRef(generateUniqueId("fieldset_label_"));
 
@@ -49,3 +49,5 @@ export const Fieldset: React.FC<FieldsetProps> = (props) => {
     </div>
   );
 };
+
+export default Fieldset;

src/components/FilterEditor.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React from "react";
 import { TbMathFunction } from "react-icons/tb";
 import { PiListPlusBold } from "react-icons/pi";
 import {isEqual} from "lodash";
@@ -7,13 +7,13 @@ import {migrate, convertFilter} from "@maplibre/maplibre-gl-style-spec";
 import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
 
 import {combiningFilterOps} from "../libs/filterops";
-import { InputSelect } from "./InputSelect";
+import InputSelect from "./InputSelect";
-import { Block } from "./Block";
+import Block from "./Block";
-import { SingleFilterEditor } from "./SingleFilterEditor";
+import SingleFilterEditor from "./SingleFilterEditor";
-import { FilterEditorBlock } from "./FilterEditorBlock";
+import FilterEditorBlock from "./FilterEditorBlock";
-import { InputButton } from "./InputButton";
+import InputButton from "./InputButton";
-import { Doc } from "./Doc";
+import Doc from "./Doc";
-import { ExpressionProperty } from "./ExpressionProperty";
+import ExpressionProperty from "./_ExpressionProperty";
 import { type WithTranslation, withTranslation } from "react-i18next";
 import type { MappedLayerErrors, StyleSpecificationWithId } from "../libs/definitions";
 
@@ -100,64 +100,95 @@ type FilterEditorInternalProps = {
   onChange(value: LegacyFilterSpecification | ExpressionSpecification): void
 } & WithTranslation;
 
-const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["all"], ...rest }) => {
+type FilterEditorState = {
-  const props = { filter, ...rest } as FilterEditorInternalProps;
+  showDoc: boolean
+  displaySimpleFilter: boolean
+  valueIsSimpleFilter?: boolean
+};
 
-  // Nothing ever toggles this: the Block below renders its own documentation
+class FilterEditorInternal extends React.Component<FilterEditorInternalProps, FilterEditorState> {
-  // toggle, so this component's inline doc panel stays hidden (as it did before).
+  static defaultProps = {
-  const [showDoc] = useState(false);
+    filter: ["all"],
-  const [displaySimpleFilter, setDisplaySimpleFilter] = useState(() =>
+  };
-    checkIfSimpleFilter(combiningFilter(props))
-  );
 
-  // Replaces getDerivedStateFromProps. "Upgrade but never downgrade": once the
+  constructor (props: FilterEditorInternalProps) {
-  // filter stops being expressible in the simple editor, switch to the
+    super(props);
-  // expression editor and stay there.
+    this.state = {
-  const isSimpleFilter = checkIfSimpleFilter(combiningFilter(props));
+      showDoc: false,
-  if (!isSimpleFilter && displaySimpleFilter) {
+      displaySimpleFilter: checkIfSimpleFilter(combiningFilter(props)),
-    setDisplaySimpleFilter(false);
+    };
   }
-  // In the original this was state, but every branch derived it from these two
-  // values alone.
-  const valueIsSimpleFilter = isSimpleFilter && !displaySimpleFilter;
 
   // Convert filter to combining filter
-  function onFilterPartChanged(filterIdx: number, newPart: any[]) {
+  onFilterPartChanged(filterIdx: number, newPart: any[]) {
-    const newFilter = combiningFilter(props).slice(0) as LegacyFilterSpecification | ExpressionSpecification;
+    const newFilter = combiningFilter(this.props).slice(0) as LegacyFilterSpecification | ExpressionSpecification;
     newFilter[filterIdx] = newPart;
-    props.onChange(newFilter);
+    this.props.onChange(newFilter);
   }
 
-  function deleteFilterItem(filterIdx: number) {
+  deleteFilterItem(filterIdx: number) {
-    const newFilter = combiningFilter(props).slice(0) as LegacyFilterSpecification | ExpressionSpecification;
+    const newFilter = combiningFilter(this.props).slice(0) as LegacyFilterSpecification | ExpressionSpecification;
     newFilter.splice(filterIdx + 1, 1);
-    props.onChange(newFilter);
+    this.props.onChange(newFilter);
   }
 
-  const addFilterItem = () => {
+  addFilterItem = () => {
-    const newFilterItem = combiningFilter(props).slice(0) as LegacyFilterSpecification | ExpressionSpecification;
+    const newFilterItem = combiningFilter(this.props).slice(0) as LegacyFilterSpecification | ExpressionSpecification;
     (newFilterItem as any[]).push(["==", "name", ""]);
-    props.onChange(newFilterItem);
+    this.props.onChange(newFilterItem);
   };
 
-  const makeFilter = () => {
+  onToggleDoc = (val: boolean) => {
-    setDisplaySimpleFilter(true);
+    this.setState({
+      showDoc: val
+    });
   };
 
-  const makeExpression = () => {
+  makeFilter = () => {
-    const currentFilter = combiningFilter(props);
+    this.setState({
-    props.onChange(migrateFilter(currentFilter));
+      displaySimpleFilter: true,
-    setDisplaySimpleFilter(false);
+    });
   };
 
+  makeExpression = () => {
+    const filter = combiningFilter(this.props);
+    this.props.onChange(migrateFilter(filter));
+    this.setState({
+      displaySimpleFilter: false,
+    });
+  };
 
-  const {errors, t} = props;
+  static getDerivedStateFromProps(props: Readonly<FilterEditorInternalProps>, state: FilterEditorState) {
+    const displaySimpleFilter = checkIfSimpleFilter(combiningFilter(props));
+
+    // Upgrade but never downgrade
+    if (!displaySimpleFilter && state.displaySimpleFilter === true) {
+      return {
+        displaySimpleFilter: false,
+        valueIsSimpleFilter: false,
+      };
+    }
+    else if (displaySimpleFilter && state.displaySimpleFilter === false) {
+      return {
+        valueIsSimpleFilter: true,
+      };
+    }
+    else {
+      return {
+        valueIsSimpleFilter: false,
+      };
+    }
+  }
+
+  render() {
+    const {errors, t} = this.props;
+    const {displaySimpleFilter} = this.state;
     const fieldSpec={
       doc: latest.layer.filter.doc + " Combine multiple filters together by using a compound filter."
     };
     const defaultFilter = ["all"] as LegacyFilterSpecification | ExpressionSpecification;
 
-  const isNestedCombiningFilter = displaySimpleFilter && hasNestedCombiningFilter(combiningFilter(props));
+    const isNestedCombiningFilter = displaySimpleFilter && hasNestedCombiningFilter(combiningFilter(this.props));
 
     if (isNestedCombiningFilter) {
       return <div className="maputnik-filter-editor-unsupported">
@@ -165,7 +196,7 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
           {t("Nested filters are not supported.")}
         </p>
         <InputButton
-        onClick={makeExpression}
+          onClick={this.makeExpression}
           title={t("Convert to expression")}
         >
           <TbMathFunction />
@@ -174,17 +205,16 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
       </div>;
     }
     else if (displaySimpleFilter) {
-    const filter = combiningFilter(props);
+      const filter = combiningFilter(this.props);
       const combiningOp = filter[0];
       const filters = filter.slice(1) as (LegacyFilterSpecification | ExpressionSpecification)[];
 
       const actions = (
         <div>
           <InputButton
-          onClick={makeExpression}
+            onClick={this.makeExpression}
             title={t("Convert to expression")}
             className="maputnik-make-zoom-function"
-          data-wd-key="filter-convert-to-expression"
           >
             <TbMathFunction />
           </InputButton>
@@ -196,11 +226,11 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
 
         return (
           <div key={`block-${idx}`}>
-          <FilterEditorBlock key={idx} onDelete={deleteFilterItem.bind(null, idx)}>
+            <FilterEditorBlock key={idx} onDelete={this.deleteFilterItem.bind(this, idx)}>
               <SingleFilterEditor
-              properties={props.properties}
+                properties={this.props.properties}
                 filter={f}
-              onChange={onFilterPartChanged.bind(null, idx + 1)}
+                onChange={this.onFilterPartChanged.bind(this, idx + 1)}
               />
             </FilterEditorBlock>
             {error &&
@@ -218,11 +248,10 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
             fieldSpec={fieldSpec}
             label={t("Filter")}
             action={actions}
-          data-wd-key="filter-combining-operator"
           >
             <InputSelect
               value={combiningOp}
-            onChange={(v: [string, any]) => onFilterPartChanged(0, v)}
+              onChange={(v: [string, any]) => this.onFilterPartChanged(0, v)}
               options={[
                 ["all", t("every filter matches")],
                 ["none", t("no filter matches")],
@@ -238,7 +267,7 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
             <InputButton
               data-wd-key="layer-filter-button"
               className="maputnik-add-filter"
-            onClick={addFilterItem}
+              onClick={this.addFilterItem}
             >
               <PiListPlusBold style={{ verticalAlign: "text-bottom" }} />
               {t("Add filter")}
@@ -247,7 +276,7 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
           <div
             key="doc"
             className="maputnik-doc-inline"
-          style={{display: showDoc ? "" : "none"}}
+            style={{display: this.state.showDoc ? "" : "none"}}
           >
             <Doc fieldSpec={fieldSpec} />
           </div>
@@ -255,26 +284,26 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
       );
     }
     else {
-    const {filter} = props;
+      const {filter} = this.props;
 
       return (
         <>
           <ExpressionProperty
             onDelete={() => {
-            setDisplaySimpleFilter(true);
+              this.setState({displaySimpleFilter: true});
-            props.onChange(defaultFilter);
+              this.props.onChange(defaultFilter);
             }}
             fieldName="filter"
             value={filter}
             errors={errors}
-          onChange={props.onChange}
+            onChange={this.props.onChange}
           />
-        {valueIsSimpleFilter &&
+          {this.state.valueIsSimpleFilter &&
             <div className="maputnik-expr-infobox">
               {t("You've entered an old style filter.")}
               {" "}
               <button
-                onClick={makeFilter}
+                onClick={this.makeFilter}
                 className="maputnik-expr-infobox__button"
               >
                 {t("Switch to filter editor.")}
@@ -284,6 +313,8 @@ const FilterEditorInternal: React.FC<FilterEditorInternalProps> = ({ filter = ["
         </>
       );
     }
-};
+  }
+}
 
-export const FilterEditor = withTranslation()(FilterEditorInternal);
+const FilterEditor = withTranslation()(FilterEditorInternal);
+export default FilterEditor;

src/components/FilterEditorBlock.tsx

@@ -1,5 +1,5 @@
 import React, { type PropsWithChildren } from "react";
-import { InputButton } from "./InputButton";
+import InputButton from "./InputButton";
 import {MdDelete} from "react-icons/md";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
@@ -7,22 +7,25 @@ type FilterEditorBlockInternalProps = PropsWithChildren & {
   onDelete(...args: unknown[]): unknown
 } & WithTranslation;
 
-const FilterEditorBlockInternal: React.FC<FilterEditorBlockInternalProps> = (props) => {
+class FilterEditorBlockInternal extends React.Component<FilterEditorBlockInternalProps> {
-  const t = props.t;
+  render() {
+    const t = this.props.t;
     return <div className="maputnik-filter-editor-block">
       <div className="maputnik-filter-editor-block-content">
-      {props.children}
+        {this.props.children}
       </div>
       <div className="maputnik-filter-editor-block-action">
         <InputButton
           className="maputnik-icon-button"
-        onClick={props.onDelete}
+          onClick={this.props.onDelete}
           title={t("Delete filter block")}
         >
           <MdDelete />
         </InputButton>
       </div>
     </div>;
-};
+  }
+}
 
-export const FilterEditorBlock = withTranslation()(FilterEditorBlockInternal);
+const FilterEditorBlock = withTranslation()(FilterEditorBlockInternal);
+export default FilterEditorBlock;

src/components/FunctionButtons.tsx

@@ -1,68 +0,0 @@
-import React from "react";
-
-import { InputButton } from "./InputButton";
-import {MdFunctions, MdInsertChart} from "react-icons/md";
-import { TbMathFunction } from "react-icons/tb";
-import { type WithTranslation, withTranslation } from "react-i18next";
-
-type FunctionInputButtonsInternalProps = {
-  fieldSpec?: any
-  onZoomClick?(): void
-  onDataClick?(): void
-  onExpressionClick?(): void
-  onElevationClick?(): void
-} & WithTranslation;
-
-const FunctionInputButtonsInternal: React.FC<FunctionInputButtonsInternalProps> = (props) => {
-  const t = props.t;
-
-  if (props.fieldSpec.expression?.parameters.includes("zoom")) {
-    const expressionInputButton = (
-      <InputButton
-        className="maputnik-make-zoom-function"
-        onClick={props.onExpressionClick}
-        title={t("Convert to expression")}
-      >
-        <TbMathFunction />
-      </InputButton>
-    );
-
-    const makeZoomInputButton = <InputButton
-      className="maputnik-make-zoom-function"
-      onClick={props.onZoomClick}
-      title={t("Convert property into a zoom function")}
-    >
-      <MdFunctions />
-    </InputButton>;
-
-    let makeDataInputButton;
-    if (props.fieldSpec["property-type"] === "data-driven") {
-      makeDataInputButton = <InputButton
-        className="maputnik-make-data-function"
-        onClick={props.onDataClick}
-        title={t("Convert property to data function")}
-      >
-        <MdInsertChart />
-      </InputButton>;
-    }
-    return <div>
-      {expressionInputButton}
-      {makeDataInputButton}
-      {makeZoomInputButton}
-    </div>;
-  } else if (props.fieldSpec.expression?.parameters.includes("elevation")) {
-    const inputElevationButton = <InputButton
-      className="maputnik-make-elevation-function"
-      onClick={props.onElevationClick}
-      title={t("Convert property into a elevation function")}
-      data-wd-key='make-elevation-function'
-    >
-      <MdFunctions />
-    </InputButton>;
-    return <div>{inputElevationButton}</div>;
-  } else {
-    return <div></div>;
-  }
-};
-
-export const FunctionInputButtons = withTranslation()(FunctionInputButtonsInternal);

src/components/IconLayer.tsx

@@ -13,7 +13,7 @@ type IconLayerProps = {
   className?: string
 };
 
-export const IconLayer: React.FC<IconLayerProps> = (props) => {
+const IconLayer: React.FC<IconLayerProps> = (props) => {
   const iconProps = { style: props.style };
   switch(props.type) {
     case "fill-extrusion": return <IoMdCube {...iconProps} />;
@@ -29,3 +29,5 @@ export const IconLayer: React.FC<IconLayerProps> = (props) => {
     default: return <MdPriorityHigh {...iconProps} />;
   }
 };
+
+export default IconLayer;

src/components/InputArray.tsx

@@ -1,6 +1,6 @@
-import React, { useState } from "react";
+import React from "react";
-import { InputString } from "./InputString";
+import InputString from "./InputString";
-import { InputNumber } from "./InputNumber";
+import InputNumber from "./InputNumber";
 
 export type InputArrayProps = {
   value: (string | number | undefined)[]
@@ -12,40 +12,73 @@ export type InputArrayProps = {
   label?: string
 };
 
-export const InputArray: React.FC<InputArrayProps> = ({
+type InputArrayState = {
-  value: propsValue = [],
+  value: (string | number | undefined)[]
-  default: propsDefault = [],
+  initialPropsValue: unknown[]
-  ...rest
+};
-}) => {
-  const props = { value: propsValue, default: propsDefault, ...rest };
 
-  // The original seeded this from props and then never let props overwrite it
+export default class InputArray extends React.Component<InputArrayProps, InputArrayState> {
-  // again (its getDerivedStateFromProps assigned the existing state back in
+  static defaultProps = {
-  // both branches), so the value is owned by this component after mount.
+    value: [],
-  const [value, setValue] = useState<(string | number | undefined)[]>(() => propsValue.slice(0));
+    default: [],
+  };
 
-  function isComplete(val: unknown[]) {
+  constructor (props: InputArrayProps) {
-    return Array(props.length).fill(null).every((_, i) => {
+    super(props);
-      const v = val[i];
+    this.state = {
-      return !(v === undefined || v === "");
+      value: this.props.value.slice(0),
+      // This is so we can compare changes in getDerivedStateFromProps
+      initialPropsValue: this.props.value.slice(0),
+    };
+  }
+
+  static getDerivedStateFromProps(props: Readonly<InputArrayProps>, state: InputArrayState) {
+    const value: any[] = [];
+    const initialPropsValue = state.initialPropsValue.slice(0);
+
+    Array(props.length).fill(null).map((_, i) => {
+      if (props.value[i] === state.initialPropsValue[i]) {
+        value[i] = state.value[i];
+      }
+      else {
+        value[i] = state.value[i];
+        initialPropsValue[i] = state.value[i];
+      }
+    });
+
+    return {
+      value,
+      initialPropsValue,
+    };
+  }
+
+  isComplete(value: unknown[]) {
+    return Array(this.props.length).fill(null).every((_, i) => {
+      const val = value[i];
+      return !(val === undefined || val === "");
     });
   }
 
-  function changeValue(idx: number, newValue: string | number | undefined) {
+  changeValue(idx: number, newValue: string | number | undefined) {
-    const nextValue = value.slice(0);
+    const value = this.state.value.slice(0);
-    nextValue[idx] = newValue;
+    value[idx] = newValue;
 
-    setValue(nextValue);
+    this.setState({
-
+      value,
-    if (isComplete(nextValue) && props.onChange) {
+    }, () => {
-      props.onChange(nextValue);
+      if (this.isComplete(value) && this.props.onChange) {
+        this.props.onChange(value);
       }
-    else if (props.onChange) {
+      else if (this.props.onChange){
         // Unset until complete
-      props.onChange(undefined);
+        this.props.onChange(undefined);
       }
+    });
   }
 
+  render() {
+    const {value} = this.state;
+
     const containsValues = (
       value.length > 0 &&
       !value.every(val => {
@@ -53,24 +86,24 @@ export const InputArray: React.FC<InputArrayProps> = ({
       })
     );
 
-  const inputs = Array(props.length).fill(null).map((_, i) => {
+    const inputs = Array(this.props.length).fill(null).map((_, i) => {
-    if(props.type === "number") {
+      if(this.props.type === "number") {
         return <InputNumber
           key={i}
-        default={containsValues || !props.default ? undefined : props.default[i] as number}
+          default={containsValues || !this.props.default ? undefined : this.props.default[i] as number}
           value={value[i] as number}
           required={containsValues ? true : false}
-        onChange={(v) => changeValue(i, v)}
+          onChange={(v) => this.changeValue(i, v)}
-        aria-label={props["aria-label"] || props.label}
+          aria-label={this.props["aria-label"] || this.props.label}
         />;
       } else {
         return <InputString
           key={i}
-        default={containsValues || !props.default ? undefined : props.default[i] as string}
+          default={containsValues || !this.props.default ? undefined : this.props.default[i] as string}
           value={value[i] as string}
           required={containsValues ? true : false}
-        onChange={(v) => changeValue(i, v)}
+          onChange={this.changeValue.bind(this, i)}
-        aria-label={props["aria-label"] || props.label}
+          aria-label={this.props["aria-label"] || this.props.label}
         />;
       }
     });
@@ -80,4 +113,5 @@ export const InputArray: React.FC<InputArrayProps> = ({
         {inputs}
       </div>
     );
-};
+  }
+}

src/components/InputAutocomplete.browser.test.tsx

@@ -0,0 +1,24 @@
+import { expect, test } from "vitest";
+import { render } from "vitest-browser-react";
+import { page } from "vitest/browser";
+import InputAutocomplete from "./InputAutocomplete";
+
+const fruits = ["apple", "banana", "cherry"];
+
+test("filters options when typing", async () => {
+  render(<InputAutocomplete aria-label="Fruit" options={fruits.map((f) => [f, f])} />);
+
+  const input = page.getByLabelText("Fruit");
+  await input.click();
+
+  const menuItems = page.getByRole("option");
+  await expect.element(menuItems.first()).toBeVisible();
+  expect(menuItems.all()).toHaveLength(3);
+
+  await input.fill("ch");
+  await expect.element(page.getByText("cherry")).toBeVisible();
+  expect(page.getByRole("option").all()).toHaveLength(1);
+
+  await page.getByText("cherry").click();
+  await expect.element(input).toHaveValue("cherry");
+});

src/components/InputAutocomplete.tsx

@@ -11,7 +11,7 @@ export type InputAutocompleteProps = {
   "aria-label"?: string
 };
 
-export function InputAutocomplete({
+export default function InputAutocomplete({
   value,
   options = [],
   onChange = () => {},

src/components/InputButton.tsx

@@ -14,18 +14,20 @@ type InputButtonProps = {
   title?: string
 };
 
-export const InputButton: React.FC<InputButtonProps> = (props) => {
+export default class InputButton extends React.Component<InputButtonProps> {
+  render() {
     return <button
-    id={props.id}
+      id={this.props.id}
-    title={props.title}
+      title={this.props.title}
-    type={props.type}
+      type={this.props.type}
-    onClick={props.onClick}
+      onClick={this.props.onClick}
-    disabled={props.disabled}
+      disabled={this.props.disabled}
-    aria-label={props["aria-label"]}
+      aria-label={this.props["aria-label"]}
-    className={classnames("maputnik-button", props.className)}
+      className={classnames("maputnik-button", this.props.className)}
-    data-wd-key={props["data-wd-key"]}
+      data-wd-key={this.props["data-wd-key"]}
-    style={props.style}
+      style={this.props.style}
     >
-    {props.children}
+      {this.props.children}
     </button>;
-};
+  }
+}

src/components/InputCheckbox.tsx

@@ -6,26 +6,32 @@ export type InputCheckboxProps = {
   onChange(...args: unknown[]): unknown
 };
 
-export const InputCheckbox: React.FC<InputCheckboxProps> = ({value = false, ...props}) => {
+export default class InputCheckbox extends React.Component<InputCheckboxProps> {
-  const onChange = () => {
+  static defaultProps = {
-    props.onChange(!value);
+    value: false,
   };
 
+  onChange = () => {
+    this.props.onChange(!this.props.value);
+  };
+
+  render() {
     return <div className="maputnik-checkbox-wrapper">
       <input
         className="maputnik-checkbox"
         type="checkbox"
-      style={props.style}
+        style={this.props.style}
-      onChange={onChange}
+        onChange={this.onChange}
-      onClick={onChange}
+        onClick={this.onChange}
-      checked={value}
+        checked={this.props.value}
       />
       <div className="maputnik-checkbox-box">
         <svg style={{
-        display: value ? "inline" : "none"
+          display: this.props.value ? "inline" : "none"
         }} className="maputnik-checkbox-icon" viewBox='0 0 32 32'>
           <path d='M1 14 L5 10 L13 18 L27 4 L31 8 L13 26 z' />
         </svg>
       </div>
     </div>;
-};
+  }
+}

src/components/InputColor.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useMemo, useRef, useState } from "react";
+import React from "react";
 import Color from "color";
 import ChromePicker from "react-color/lib/components/chrome/Chrome";
 import {type ColorResult} from "react-color";
@@ -20,27 +20,26 @@ export type InputColorProps = {
 };
 
 /*** Number fields with support for min, max and units and documentation*/
-export const InputColor: React.FC<InputColorProps> = (props) => {
+export default class InputColor extends React.Component<InputColorProps> {
-  const [pickerOpened, setPickerOpened] = useState(false);
+  state = {
-  const colorInput = useRef<HTMLInputElement | null>(null);
+    pickerOpened: false
+  };
+  colorInput: HTMLInputElement | null = null;
 
-  // Keep the latest `onChange` available to the throttled callback, which is
+  constructor (props: InputColorProps) {
-  // created only once so that throttling actually takes effect.
+    super(props);
-  const onChangeProp = useRef(props.onChange);
+    this.onChangeNoCheck = lodash.throttle(this.onChangeNoCheck, 1000/30);
-  useEffect(() => {
+  }
-    onChangeProp.current = props.onChange;
-  });
 
-  const onChangeNoCheck = useMemo(
+  onChangeNoCheck(v: string) {
-    () => lodash.throttle((v: string) => onChangeProp.current(v), 1000/30),
+    this.props.onChange(v);
-    []
+  }
-  );
 
   //TODO: I much rather would do this with absolute positioning
   //but I am too stupid to get it to work together with fixed position
   //and scrollbars so I have to fallback to JavaScript
-  const calcPickerOffset = () => {
+  calcPickerOffset = () => {
-    const elem = colorInput.current;
+    const elem = this.colorInput;
     if(elem) {
       const pos = elem.getBoundingClientRect();
       return {
@@ -55,27 +54,28 @@ export const InputColor: React.FC<InputColorProps> = (props) => {
     }
   };
 
-  const togglePicker = () => {
+  togglePicker = () => {
-    setPickerOpened(opened => !opened);
+    this.setState({ pickerOpened: !this.state.pickerOpened });
   };
 
-  const getColor = () => {
+  get color() {
     // Catch invalid color.
     try {
-      return Color(props.value).rgb();
+      return Color(this.props.value).rgb();
     }
     catch(err) {
       console.warn("Error parsing color: ", err);
       return Color("rgb(255,255,255)");
     }
-  };
+  }
 
-  const onChange = (v: string) => {
+  onChange (v: string) {
-    props.onChange(v === "" ? undefined : v);
+    this.props.onChange(v === "" ? undefined : v);
-  };
+  }
 
-  const offset = calcPickerOffset();
+  render() {
-  const currentColor = getColor().object();
+    const offset = this.calcPickerOffset();
+    const currentColor = this.color.object();
     const currentChromeColor = {
       r: currentColor.r,
       g: currentColor.g,
@@ -94,11 +94,11 @@ export const InputColor: React.FC<InputColorProps> = (props) => {
       }}>
       <ChromePicker
         color={currentChromeColor}
-      onChange={c => onChangeNoCheck(formatColor(c))}
+        onChange={c => this.onChangeNoCheck(formatColor(c))}
       />
       <div
         className="maputnik-color-picker-offset"
-      onClick={togglePicker}
+        onClick={this.togglePicker}
         style={{
           zIndex: -1,
           position: "fixed",
@@ -111,24 +111,25 @@ export const InputColor: React.FC<InputColorProps> = (props) => {
     </div>;
 
     const swatchStyle = {
-    backgroundColor: props.value
+      backgroundColor: this.props.value
     };
 
     return <div className="maputnik-color-wrapper">
-    {pickerOpened && picker}
+      {this.state.pickerOpened && picker}
       <div className="maputnik-color-swatch" style={swatchStyle}></div>
       <input
-      aria-label={props["aria-label"]}
+        aria-label={this.props["aria-label"]}
         spellCheck="false"
         autoComplete="off"
         className="maputnik-color"
-      ref={colorInput}
+        ref={(input) => {this.colorInput = input;}}
-      onClick={togglePicker}
+        onClick={this.togglePicker}
-      style={props.style}
+        style={this.props.style}
-      name={props.name}
+        name={this.props.name}
-      placeholder={props.default}
+        placeholder={this.props.default}
-      value={props.value ? props.value : ""}
+        value={this.props.value ? this.props.value : ""}
-      onChange={(e) => onChange(e.target.value)}
+        onChange={(e) => this.onChange(e.target.value)}
       />
     </div>;
-};
+  }
+}

src/components/InputDynamicArray.tsx

@@ -3,13 +3,13 @@ import capitalize from "lodash.capitalize";
 import {MdDelete} from "react-icons/md";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
-import { InputString } from "./InputString";
+import InputString from "./InputString";
-import { InputNumber } from "./InputNumber";
+import InputNumber from "./InputNumber";
-import { InputButton } from "./InputButton";
+import InputButton from "./InputButton";
-import { FieldDocLabel } from "./FieldDocLabel";
+import FieldDocLabel from "./FieldDocLabel";
-import { InputEnum } from "./InputEnum";
+import InputEnum from "./InputEnum";
-import { InputUrl } from "./InputUrl";
+import InputUrl from "./InputUrl";
-import { InputColor } from "./InputColor";
+import InputColor from "./InputColor";
 
 
 export type InputDynamicArrayProps = {
@@ -27,91 +27,94 @@ export type InputDynamicArrayProps = {
 
 type InputDynamicArrayInternalProps = InputDynamicArrayProps & WithTranslation;
 
-const InputDynamicArrayInternal: React.FC<InputDynamicArrayInternalProps> = (props) => {
+class InputDynamicArrayInternal extends React.Component<InputDynamicArrayInternalProps> {
-  const values = props.value || props.default || [];
+  changeValue(idx: number, newValue: string | number | undefined) {
-
+    const values = this.values.slice(0);
-  const changeValue = (idx: number, newValue: string | number | undefined) => {
+    values[idx] = newValue;
-    const newValues = values.slice(0);
+    if (this.props.onChange) this.props.onChange(values);
-    newValues[idx] = newValue;
-    if (props.onChange) props.onChange(newValues);
-  };
-
-  const addValue = () => {
-    const newValues = values.slice(0);
-    if (props.type === "number") {
-      newValues.push(0);
   }
-    else if (props.type === "url") {
+
-      newValues.push("");
+  get values() {
+    return this.props.value || this.props.default || [];
   }
-    else if (props.type === "enum") {
+
-      const {fieldSpec} = props;
+  addValue = () => {
+    const values = this.values.slice(0);
+    if (this.props.type === "number") {
+      values.push(0);
+    }
+    else if (this.props.type === "url") {
+      values.push("");
+    }
+    else if (this.props.type === "enum") {
+      const {fieldSpec} = this.props;
       const defaultValue = Object.keys(fieldSpec!.values)[0];
-      newValues.push(defaultValue);
+      values.push(defaultValue);
-    } else if (props.type === "color") {
+    } else if (this.props.type === "color") {
-      newValues.push("#000000");
+      values.push("#000000");
     } else {
-      newValues.push("");
+      values.push("");
     }
 
-    if (props.onChange) props.onChange(newValues);
+    if (this.props.onChange) this.props.onChange(values);
   };
 
-  const deleteValue = (valueIdx: number) => {
+  deleteValue(valueIdx: number) {
-    const newValues = values.slice(0);
+    const values = this.values.slice(0);
-    newValues.splice(valueIdx, 1);
+    values.splice(valueIdx, 1);
 
-    if (props.onChange) props.onChange(newValues.length > 0 ? newValues : undefined);
+    if (this.props.onChange) this.props.onChange(values.length > 0 ? values : undefined);
-  };
+  }
 
-  const t = props.t;
+  render() {
-  const i18nProps = { t, i18n: props.i18n, tReady: props.tReady };
+    const t = this.props.t;
-  const inputs = values.map((v, i) => {
+    const i18nProps = { t, i18n: this.props.i18n, tReady: this.props.tReady };
+    const inputs = this.values.map((v, i) => {
       const deleteValueBtn= <DeleteValueInputButton
-      onClick={deleteValue.bind(null, i)}
+        onClick={this.deleteValue.bind(this, i)}
         {...i18nProps}
       />;
       let input;
-    if(props.type === "url") {
+      if(this.props.type === "url") {
         input = <InputUrl
           value={v as string}
-        onChange={changeValue.bind(null, i)}
+          onChange={this.changeValue.bind(this, i)}
-        aria-label={props["aria-label"] || props.label}
+          aria-label={this.props["aria-label"] || this.props.label}
         />;
       }
-    else if (props.type === "number") {
+      else if (this.props.type === "number") {
         input = <InputNumber
           value={v as number}
-        onChange={changeValue.bind(null, i)}
+          onChange={this.changeValue.bind(this, i)}
-        aria-label={props["aria-label"] || props.label}
+          aria-label={this.props["aria-label"] || this.props.label}
         />;
       }
-    else if (props.type === "enum") {
+      else if (this.props.type === "enum") {
-      const options = Object.keys(props.fieldSpec?.values).map(v => [v, capitalize(v)]);
+        const options = Object.keys(this.props.fieldSpec?.values).map(v => [v, capitalize(v)]);
         input = <InputEnum
           options={options}
           value={v as string}
-        onChange={changeValue.bind(null, i)}
+          onChange={this.changeValue.bind(this, i)}
-        aria-label={props["aria-label"] || props.label}
+          aria-label={this.props["aria-label"] || this.props.label}
         />;
       }
-    else if (props.type === "color") {
+      else if (this.props.type === "color") {
         input = <InputColor
           value={v as string}
-        onChange={changeValue.bind(null, i)}
+          onChange={this.changeValue.bind(this, i)}
-        aria-label={props["aria-label"] || props.label}
+          aria-label={this.props["aria-label"] || this.props.label}
         />;
       }
       else {
         input = <InputString
           value={v as string}
-        onChange={changeValue.bind(null, i)}
+          onChange={this.changeValue.bind(this, i)}
-        aria-label={props["aria-label"] || props.label}
+          aria-label={this.props["aria-label"] || this.props.label}
         />;
       }
 
       return <div
-      style={props.style}
+        style={this.props.style}
         key={i}
         className="maputnik-array-block"
       >
@@ -129,28 +132,33 @@ const InputDynamicArrayInternal: React.FC<InputDynamicArrayInternalProps> = (pro
         {inputs}
         <InputButton
           className="maputnik-array-add-value"
-        onClick={addValue}
+          onClick={this.addValue}
         >
           {t("Add value")}
         </InputButton>
       </div>
     );
-};
+  }
+}
+
+const InputDynamicArray = withTranslation()(InputDynamicArrayInternal);
+export default InputDynamicArray;
 
-export const InputDynamicArray = withTranslation()(InputDynamicArrayInternal);
 type DeleteValueInputButtonProps = {
   onClick?(...args: unknown[]): unknown
 } & WithTranslation;
 
-const DeleteValueInputButton: React.FC<DeleteValueInputButtonProps> = (props) => {
+class DeleteValueInputButton extends React.Component<DeleteValueInputButtonProps> {
-  const t = props.t;
+  render() {
+    const t = this.props.t;
     return <InputButton
       className="maputnik-delete-stop"
-    onClick={props.onClick}
+      onClick={this.props.onClick}
       title={t("Remove array item")}
     >
       <FieldDocLabel
         label={<MdDelete />}
       />
     </InputButton>;
-};
+  }
+}

src/components/InputEnum.tsx

@@ -1,6 +1,6 @@
 import React from "react";
-import { InputSelect } from "./InputSelect";
+import InputSelect from "./InputSelect";
-import { InputMultiInput } from "./InputMultiInput";
+import InputMultiInput from "./InputMultiInput";
 
 
 function optionsLabelLength(options: any[]) {
@@ -25,23 +25,25 @@ export type InputEnumProps = {
 };
 
 
-export const InputEnum: React.FC<InputEnumProps> = (props) => {
+export default class InputEnum extends React.Component<InputEnumProps> {
-  const {options, value, onChange, name, label} = props;
+  render() {
+    const {options, value, onChange, name, label} = this.props;
 
     if(options.length <= 3 && optionsLabelLength(options) <= 20) {
       return <InputMultiInput
         name={name}
         options={options}
-      value={(value || props.default)!}
+        value={(value || this.props.default)!}
         onChange={onChange}
-      aria-label={props["aria-label"] || label}
+        aria-label={this.props["aria-label"] || label}
       />;
     } else {
       return <InputSelect
         options={options}
-      value={(value || props.default)!}
+        value={(value || this.props.default)!}
         onChange={onChange}
-      aria-label={props["aria-label"] || label}
+        aria-label={this.props["aria-label"] || label}
       />;
     }
-};
+  }
+}

src/components/InputFont.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { InputAutocomplete } from "./InputAutocomplete";
+import InputAutocomplete from "./InputAutocomplete";
 
 export type InputFontProps = {
   name: string
@@ -11,9 +11,13 @@ export type InputFontProps = {
   "aria-label"?: string
 };
 
-export const InputFont: React.FC<InputFontProps> = ({fonts = [], ...props}) => {
+export default class InputFont extends React.Component<InputFontProps> {
-  const getValues = () => {
+  static defaultProps = {
-    const out = props.value || props.default || [];
+    fonts: []
+  };
+
+  get values() {
+    const out = this.props.value || this.props.default || [];
 
     // Always put a "" in the last field to you can keep adding entries
     if (out[out.length-1] !== ""){
@@ -22,29 +26,28 @@ export const InputFont: React.FC<InputFontProps> = ({fonts = [], ...props}) => {
     else {
       return out;
     }
-  };
+  }
 
-  const values = getValues();
+  changeFont(idx: number, newValue: string) {
-
+    const changedValues = this.values.slice(0);
-  const changeFont = (idx: number, newValue: string) => {
-    const changedValues = values.slice(0);
     changedValues[idx] = newValue;
     const filteredValues = changedValues
       .filter(v => v !== undefined)
       .filter(v => v !== "");
 
-    props.onChange(filteredValues);
+    this.props.onChange(filteredValues);
-  };
+  }
 
-  const inputs = values.map((value, i) => {
+  render() {
+    const inputs = this.values.map((value, i) => {
       return <li
         key={i}
       >
         <InputAutocomplete
-        aria-label={props["aria-label"] || props.name}
+          aria-label={this.props["aria-label"] || this.props.name}
           value={value}
-        options={fonts.map(f => [f, f])}
+          options={this.props.fonts?.map(f => [f, f])}
-        onChange={changeFont.bind(null, i)}
+          onChange={this.changeFont.bind(this, i)}
         />
       </li>;
     });
@@ -54,4 +57,5 @@ export const InputFont: React.FC<InputFontProps> = ({fonts = [], ...props}) => {
         {inputs}
       </ul>
     );
-};
+  }
+}

src/components/InputJson.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useRef } from "react";
+import React from "react";
 import classnames from "classnames";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
@@ -25,49 +25,88 @@ export type InputJsonProps = {
 };
 type InputJsonInternalProps = InputJsonProps & WithTranslation;
 
-function getPrettyJson(data: any) {
+type InputJsonState = {
+  isEditing: boolean
+  prevValue: string
+};
+
+class InputJsonInternal extends React.Component<InputJsonInternalProps, InputJsonState> {
+  static defaultProps = {
+    onFocus: () => {},
+    onBlur: () => {},
+    withScroll: false
+  };
+  _view: EditorView | undefined;
+  _el: HTMLDivElement | null = null;
+  _cancelNextChange: boolean = false;
+
+  constructor(props: InputJsonInternalProps) {
+    super(props);
+    this.state = {
+      isEditing: false,
+      prevValue: this.getPrettyJson(this.props.value),
+    };
+  }
+
+  getPrettyJson(data: any) {
     return stringifyPretty(data, {indent: 2, maxLength: 40});
-}
+  }
 
-const InputJsonInternal: React.FC<InputJsonInternalProps> = ({
+  componentDidMount () {
-  value,
+    this._view = createEditor({
-  className,
+      parent: this._el!,
-  onChange,
+      value: this.getPrettyJson(this.props.value),
-  onFocus = () => {},
+      lintType: this.props.lintType || "layer",
-  onBlur = () => {},
+      onChange: (value:string) => this.onChange(value),
-  lintType,
+      onFocus: () => this.onFocus(),
-  spec,
+      onBlur: () => this.onBlur(),
-  withScroll = false,
+      spec: this.props.spec
-}) => {
+    });
-  const el = useRef<HTMLDivElement | null>(null);
+  }
-  const view = useRef<EditorView | undefined>(undefined);
-  const cancelNextChange = useRef<boolean>(false);
-  // `isEditing` and `prevValue` are never rendered, they are only read from the
-  // CodeMirror callbacks, so refs keep them up to date without re-rendering.
-  const isEditing = useRef<boolean>(false);
-  const prevValue = useRef<string>(getPrettyJson(value));
-  // Mirrors `prevProps.value` from the previous `componentDidUpdate`.
-  const prevValueProp = useRef<object>(value);
 
-  const handleFocus = () => {
+  onFocus = () => {
-    if (onFocus) onFocus();
+    if (this.props.onFocus) this.props.onFocus();
-    isEditing.current = true;
+    this.setState({
+      isEditing: true,
+    });
   };
 
-  const handleBlur = () => {
+  onBlur = () => {
-    if (onBlur) onBlur();
+    if (this.props.onBlur) this.props.onBlur();
-    isEditing.current = false;
+    this.setState({
+      isEditing: false,
+    });
   };
 
-  const handleChange = () => {
+  componentDidUpdate(prevProps: InputJsonProps) {
-    if (cancelNextChange.current) {
+    if (!this.state.isEditing && prevProps.value !== this.props.value) {
-      cancelNextChange.current = false;
+      this._cancelNextChange = true;
-      prevValue.current = view.current!.state.doc.toString();
+      const transactionSpec: TransactionSpec = {
+        changes: {
+          from: 0,
+          to: this._view!.state.doc.length,
+          insert: this.getPrettyJson(this.props.value)
+        }
+      };
+      if (this.props.withScroll) {
+        transactionSpec.selection = this._view!.state.selection;
+        transactionSpec.scrollIntoView = true;
+      }
+      this._view!.dispatch(transactionSpec);
+    }
+  }
+
+  onChange = (_e: unknown) => {
+    if (this._cancelNextChange) {
+      this._cancelNextChange = false;
+      this.setState({
+        prevValue: this._view!.state.doc.toString(),
+      });
       return;
     }
-    const newCode = view.current!.state.doc.toString();
+    const newCode = this._view!.state.doc.toString();
 
-    if (prevValue.current !== newCode) {
+    if (this.state.prevValue !== newCode) {
       let parsedLayer, err;
       try {
         parsedLayer = JSON.parse(newCode);
@@ -77,63 +116,24 @@ const InputJsonInternal: React.FC<InputJsonInternalProps> = ({
       }
 
       if (!err) {
-        if (onChange) onChange(parsedLayer);
+        if (this.props.onChange) this.props.onChange(parsedLayer);
       }
     }
 
-    prevValue.current = newCode;
+    this.setState({
+      prevValue: newCode,
+    });
   };
 
-  // The editor is created once on mount, so its callbacks have to go through a
+  render() {
-  // ref to always see the latest props.
-  const handlers = useRef({handleChange, handleFocus, handleBlur});
-  useEffect(() => {
-    handlers.current = {handleChange, handleFocus, handleBlur};
-  });
-
-  useEffect(() => {
-    view.current = createEditor({
-      parent: el.current!,
-      value: getPrettyJson(value),
-      lintType: lintType || "layer",
-      onChange: () => handlers.current.handleChange(),
-      onFocus: () => handlers.current.handleFocus(),
-      onBlur: () => handlers.current.handleBlur(),
-      spec: spec
-    });
-    // Runs once on mount, mirroring the previous componentDidMount.
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- mount-only: adding deps would rebuild the editor on every change
-  }, []);
-
-  useEffect(() => {
-    // Only react to an actual change of the `value` prop, which also skips the
-    // initial mount (the editor is created with the value already).
-    if (prevValueProp.current === value) return;
-    prevValueProp.current = value;
-
-    if (isEditing.current) return;
-
-    cancelNextChange.current = true;
-    const transactionSpec: TransactionSpec = {
-      changes: {
-        from: 0,
-        to: view.current!.state.doc.length,
-        insert: getPrettyJson(value)
-      }
-    };
-    if (withScroll) {
-      transactionSpec.selection = view.current!.state.selection;
-      transactionSpec.scrollIntoView = true;
-    }
-    view.current!.dispatch(transactionSpec);
-  }, [value, withScroll]);
-
     return <div className="json-editor" data-wd-key="json-editor" aria-hidden="true" style={{cursor: "text"}}>
       <div
-      className={classnames("codemirror-container", className)}
+        className={classnames("codemirror-container", this.props.className)}
-      ref={el}
+        ref={(el) => {this._el = el;}}
       />
     </div>;
-};
+  }
+}
 
-export const InputJson = withTranslation()(InputJsonInternal);
+const InputJson = withTranslation()(InputJsonInternal);
+export default InputJson;

src/components/InputMultiInput.tsx

@@ -9,21 +9,22 @@ export type InputMultiInputProps = {
   "aria-label"?: string
 };
 
-export const InputMultiInput: React.FC<InputMultiInputProps> = (props) => {
+export default class InputMultiInput extends React.Component<InputMultiInputProps> {
-  let options = props.options;
+  render() {
+    let options = this.props.options;
     if(options.length > 0 && !Array.isArray(options[0])) {
       options = options.map(v => [v, v]);
     }
 
-  const selectedValue = props.value || options[0][0];
+    const selectedValue = this.props.value || options[0][0];
     const radios = options.map(([val, label])=> {
       return <label
         key={val}
         className={classnames("maputnik-button", "maputnik-radio-as-button", {"maputnik-button-selected": val === selectedValue})}
       >
         <input type="radio"
-        name={props.name}
+          name={this.props.name}
-        onChange={_e => props.onChange(val)}
+          onChange={_e => this.props.onChange(val)}
           value={val}
           checked={val === selectedValue}
         />
@@ -31,7 +32,8 @@ export const InputMultiInput: React.FC<InputMultiInputProps> = (props) => {
       </label>;
     });
 
-  return <fieldset className="maputnik-multibutton" aria-label={props["aria-label"]}>
+    return <fieldset className="maputnik-multibutton" aria-label={this.props["aria-label"]}>
       {radios}
     </fieldset>;
-};
+  }
+}

src/components/InputNumber.tsx

@@ -1,4 +1,5 @@
-import React, { type BaseSyntheticEvent, useRef, useState } from "react";
+import React, { type BaseSyntheticEvent } from "react";
+import generateUniqueId from "../libs/document-uid";
 
 export type InputNumberProps = {
   value?: number
@@ -13,136 +14,162 @@ export type InputNumberProps = {
   "aria-label"?: string
 };
 
-export const InputNumber: React.FC<InputNumberProps> = (props) => {
+type InputNumberState = {
-  const { rangeStep = 1 } = props;
+  uuid: number
+  editing: boolean
+  editingRange?: boolean
+  value?: number
+  /**
+   * This is the value that is currently being edited. It can be an invalid value.
+   */
+  dirtyValue?: number | string | undefined
+};
 
-  const [editing, setEditing] = useState(false);
+export default class InputNumber extends React.Component<InputNumberProps, InputNumberState> {
-  const [editingRange, setEditingRange] = useState(false);
+  static defaultProps = {
-  const [value, setValue] = useState<number | undefined>(props.value);
+    rangeStep: 1
-  /** The value currently being edited. It can be an invalid value. */
+  };
-  const [dirtyValue, setDirtyValue] = useState<number | string | undefined>(props.value);
+  _keyboardEvent: boolean = false;
 
-  const keyboardEvent = useRef(false);
+  constructor(props: InputNumberProps) {
-
+    super(props);
-  // Replaces getDerivedStateFromProps: while not editing, track the prop.
+    this.state = {
-  if (!editing && props.value !== value) {
+      uuid: +generateUniqueId(),
-    setValue(props.value);
+      editing: false,
-    setDirtyValue(props.value);
+      value: props.value,
+      dirtyValue: props.value,
+    };
   }
 
-  function isValid(v: number | string | undefined) {
+  static getDerivedStateFromProps(props: Readonly<InputNumberProps>, state: InputNumberState) {
+    if (!state.editing && props.value !== state.value) {
+      return {
+        value: props.value,
+        dirtyValue: props.value,
+      };
+    }
+    return null;
+  }
+
+  changeValue(newValue: number | string | undefined) {
+    const value = (newValue === "" || newValue === undefined) ?
+      undefined : +newValue;
+
+    const hasChanged = this.props.value !== value;
+    if(this.isValid(value) && hasChanged) {
+      if (this.props.onChange) this.props.onChange(value);
+      this.setState({
+        value: value,
+      });
+    }
+    else if (!this.isValid(value) && hasChanged) {
+      this.setState({
+        value: undefined,
+      });
+    }
+
+    this.setState({
+      dirtyValue: newValue === "" ? undefined : newValue,
+    });
+  }
+
+  isValid(v: number | string | undefined) {
     if (v === undefined) {
       return true;
     }
 
-    const val = +v;
+    const value = +v;
-    if(isNaN(val)) {
+    if(isNaN(value)) {
       return false;
     }
 
-    if(!isNaN(props.min!) && val < props.min!) {
+    if(!isNaN(this.props.min!) && value < this.props.min!) {
       return false;
     }
 
-    if(!isNaN(props.max!) && val > props.max!) {
+    if(!isNaN(this.props.max!) && value > this.props.max!) {
       return false;
     }
 
     return true;
   }
 
-  function changeValue(newValue: number | string | undefined) {
+  resetValue = () => {
-    const val = (newValue === "" || newValue === undefined) ?
+    this.setState({editing: false});
-      undefined : +newValue;
-
-    const hasChanged = props.value !== val;
-    if(isValid(val) && hasChanged) {
-      if (props.onChange) props.onChange(val);
-      setValue(val);
-    }
-    else if (!isValid(val) && hasChanged) {
-      setValue(undefined);
-    }
-
-    setDirtyValue(newValue === "" ? undefined : newValue);
-  }
-
-  const resetValue = () => {
-    setEditing(false);
     // Reset explicitly to default value if value has been cleared
-    if(!value) {
+    if(!this.state.value) {
       return;
     }
 
     // If set value is invalid fall back to the last valid value from props or at last resort the default value
-    if (!isValid(value)) {
+    if (!this.isValid(this.state.value)) {
-      if(isValid(props.value)) {
+      if(this.isValid(this.props.value)) {
-        changeValue(props.value);
+        this.changeValue(this.props.value);
-        setDirtyValue(props.value);
+        this.setState({dirtyValue: this.props.value});
       } else {
-        changeValue(undefined);
+        this.changeValue(undefined);
-        setDirtyValue(undefined);
+        this.setState({dirtyValue: undefined});
       }
     }
   };
 
-  const onChangeRange = (e: BaseSyntheticEvent<Event, HTMLInputElement, HTMLInputElement>) => {
+  onChangeRange = (e: BaseSyntheticEvent<Event, HTMLInputElement, HTMLInputElement>) => {
-    let newValue = parseFloat(e.target.value);
+    let value = parseFloat(e.target.value);
-    const step = rangeStep;
+    const step = this.props.rangeStep;
-    let newDirtyValue = newValue;
+    let dirtyValue = value;
 
     if(step) {
       // Can't do this with the <input/> range step attribute else we won't be able to set a high precision value via the text input.
-      const snap = newValue % step;
+      const snap = value % step;
 
       // Round up/down to step
-      if (keyboardEvent.current) {
+      if (this._keyboardEvent) {
         // If it's keyboard event we might get a low positive/negative value,
         // for example we might go from 13 to 13.23, however because we know
         // that came from a keyboard event we always want to increase by a
         // single step value.
-        if (newValue < +dirtyValue!) {
+        if (value < +this.state.dirtyValue!) {
-          newValue = value! - step;
+          value = this.state.value! - step;
         }
         else {
-          newValue = value! + step;
+          value = this.state.value! + step;
         }
-        newDirtyValue = newValue;
+        dirtyValue = value;
       }
       else {
         if (snap < step/2) {
-          newValue = newValue - snap;
+          value = value - snap;
         }
         else {
-          newValue = newValue + (step - snap);
+          value = value + (step - snap);
         }
       }
     }
 
-    keyboardEvent.current = false;
+    this._keyboardEvent = false;
 
     // Clamp between min/max
-    newValue = Math.max(props.min!, Math.min(props.max!, newValue));
+    value = Math.max(this.props.min!, Math.min(this.props.max!, value));
 
-    setValue(newValue);
+    this.setState({value, dirtyValue});
-    setDirtyValue(newDirtyValue);
+    if (this.props.onChange) this.props.onChange(value);
-    if (props.onChange) props.onChange(newValue);
   };
 
+  render() {
     if(
-    Object.prototype.hasOwnProperty.call(props, "min") &&
+      Object.prototype.hasOwnProperty.call(this.props, "min") &&
-    Object.prototype.hasOwnProperty.call(props, "max") &&
+      Object.prototype.hasOwnProperty.call(this.props, "max") &&
-    props.min !== undefined && props.max !== undefined &&
+      this.props.min !== undefined && this.props.max !== undefined &&
-    props.allowRange
+      this.props.allowRange
     ) {
-    const currentValue = editing ? dirtyValue : value;
+      const value = this.state.editing ? this.state.dirtyValue : this.state.value;
-    const defaultValue = props.default === undefined ? "" : props.default;
+      const defaultValue = this.props.default === undefined ? "" : this.props.default;
       let inputValue;
-    if (editingRange) {
+      if (this.state.editingRange) {
-      inputValue = value;
+        inputValue = this.state.value;
       }
       else {
-      inputValue = currentValue;
+        inputValue = value;
       }
 
       return <div className="maputnik-number-container">
@@ -150,69 +177,70 @@ export const InputNumber: React.FC<InputNumberProps> = (props) => {
           className="maputnik-number-range"
           key="range"
           type="range"
-        max={props.max}
+          max={this.props.max}
-        min={props.min}
+          min={this.props.min}
           step="any"
           spellCheck="false"
-        value={currentValue === undefined ? defaultValue : currentValue}
+          value={value === undefined ? defaultValue : value}
-        onChange={onChangeRange}
+          onChange={this.onChangeRange}
           onKeyDown={() => {
-          keyboardEvent.current = true;
+            this._keyboardEvent = true;
           }}
           onPointerDown={() => {
-          setEditing(true);
+            this.setState({editing: true, editingRange: true});
-          setEditingRange(true);
           }}
           onPointerUp={() => {
             // Safari doesn't get onBlur event
-          setEditing(false);
+            this.setState({editing: false, editingRange: false});
-          setEditingRange(false);
           }}
           onBlur={() => {
-          setEditing(false);
+            this.setState({
-          setEditingRange(false);
+              editing: false,
-          setDirtyValue(value);
+              editingRange: false,
+              dirtyValue: this.state.value,
+            });
           }}
-        data-wd-key={props["data-wd-key"] + "-range"}
+          data-wd-key={this.props["data-wd-key"] + "-range"}
         />
         <input
           key="text"
           type="text"
           spellCheck="false"
           className="maputnik-number"
-        placeholder={props.default?.toString()}
+          placeholder={this.props.default?.toString()}
           value={inputValue === undefined ? "" : inputValue}
           onFocus={_e => {
-          setEditing(true);
+            this.setState({editing: true});
           }}
           onChange={e => {
-          changeValue(e.target.value);
+            this.changeValue(e.target.value);
           }}
           onBlur={_e => {
-          setEditing(false);
+            this.setState({editing: false});
-          resetValue();
+            this.resetValue();
           }}
-        data-wd-key={props["data-wd-key"] + "-text"}
+          data-wd-key={this.props["data-wd-key"] + "-text"}
 
         />
       </div>;
     }
     else {
-    const currentValue = editing ? dirtyValue : value;
+      const value = this.state.editing ? this.state.dirtyValue : this.state.value;
 
       return <input
-      aria-label={props["aria-label"]}
+        aria-label={this.props["aria-label"]}
         spellCheck="false"
         className="maputnik-number"
-      placeholder={props.default?.toString()}
+        placeholder={this.props.default?.toString()}
-      value={currentValue === undefined ? "" : currentValue}
+        value={value === undefined ? "" : value}
-      onChange={e => changeValue(e.target.value)}
+        onChange={e => this.changeValue(e.target.value)}
         onFocus={() => {
-        setEditing(true);
+          this.setState({editing: true});
         }}
-      onBlur={resetValue}
+        onBlur={this.resetValue}
-      required={props.required}
+        required={this.props.required}
-      data-wd-key={props["data-wd-key"]}
+        data-wd-key={this.props["data-wd-key"]}
       />;
     }
-};
+  }
+}

src/components/InputSelect.tsx

@@ -10,21 +10,23 @@ export type InputSelectProps = {
   "aria-label"?: string
 };
 
-export const InputSelect: React.FC<InputSelectProps> = (props) => {
+export default class InputSelect extends React.Component<InputSelectProps> {
-  let options = props.options;
+  render() {
+    let options = this.props.options;
     if(options.length > 0 && !Array.isArray(options[0])) {
       options = options.map((v) => [v, v]) as [string, any][];
     }
 
     return <select
       className="maputnik-select"
-    data-wd-key={props["data-wd-key"]}
+      data-wd-key={this.props["data-wd-key"]}
-    style={props.style}
+      style={this.props.style}
-    title={props.title}
+      title={this.props.title}
-    value={props.value}
+      value={this.props.value}
-    onChange={e => props.onChange(e.target.value)}
+      onChange={e => this.props.onChange(e.target.value)}
-    aria-label={props["aria-label"]}
+      aria-label={this.props["aria-label"]}
     >
       { options.map(([val, label]) => <option key={val} value={val}>{label}</option>) }
     </select>;
-};
+  }
+}

src/components/InputSpec.tsx

@@ -1,14 +1,14 @@
 import React, { type ReactElement } from "react";
 
-import { InputColor, type InputColorProps } from "./InputColor";
+import InputColor, { type InputColorProps } from "./InputColor";
-import { InputNumber, type InputNumberProps } from "./InputNumber";
+import InputNumber, { type InputNumberProps } from "./InputNumber";
-import { InputCheckbox, type InputCheckboxProps } from "./InputCheckbox";
+import InputCheckbox, { type InputCheckboxProps } from "./InputCheckbox";
-import { InputString, type InputStringProps } from "./InputString";
+import InputString, { type InputStringProps } from "./InputString";
-import { InputArray, type InputArrayProps } from "./InputArray";
+import InputArray, { type InputArrayProps } from "./InputArray";
-import { InputDynamicArray, type InputDynamicArrayProps } from "./InputDynamicArray";
+import InputDynamicArray, { type InputDynamicArrayProps } from "./InputDynamicArray";
-import { InputFont, type InputFontProps } from "./InputFont";
+import InputFont, { type InputFontProps } from "./InputFont";
-import { InputAutocomplete, type InputAutocompleteProps } from "./InputAutocomplete";
+import InputAutocomplete, { type InputAutocompleteProps } from "./InputAutocomplete";
-import { InputEnum, type InputEnumProps } from "./InputEnum";
+import InputEnum, { type InputEnumProps } from "./InputEnum";
 import capitalize from "lodash.capitalize";
 
 const iconProperties = ["background-pattern", "fill-pattern", "line-pattern", "fill-extrusion-pattern", "icon-image"];
@@ -38,31 +38,31 @@ export type InputSpecProps = {
 /** Display any field from the Maplibre GL style spec and
  * choose the correct field component based on the @{fieldSpec}
  * to display @{value}. */
-export const InputSpec: React.FC<InputSpecProps> = (props) => {
+export default class InputSpec extends React.Component<InputSpecProps> {
 
-  const childNodes = () => {
+  childNodes() {
     const commonProps = {
-      fieldSpec: props.fieldSpec,
+      fieldSpec: this.props.fieldSpec,
-      label: props.label,
+      label: this.props.label,
-      action: props.action,
+      action: this.props.action,
-      style: props.style,
+      style: this.props.style,
-      value: props.value,
+      value: this.props.value,
-      default: props.fieldSpec?.default,
+      default: this.props.fieldSpec?.default,
-      name: props.fieldName,
+      name: this.props.fieldName,
-      "data-wd-key": "spec-field-input:" + props.fieldName,
+      "data-wd-key": "spec-field-input:" + this.props.fieldName,
-      onChange: (newValue: number | undefined | (string | number | undefined)[]) => props.onChange!(props.fieldName, newValue),
+      onChange: (newValue: number | undefined | (string | number | undefined)[]) => this.props.onChange!(this.props.fieldName, newValue),
-      "aria-label": props["aria-label"],
+      "aria-label": this.props["aria-label"],
     };
-    switch(props.fieldSpec?.type) {
+    switch(this.props.fieldSpec?.type) {
       case "number": return (
         <InputNumber
           {...commonProps as InputNumberProps}
-          min={props.fieldSpec.minimum}
+          min={this.props.fieldSpec.minimum}
-          max={props.fieldSpec.maximum}
+          max={this.props.fieldSpec.maximum}
         />
       );
       case "enum": {
-        const options = Object.keys(props.fieldSpec.values || []).map(v => [v, capitalize(v)]);
+        const options = Object.keys(this.props.fieldSpec.values || []).map(v => [v, capitalize(v)]);
 
         return <InputEnum
           {...commonProps as Omit<InputEnumProps, "options">}
@@ -72,8 +72,8 @@ export const InputSpec: React.FC<InputSpecProps> = (props) => {
       case "resolvedImage":
       case "formatted":
       case "string":
-        if (iconProperties.indexOf(props.fieldName!) >= 0) {
+        if (iconProperties.indexOf(this.props.fieldName!) >= 0) {
-          const options = props.fieldSpec.values || [];
+          const options = this.props.fieldSpec.values || [];
           return <InputAutocomplete
             {...commonProps as Omit<InputAutocompleteProps, "options">}
             options={options.map(f => [f, f])}
@@ -94,59 +94,61 @@ export const InputSpec: React.FC<InputSpecProps> = (props) => {
         />
       );
       case "array":
-        if(props.fieldName === "text-font") {
+        if(this.props.fieldName === "text-font") {
           return <InputFont
             {...commonProps as InputFontProps}
-            fonts={props.fieldSpec.values}
+            fonts={this.props.fieldSpec.values}
           />;
         } else {
-          if (props.fieldSpec.length) {
+          if (this.props.fieldSpec.length) {
             return <InputArray
               {...commonProps as InputArrayProps}
-              type={props.fieldSpec.value}
+              type={this.props.fieldSpec.value}
-              length={props.fieldSpec.length}
+              length={this.props.fieldSpec.length}
             />;
           } else {
             return <InputDynamicArray
               {...commonProps as InputDynamicArrayProps}
-              fieldSpec={props.fieldSpec}
+              fieldSpec={this.props.fieldSpec}
-              type={props.fieldSpec.value as InputDynamicArrayProps["type"]}
+              type={this.props.fieldSpec.value as InputDynamicArrayProps["type"]}
             />;
           }
         }
       case "numberArray": return (
         <InputDynamicArray
           {...commonProps as InputDynamicArrayProps}
-          fieldSpec={props.fieldSpec}
+          fieldSpec={this.props.fieldSpec}
           type="number"
-          value={(Array.isArray(props.value) ? props.value : [props.value]) as (string | number | undefined)[]}
+          value={(Array.isArray(this.props.value) ? this.props.value : [this.props.value]) as (string | number | undefined)[]}
         />
       );
       case "colorArray": return (
         <InputDynamicArray
           {...commonProps as InputDynamicArrayProps}
-          fieldSpec={props.fieldSpec}
+          fieldSpec={this.props.fieldSpec}
           type="color"
-          value={(Array.isArray(props.value) ? props.value : [props.value]) as (string | number | undefined)[]}
+          value={(Array.isArray(this.props.value) ? this.props.value : [this.props.value]) as (string | number | undefined)[]}
         />
       );
       case "padding": return (
         <InputArray
           {...commonProps as InputArrayProps}
           type="number"
-          value={(Array.isArray(props.value) ? props.value : [props.value]) as (string | number | undefined)[]}
+          value={(Array.isArray(this.props.value) ? this.props.value : [this.props.value]) as (string | number | undefined)[]}
           length={4}
         />
       );
       default:
-        console.warn(`No proper field input for ${props.fieldName} type: ${props.fieldSpec?.type}`);
+        console.warn(`No proper field input for ${this.props.fieldName} type: ${this.props.fieldSpec?.type}`);
         return null;
     }
-  };
+  }
 
+  render() {
     return (
-    <div data-wd-key={"spec-field:"+props.fieldName}>
+      <div data-wd-key={"spec-field:"+this.props.fieldName}>
-      {childNodes()}
+        {this.childNodes()}
       </div>
     );
-};
+  }
+}

src/components/InputString.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React from "react";
 
 export type InputStringProps = {
   "data-wd-key"?: string
@@ -15,21 +15,38 @@ export type InputStringProps = {
   title?: string
 };
 
-export const InputString: React.FC<InputStringProps> = (props) => {
+type InputStringState = {
-  const { onInput = () => {} } = props;
+  editing: boolean
-  const [editing, setEditing] = useState(false);
+  value?: string
-  const [value, setValue] = useState<string | undefined>(props.value);
+};
 
-  // Replaces getDerivedStateFromProps: while the field is not being edited its
+export default class InputString extends React.Component<InputStringProps, InputStringState> {
-  // value tracks the prop, so an external change to the style is picked up.
+  static defaultProps = {
-  if (!editing && value !== props.value) {
+    onInput: () => {},
-    setValue(props.value);
+  };
+
+  constructor(props: InputStringProps) {
+    super(props);
+    this.state = {
+      editing: false,
+      value: props.value || ""
+    };
   }
 
+  static getDerivedStateFromProps(props: Readonly<InputStringProps>, state: InputStringState) {
+    if (!state.editing) {
+      return {
+        value: props.value
+      };
+    }
+    return {};
+  }
+
+  render() {
     let tag;
     let classes;
 
-  if(props.multi) {
+    if(this.props.multi) {
       tag = "textarea";
       classes = [
         "maputnik-string",
@@ -43,38 +60,40 @@ export const InputString: React.FC<InputStringProps> = (props) => {
       ];
     }
 
-  if(props.disabled) {
+    if(this.props.disabled) {
       classes.push("maputnik-string--disabled");
     }
 
     return React.createElement(tag, {
-    "aria-label": props["aria-label"],
+      "aria-label": this.props["aria-label"],
-    "data-wd-key": props["data-wd-key"],
+      "data-wd-key": this.props["data-wd-key"],
-    spellCheck: Object.prototype.hasOwnProperty.call(props, "spellCheck") ? props.spellCheck : !(tag === "input"),
+      spellCheck: Object.prototype.hasOwnProperty.call(this.props, "spellCheck") ? this.props.spellCheck : !(tag === "input"),
-    disabled: props.disabled,
+      disabled: this.props.disabled,
       className: classes.join(" "),
-    style: props.style,
+      style: this.props.style,
-    value: value === undefined ? "" : value,
+      value: this.state.value === undefined ? "" : this.state.value,
-    placeholder: props.default,
+      placeholder: this.props.default,
-    title: props.title,
+      title: this.props.title,
       onChange: (e: React.BaseSyntheticEvent<Event, HTMLInputElement, HTMLInputElement>) => {
-      setEditing(true);
+        this.setState({
-      setValue(e.target.value);
+          editing: true,
-      onInput(e.target.value);
+          value: e.target.value
+        }, () => {
+          if (this.props.onInput) this.props.onInput(this.state.value);
+        });
       },
       onBlur: () => {
-      // Note: editing is only cleared when the value actually changed; this
+        if(this.state.value!==this.props.value) {
-      // mirrors the original and keeps a no-op blur from resyncing the value.
+          this.setState({editing: false});
-      if(value !== props.value) {
+          if (this.props.onChange) this.props.onChange(this.state.value);
-        setEditing(false);
-        if (props.onChange) props.onChange(value);
         }
       },
-    onKeyDown: (e: React.KeyboardEvent) => {
+      onKeyDown: (e) => {
-      if (e.keyCode === 13 && props.onChange) {
+        if (e.keyCode === 13 && this.props.onChange) {
-        props.onChange(value);
+          this.props.onChange(this.state.value);
         }
       },
-    required: props.required,
+      required: this.props.required,
     });
-};
+  }
+}

src/components/InputUrl.tsx

@@ -1,6 +1,6 @@
-import React, { type JSX, useState } from "react";
+import React, { type JSX } from "react";
-import { InputString } from "./InputString";
+import InputString from "./InputString";
-import { SmallError } from "./SmallError";
+import SmallError from "./SmallError";
 import { Trans, type WithTranslation, withTranslation } from "react-i18next";
 import { type TFunction } from "i18next";
 import { ErrorType, validate } from "../libs/urlopen";
@@ -46,30 +46,50 @@ export type FieldUrlProps = {
 
 type InputUrlInternalProps = FieldUrlProps & WithTranslation;
 
-const InputUrlInternal: React.FC<InputUrlInternalProps> = ({onInput = () => {}, ...props}) => {
+type InputUrlState = {
-  const [error, setError] = useState<ErrorType | undefined>(() => validate(props.value));
+  error?: ErrorType
+};
 
-  const handleInput = (url: string) => {
+class InputUrlInternal extends React.Component<InputUrlInternalProps, InputUrlState> {
-    setError(validate(url));
+  static defaultProps = {
-    onInput(url);
+    onInput: () => {},
   };
 
-  const handleChange = (url: string) => {
+  constructor (props: InputUrlInternalProps) {
-    setError(validate(url));
+    super(props);
-    props.onChange(url);
+    this.state = {
+      error: validate(props.value),
+    };
+  }
+
+  onInput = (url: string) => {
+    this.setState({
+      error: validate(url),
+    });
+    if (this.props.onInput) this.props.onInput(url);
   };
 
+  onChange = (url: string) => {
+    this.setState({
+      error: validate(url),
+    });
+    this.props.onChange(url);
+  };
+
+  render () {
     return (
       <div>
         <InputString
-        {...props}
+          {...this.props}
-        onInput={handleInput}
+          onInput={this.onInput}
-        onChange={handleChange}
+          onChange={this.onChange}
-        aria-label={props["aria-label"]}
+          aria-label={this.props["aria-label"]}
         />
-      {errorTypeToJsx(error, props.t)}
+        {errorTypeToJsx(this.state.error, this.props.t)}
       </div>
     );
-};
+  }
+}
 
-export const InputUrl = withTranslation()(InputUrlInternal);
+const InputUrl = withTranslation()(InputUrlInternal);
+export default InputUrl;

src/components/LayerEditor.tsx

@@ -1,4 +1,4 @@
-import React, { type JSX, useState } from "react";
+import React, { type JSX } from "react";
 import { Wrapper, Button, Menu, MenuItem } from "react-aria-menubutton";
 import { Accordion } from "react-accessible-accordion";
 import { MdMoreVert } from "react-icons/md";
@@ -6,20 +6,18 @@ import { IconContext } from "react-icons";
 import { type BackgroundLayerSpecification, type LayerSpecification, type SourceSpecification } from "maplibre-gl";
 import { v8 } from "@maplibre/maplibre-gl-style-spec";
 
-import { FieldJson } from "./FieldJson";
+import FieldJson from "./FieldJson";
-import { FilterEditor } from "./FilterEditor";
+import FilterEditor from "./FilterEditor";
-import { PropertyGroup } from "./PropertyGroup";
+import PropertyGroup from "./PropertyGroup";
-import { LayerEditorGroup } from "./LayerEditorGroup";
+import LayerEditorGroup from "./LayerEditorGroup";
-import { FieldType } from "./FieldType";
+import FieldType from "./FieldType";
-import { FieldId } from "./FieldId";
+import FieldId from "./FieldId";
-import { FieldMinZoom } from "./FieldMinZoom";
+import FieldMinZoom from "./FieldMinZoom";
-import { FieldMaxZoom } from "./FieldMaxZoom";
+import FieldMaxZoom from "./FieldMaxZoom";
-import { FieldComment } from "./FieldComment";
+import FieldComment from "./FieldComment";
-import { FieldSource } from "./FieldSource";
+import FieldSource from "./FieldSource";
-import { FieldSourceLayer } from "./FieldSourceLayer";
+import FieldSourceLayer from "./FieldSourceLayer";
-// Aliased: the component defines its own changeProperty, which would otherwise
+import { changeType, changeProperty } from "../libs/layer";
-// shadow this import (as a class method there was no collision).
-import { changeType, changeProperty as changeLayerProperty } from "../libs/layer";
 import { formatLayerId } from "../libs/format";
 import { type WithTranslation, withTranslation } from "react-i18next";
 import { type TFunction } from "i18next";
@@ -133,56 +131,67 @@ type LayerEditorInternalProps = {
   errors?: MappedError[]
 } & WithTranslation;
 
+type LayerEditorState = {
+  editorGroups: { [keys: string]: boolean }
+};
+
 /** Layer editor supporting multiple types of layers. */
-const LayerEditorInternal: React.FC<LayerEditorInternalProps> = ({
+class LayerEditorInternal extends React.Component<LayerEditorInternalProps, LayerEditorState> {
-  onLayerChanged = () => { },
+  static defaultProps = {
-  onLayerIdChange = () => { },
+    onLayerChanged: () => { },
-  ...rest
+    onLayerIdChange: () => { },
-}) => {
+    onLayerDestroyed: () => { },
-  const props = { onLayerChanged, onLayerIdChange, ...rest } as LayerEditorInternalProps;
+  };
 
-  const [editorGroups, setEditorGroups] = useState<{ [keys: string]: boolean }>(() => {
+  constructor(props: LayerEditorInternalProps) {
-    const groups: { [keys: string]: boolean } = {};
+    super(props);
-    for (const group of layoutGroups(props.layer.type, props.t)) {
+
-      groups[group.title] = true;
+    const editorGroups: { [keys: string]: boolean } = {};
+    for (const group of layoutGroups(this.props.layer.type, props.t)) {
+      editorGroups[group.title] = true;
     }
-    return groups;
-  });
 
-  // Replaces getDerivedStateFromProps: groups that appear after mount (because
+    this.state = { editorGroups };
-  // the layer type changed) start out expanded. Guarded so it only sets state
+  }
-  // when a group is genuinely new, otherwise this would loop every render.
+
-  const newGroups = getLayoutForType(props.layer.type, props.t)
+  static getDerivedStateFromProps(props: Readonly<LayerEditorInternalProps>, state: LayerEditorState) {
-    .filter(group => !(group.title in editorGroups));
+    const additionalGroups = { ...state.editorGroups };
-  if (newGroups.length > 0) {
+
-    const additionalGroups = { ...editorGroups };
+    for (const group of getLayoutForType(props.layer.type, props.t)) {
-    for (const group of newGroups) {
+      if (!(group.title in additionalGroups)) {
         additionalGroups[group.title] = true;
       }
-    setEditorGroups(additionalGroups);
     }
 
-  function changeProperty(group: keyof LayerSpecification | null, property: string, newValue: any) {
+    return {
-    props.onLayerChanged(
+      editorGroups: additionalGroups
-      props.layerIndex,
+    };
-      changeLayerProperty(props.layer, group, property, newValue)
+  }
+
+
+  changeProperty(group: keyof LayerSpecification | null, property: string, newValue: any) {
+    this.props.onLayerChanged(
+      this.props.layerIndex,
+      changeProperty(this.props.layer, group, property, newValue)
     );
   }
 
-  function onGroupToggle(groupTitle: string, active: boolean) {
+  onGroupToggle(groupTitle: string, active: boolean) {
     const changedActiveGroups = {
-      ...editorGroups,
+      ...this.state.editorGroups,
       [groupTitle]: active,
     };
-    setEditorGroups(changedActiveGroups);
+    this.setState({
+      editorGroups: changedActiveGroups
+    });
   }
 
-  function renderGroupType(type: string, fields?: string[]): JSX.Element {
+  renderGroupType(type: string, fields?: string[]): JSX.Element {
     let comment = "";
-    if (props.layer.metadata) {
+    if (this.props.layer.metadata) {
-      comment = (props.layer.metadata as any)["maputnik:comment"];
+      comment = (this.props.layer.metadata as any)["maputnik:comment"];
     }
-    const { errors, layerIndex } = props;
+    const { errors, layerIndex } = this.props;
 
     const errorData: MappedLayerErrors = {};
     errors!.forEach(error => {
@@ -198,85 +207,84 @@ const LayerEditorInternal: React.FC<LayerEditorInternalProps> = ({
     });
 
     let sourceLayerIds;
-    const layer = props.layer as Exclude<LayerSpecification, BackgroundLayerSpecification>;
+    const layer = this.props.layer as Exclude<LayerSpecification, BackgroundLayerSpecification>;
-    if (Object.prototype.hasOwnProperty.call(props.sources, layer.source)) {
+    if (Object.prototype.hasOwnProperty.call(this.props.sources, layer.source)) {
-      sourceLayerIds = props.sources[layer.source].layers;
+      sourceLayerIds = this.props.sources[layer.source].layers;
     }
 
     switch (type) {
       case "layer": return <div>
         <FieldId
-          value={props.layer.id}
+          value={this.props.layer.id}
           wdKey="layer-editor.layer-id"
           error={errorData.id}
-          onChange={newId => props.onLayerIdChange(props.layerIndex, props.layer.id, newId)}
+          onChange={newId => this.props.onLayerIdChange(this.props.layerIndex, this.props.layer.id, newId)}
         />
         <FieldType
           disabled={true}
           error={errorData.type}
-          value={props.layer.type}
+          value={this.props.layer.type}
-          onChange={newType => props.onLayerChanged(
+          onChange={newType => this.props.onLayerChanged(
-            props.layerIndex,
+            this.props.layerIndex,
-            changeType(props.layer, newType)
+            changeType(this.props.layer, newType)
           )}
         />
-        {props.layer.type !== "background" && <FieldSource
+        {this.props.layer.type !== "background" && <FieldSource
-          wdKey="layer-editor.layer-source"
           error={errorData.source}
-          sourceIds={Object.keys(props.sources!)}
+          sourceIds={Object.keys(this.props.sources!)}
-          value={props.layer.source}
+          value={this.props.layer.source}
-          onChange={v => changeProperty(null, "source", v)}
+          onChange={v => this.changeProperty(null, "source", v)}
         />
         }
-        {!NON_SOURCE_LAYERS.includes(props.layer.type) &&
+        {!NON_SOURCE_LAYERS.includes(this.props.layer.type) &&
           <FieldSourceLayer
             error={errorData["source-layer"]}
             sourceLayerIds={sourceLayerIds}
-            value={(props.layer as any)["source-layer"]}
+            value={(this.props.layer as any)["source-layer"]}
-            onChange={v => changeProperty(null, "source-layer", v)}
+            onChange={v => this.changeProperty(null, "source-layer", v)}
           />
         }
         <FieldMinZoom
           error={errorData.minzoom}
-          value={props.layer.minzoom}
+          value={this.props.layer.minzoom}
-          onChange={v => changeProperty(null, "minzoom", v)}
+          onChange={v => this.changeProperty(null, "minzoom", v)}
         />
         <FieldMaxZoom
           error={errorData.maxzoom}
-          value={props.layer.maxzoom}
+          value={this.props.layer.maxzoom}
-          onChange={v => changeProperty(null, "maxzoom", v)}
+          onChange={v => this.changeProperty(null, "maxzoom", v)}
         />
         <FieldComment
           error={errorData.comment}
           value={comment}
-          onChange={v => changeProperty("metadata", "maputnik:comment", v == "" ? undefined : v)}
+          onChange={v => this.changeProperty("metadata", "maputnik:comment", v == "" ? undefined : v)}
         />
       </div>;
       case "filter": return <div>
         <div className="maputnik-filter-editor-wrapper">
           <FilterEditor
             errors={errorData}
-            filter={(props.layer as any).filter}
+            filter={(this.props.layer as any).filter}
-            properties={props.vectorLayers[(props.layer as any)["source-layer"]]}
+            properties={this.props.vectorLayers[(this.props.layer as any)["source-layer"]]}
-            onChange={f => changeProperty(null, "filter", f)}
+            onChange={f => this.changeProperty(null, "filter", f)}
           />
         </div>
       </div>;
       case "properties":
         return <PropertyGroup
           errors={errorData}
-          layer={props.layer}
+          layer={this.props.layer}
           groupFields={fields!}
-          spec={props.spec}
+          spec={this.props.spec}
-          onChange={changeProperty.bind(null)}
+          onChange={this.changeProperty.bind(this)}
         />;
       case "jsoneditor":
         return <FieldJson
           lintType="layer"
-          value={props.layer}
+          value={this.props.layer}
           onChange={(layer: LayerSpecification) => {
-            props.onLayerChanged(
+            this.props.onLayerChanged(
-              props.layerIndex,
+              this.props.layerIndex,
               layer
             );
           }}
@@ -285,17 +293,18 @@ const LayerEditorInternal: React.FC<LayerEditorInternalProps> = ({
     }
   }
 
-  function moveLayer(offset: number) {
+  moveLayer(offset: number) {
-    props.onMoveLayer({
+    this.props.onMoveLayer({
-      oldIndex: props.layerIndex,
+      oldIndex: this.props.layerIndex,
-      newIndex: props.layerIndex + offset
+      newIndex: this.props.layerIndex + offset
     });
   }
 
-  const t = props.t;
+  render() {
+    const t = this.props.t;
 
     const groupIds: string[] = [];
-  const layerType = props.layer.type;
+    const layerType = this.props.layer.type;
     const groups = layoutGroups(layerType, t).filter(group => {
       return !(layerType === "background" && group.type === "source");
     }).map(group => {
@@ -306,14 +315,14 @@ const LayerEditorInternal: React.FC<LayerEditorInternalProps> = ({
         id={groupId}
         key={groupId}
         title={group.title}
-      isActive={editorGroups[group.title]}
+        isActive={this.state.editorGroups[group.title]}
-      onActiveToggle={onGroupToggle.bind(null, group.title)}
+        onActiveToggle={this.onGroupToggle.bind(this, group.title)}
       >
-      {renderGroupType(group.type, group.fields)}
+        {this.renderGroupType(group.type, group.fields)}
       </LayerEditorGroup>;
     });
 
-  const layout = props.layer.layout || {};
+    const layout = this.props.layer.layout || {};
 
     const items: {
       [key: string]: {
@@ -325,29 +334,29 @@ const LayerEditorInternal: React.FC<LayerEditorInternalProps> = ({
     } = {
       delete: {
         text: t("Delete"),
-      handler: () => props.onLayerDestroy(props.layerIndex),
+        handler: () => this.props.onLayerDestroy(this.props.layerIndex),
         wdKey: "menu-delete-layer"
       },
       duplicate: {
         text: t("Duplicate"),
-      handler: () => props.onLayerCopy(props.layerIndex),
+        handler: () => this.props.onLayerCopy(this.props.layerIndex),
         wdKey: "menu-duplicate-layer"
       },
       hide: {
         text: (layout.visibility === "none") ? t("Show") : t("Hide"),
-      handler: () => props.onLayerVisibilityToggle(props.layerIndex),
+        handler: () => this.props.onLayerVisibilityToggle(this.props.layerIndex),
         wdKey: "menu-hide-layer"
       },
       moveLayerUp: {
         text: t("Move layer up"),
-      disabled: props.isFirstLayer,
+        disabled: this.props.isFirstLayer,
-      handler: () => moveLayer(-1),
+        handler: () => this.moveLayer(-1),
         wdKey: "menu-move-layer-up"
       },
       moveLayerDown: {
         text: t("Move layer down"),
-      disabled: props.isLastLayer,
+        disabled: this.props.isLastLayer,
-      handler: () => moveLayer(+1),
+        handler: () => this.moveLayer(+1),
         wdKey: "menu-move-layer-down"
       }
     };
@@ -366,7 +375,7 @@ const LayerEditorInternal: React.FC<LayerEditorInternalProps> = ({
         <header data-wd-key="layer-editor.header">
           <div className="layer-header">
             <h2 className="layer-header__title">
-            {t("Layer")}: {formatLayerId(props.layer.id)}
+              {t("Layer")}: {formatLayerId(this.props.layer.id)}
             </h2>
             <div className="layer-header__info">
               <Wrapper
@@ -407,6 +416,8 @@ const LayerEditorInternal: React.FC<LayerEditorInternalProps> = ({
         </Accordion>
       </section>
     </IconContext.Provider>;
-};
+  }
+}
 
-export const LayerEditor = withTranslation()(LayerEditorInternal);
+const LayerEditor = withTranslation()(LayerEditorInternal);
+export default LayerEditor;

src/components/LayerEditorGroup.tsx

@@ -18,20 +18,22 @@ type LayerEditorGroupProps = {
 };
 
 
-export const LayerEditorGroup: React.FC<LayerEditorGroupProps> = (props) => {
+export default class LayerEditorGroup extends React.Component<LayerEditorGroupProps> {
-  return <AccordionItem uuid={props.id}>
+  render() {
+    return <AccordionItem uuid={this.props.id}>
       <AccordionItemHeading className="maputnik-layer-editor-group"
-      data-wd-key={"layer-editor-group:"+props["data-wd-key"]}
+        data-wd-key={"layer-editor-group:"+this.props["data-wd-key"]}
-      onClick={_e => props.onActiveToggle(!props.isActive)}
+        onClick={_e => this.props.onActiveToggle(!this.props.isActive)}
       >
         <AccordionItemButton className="maputnik-layer-editor-group__button">
-        <span style={{flexGrow: 1, alignContent: "center"}}>{props.title}</span>
+          <span style={{flexGrow: 1, alignContent: "center"}}>{this.props.title}</span>
           <MdArrowDropUp size={"2em"} className="maputnik-layer-editor-group__button__icon maputnik-layer-editor-group__button__icon--up"></MdArrowDropUp>
           <MdArrowDropDown size={"2em"} className="maputnik-layer-editor-group__button__icon maputnik-layer-editor-group__button__icon--down"></MdArrowDropDown>
         </AccordionItemButton>
       </AccordionItemHeading>
       <AccordionItemPanel>
-      {props.children}
+        {this.props.children}
       </AccordionItemPanel>
     </AccordionItem>;
-};
+  }
+}

src/components/LayerList.tsx

@@ -1,4 +1,4 @@
-import React, {type JSX, useEffect, useRef, useState} from "react";
+import React, {type JSX} from "react";
 import classnames from "classnames";
 import lodash from "lodash";
 import {
@@ -14,12 +14,12 @@ import {
   verticalListSortingStrategy,
 } from "@dnd-kit/sortable";
 
-import { LayerListGroup } from "./LayerListGroup";
+import LayerListGroup from "./LayerListGroup";
-import { LayerListItem } from "./LayerListItem";
+import LayerListItem from "./LayerListItem";
-import { ModalAdd } from "./modals/ModalAdd";
+import ModalAdd from "./modals/ModalAdd";
 
 import type {LayerSpecification, SourceSpecification} from "maplibre-gl";
-import { generateUniqueId } from "../libs/document-uid";
+import generateUniqueId from "../libs/document-uid";
 import { findClosestCommonPrefix, layerPrefix } from "../libs/layer";
 import { type WithTranslation, withTranslation } from "react-i18next";
 import { type MappedError, type OnMoveLayerCallback } from "../libs/definitions";
@@ -37,98 +37,62 @@ type LayerListContainerProps = {
 };
 type LayerListContainerInternalProps = LayerListContainerProps & WithTranslation;
 
-const noopLayerSelect = () => {};
+type LayerListContainerState = {
-
+  collapsedGroups: {[ket: string]: boolean}
-// Replaces the previous `shouldComponentUpdate`. Note the inversion: this
+  areAllGroupsExpanded: boolean
-// returns true when the props are EQUAL (i.e. no re-render is needed), whereas
+  keys: {[key: string]: number}
-// `shouldComponentUpdate` returned true when a re-render WAS needed.
+  isOpen: {[key: string]: boolean}
-function arePropsEqual(prevProps: LayerListContainerInternalProps, nextProps: LayerListContainerInternalProps) {
+};
-  // This component tree only requires id and visibility from the layers
-  // objects
-  function getRequiredProps(layer: LayerSpecification) {
-    const out: {id: string, layout?: { visibility: any}} = {
-      id: layer.id,
-    };
-
-    if (layer.layout) {
-      out.layout = {
-        visibility: layer.layout.visibility
-      };
-    }
-    return out;
-  }
-  const layersEqual = lodash.isEqual(
-    nextProps.layers.map(getRequiredProps),
-    prevProps.layers.map(getRequiredProps),
-  );
-
-  function withoutLayers(props: LayerListContainerInternalProps) {
-    const out = {
-      ...props
-    } as LayerListContainerInternalProps & { layers?: any };
-    delete out["layers"];
-    return out;
-  }
-
-  // Compare the props without layers because we've already compared them
-  // efficiently above.
-  const propsEqual = lodash.isEqual(
-    withoutLayers(prevProps),
-    withoutLayers(nextProps)
-  );
-
-  return layersEqual && propsEqual;
-}
 
 // List of collapsible layer editors
-function LayerListContainerInternal({
+class LayerListContainerInternal extends React.Component<LayerListContainerInternalProps, LayerListContainerState> {
-  layers: propsLayers,
+  static defaultProps = {
-  selectedLayerIndex,
+    onLayerSelect: () => {},
-  onLayersChange,
+  };
-  onLayerSelect = noopLayerSelect,
+  selectedItemRef: React.RefObject<any>;
-  onLayerDestroy,
+  scrollContainerRef: React.RefObject<HTMLElement | null>;
-  onLayerCopy,
-  onLayerVisibilityToggle,
-  sources,
-  errors,
-  t,
-}: LayerListContainerInternalProps) {
-  const selectedItemRef = useRef<any>(null);
-  const scrollContainerRef = useRef<HTMLElement | null>(null);
-  const hasMountedRef = useRef(false);
 
-  const [collapsedGroups, setCollapsedGroups] = useState<{[key: string]: boolean}>({});
+  constructor(props: LayerListContainerInternalProps) {
-  const [areAllGroupsExpanded, setAreAllGroupsExpanded] = useState(false);
+    super(props);
-  const [keys, setKeys] = useState<{[key: string]: number}>(() => ({
+    this.selectedItemRef = React.createRef();
+    this.scrollContainerRef = React.createRef();
+    this.state = {
+      collapsedGroups: {},
+      areAllGroupsExpanded: false,
+      keys: {
         add: +generateUniqueId(),
-  }));
+      },
-  const [isOpen, setIsOpen] = useState<{[key: string]: boolean}>({
+      isOpen: {
         add: false,
-  });
+      }
-
+    };
-  function toggleModal(modalName: string) {
-    setKeys(prevKeys => ({
-      ...prevKeys,
-      [modalName]: +generateUniqueId(),
-    }));
-    setIsOpen(prevIsOpen => ({
-      ...prevIsOpen,
-      [modalName]: !prevIsOpen[modalName]
-    }));
   }
 
-  const toggleLayers = () => {
+  toggleModal(modalName: string) {
+    this.setState({
+      keys: {
+        ...this.state.keys,
+        [modalName]: +generateUniqueId(),
+      },
+      isOpen: {
+        ...this.state.isOpen,
+        [modalName]: !this.state.isOpen[modalName]
+      }
+    });
+  }
+
+  toggleLayers = () => {
     let idx = 0;
 
     const newGroups: {[key:string]: boolean} = {};
 
-    groupedLayers().forEach(layers => {
+    this.groupedLayers().forEach(layers => {
       const groupPrefix = layerPrefix(layers[0].id);
       const lookupKey = [groupPrefix, idx].join("-");
 
 
       if (layers.length > 1) {
-        newGroups[lookupKey] = areAllGroupsExpanded;
+        newGroups[lookupKey] = this.state.areAllGroupsExpanded;
       }
 
       layers.forEach((_layer) => {
@@ -136,17 +100,19 @@ function LayerListContainerInternal({
       });
     });
 
-    setCollapsedGroups(newGroups);
+    this.setState({
-    setAreAllGroupsExpanded(!areAllGroupsExpanded);
+      collapsedGroups: newGroups,
+      areAllGroupsExpanded: !this.state.areAllGroupsExpanded
+    });
   };
 
-  function groupedLayers(): (LayerSpecification & {key: string})[][] {
+  groupedLayers(): (LayerSpecification & {key: string})[][] {
     const groups = [];
     const layerIdCount = new Map();
 
-    for (let i = 0; i < propsLayers.length; i++) {
+    for (let i = 0; i < this.props.layers.length; i++) {
-      const origLayer = propsLayers[i];
+      const origLayer = this.props.layers[i];
-      const previousLayer = propsLayers[i-1];
+      const previousLayer = this.props.layers[i-1];
       layerIdCount.set(origLayer.id,
         layerIdCount.has(origLayer.id) ? layerIdCount.get(origLayer.id) + 1 : 0
       );
@@ -164,35 +130,75 @@ function LayerListContainerInternal({
     return groups;
   }
 
-  function toggleLayerGroup(groupPrefix: string, idx: number) {
+  toggleLayerGroup(groupPrefix: string, idx: number) {
     const lookupKey = [groupPrefix, idx].join("-");
-    setCollapsedGroups(prevCollapsedGroups => {
+    const newGroups = { ...this.state.collapsedGroups };
-      const newGroups = { ...prevCollapsedGroups };
+    if(lookupKey in this.state.collapsedGroups) {
-      if(lookupKey in prevCollapsedGroups) {
+      newGroups[lookupKey] = !this.state.collapsedGroups[lookupKey];
-        newGroups[lookupKey] = !prevCollapsedGroups[lookupKey];
     } else {
       newGroups[lookupKey] = false;
     }
-      return newGroups;
+    this.setState({
+      collapsedGroups: newGroups
     });
   }
 
-  function isCollapsed(groupPrefix: string, idx: number) {
+  isCollapsed(groupPrefix: string, idx: number) {
-    const collapsed = collapsedGroups[[groupPrefix, idx].join("-")];
+    const collapsed = this.state.collapsedGroups[[groupPrefix, idx].join("-")];
     return collapsed === undefined ? true : collapsed;
   }
 
-  useEffect(() => {
+  shouldComponentUpdate (nextProps: LayerListContainerProps, nextState: LayerListContainerState) {
-    // `componentDidUpdate` did not run on mount, so skip the first run here too.
+    // Always update on state change
-    if (!hasMountedRef.current) {
+    if (this.state !== nextState) {
-      hasMountedRef.current = true;
+      return true;
-      return;
     }
-    const selectedItemNode = selectedItemRef.current;
+
+    // This component tree only requires id and visibility from the layers
+    // objects
+    function getRequiredProps(layer: LayerSpecification) {
+      const out: {id: string, layout?: { visibility: any}} = {
+        id: layer.id,
+      };
+
+      if (layer.layout) {
+        out.layout = {
+          visibility: layer.layout.visibility
+        };
+      }
+      return out;
+    }
+    const layersEqual = lodash.isEqual(
+      nextProps.layers.map(getRequiredProps),
+      this.props.layers.map(getRequiredProps),
+    );
+
+    function withoutLayers(props: LayerListContainerProps) {
+      const out = {
+        ...props
+      } as LayerListContainerProps & { layers?: any };
+      delete out["layers"];
+      return out;
+    }
+
+    // Compare the props without layers because we've already compared them
+    // efficiently above.
+    const propsEqual = lodash.isEqual(
+      withoutLayers(this.props),
+      withoutLayers(nextProps)
+    );
+
+    const propsChanged = !(layersEqual && propsEqual);
+    return propsChanged;
+  }
+
+  componentDidUpdate (prevProps: LayerListContainerProps) {
+    if (prevProps.selectedLayerIndex !== this.props.selectedLayerIndex) {
+      const selectedItemNode = this.selectedItemRef.current;
       if (selectedItemNode && selectedItemNode.node) {
         const target = selectedItemNode.node;
         const options = {
-        root: scrollContainerRef.current,
+          root: this.scrollContainerRef.current,
           threshold: 1.0
         };
         const observer = new IntersectionObserver(entries => {
@@ -204,30 +210,32 @@ function LayerListContainerInternal({
 
         observer.observe(target);
       }
-  }, [selectedLayerIndex]);
+    }
+  }
+
+  render() {
 
     const listItems: JSX.Element[] = [];
     let idx = 0;
-  const layersByGroup = groupedLayers();
+    const layersByGroup = this.groupedLayers();
     layersByGroup.forEach(layers => {
       const groupPrefix = layerPrefix(layers[0].id);
       if(layers.length > 1) {
-      const currentIdx = idx;
         const grp = <LayerListGroup
           data-wd-key={[groupPrefix, idx].join("-")}
           aria-controls={layers.map(l => l.key).join(" ")}
           key={`group-${groupPrefix}-${idx}`}
           title={groupPrefix}
-        isActive={!isCollapsed(groupPrefix, idx) || idx === selectedLayerIndex}
+          isActive={!this.isCollapsed(groupPrefix, idx) || idx === this.props.selectedLayerIndex}
-        onActiveToggle={() => toggleLayerGroup(groupPrefix, currentIdx)}
+          onActiveToggle={this.toggleLayerGroup.bind(this, groupPrefix, idx)}
         />;
         listItems.push(grp);
       }
 
       layers.forEach((layer, idxInGroup) => {
-      const groupIdx = findClosestCommonPrefix(propsLayers, idx);
+        const groupIdx = findClosestCommonPrefix(this.props.layers, idx);
 
-      const layerError = errors.find(error => {
+        const layerError = this.props.errors.find(error => {
           return (
             error.parsed &&
             error.parsed.type === "layer" &&
@@ -236,13 +244,13 @@ function LayerListContainerInternal({
         });
 
         const additionalProps: {ref?: React.RefObject<any>} = {};
-      if (idx === selectedLayerIndex) {
+        if (idx === this.props.selectedLayerIndex) {
-        additionalProps.ref = selectedItemRef;
+          additionalProps.ref = this.selectedItemRef;
         }
 
         const listItem = <LayerListItem
           className={classnames({
-          "maputnik-layer-list-item-collapsed": layers.length > 1 && isCollapsed(groupPrefix, groupIdx) && idx !== selectedLayerIndex,
+            "maputnik-layer-list-item-collapsed": layers.length > 1 && this.isCollapsed(groupPrefix, groupIdx) && idx !== this.props.selectedLayerIndex,
             "maputnik-layer-list-item-group-last": idxInGroup == layers.length - 1 && layers.length > 1,
             "maputnik-layer-list-item--error": !!layerError
           })}
@@ -252,11 +260,11 @@ function LayerListContainerInternal({
           layerIndex={idx}
           layerType={layer.type}
           visibility={(layer.layout || {}).visibility}
-        isSelected={idx === selectedLayerIndex}
+          isSelected={idx === this.props.selectedLayerIndex}
-        onLayerSelect={onLayerSelect}
+          onLayerSelect={this.props.onLayerSelect}
-        onLayerDestroy={onLayerDestroy}
+          onLayerDestroy={this.props.onLayerDestroy?.bind(this)}
-        onLayerCopy={onLayerCopy}
+          onLayerCopy={this.props.onLayerCopy.bind(this)}
-        onLayerVisibilityToggle={onLayerVisibilityToggle}
+          onLayerVisibilityToggle={this.props.onLayerVisibilityToggle.bind(this)}
           {...additionalProps}
         />;
         listItems.push(listItem);
@@ -264,20 +272,22 @@ function LayerListContainerInternal({
       });
     });
 
+    const t = this.props.t;
+
     return <section
       className="maputnik-layer-list"
       data-wd-key="layer-list"
       role="complementary"
       aria-label={t("Layers list")}
-    ref={scrollContainerRef}
+      ref={this.scrollContainerRef}
     >
       <ModalAdd
-      key={keys.add}
+        key={this.state.keys.add}
-      layers={propsLayers}
+        layers={this.props.layers}
-      sources={sources}
+        sources={this.props.sources}
-      isOpen={isOpen.add}
+        isOpen={this.state.isOpen.add}
-      onOpenToggle={() => toggleModal("add")}
+        onOpenToggle={this.toggleModal.bind(this, "add")}
-      onLayersChange={onLayersChange}
+        onLayersChange={this.props.onLayersChange}
       />
       <header className="maputnik-layer-list-header" data-wd-key="layer-list.header">
         <span className="maputnik-layer-list-header-title">{t("Layers")}</span>
@@ -287,9 +297,9 @@ function LayerListContainerInternal({
             <button
               id="skip-target-layer-list"
               data-wd-key="skip-target-layer-list"
-            onClick={toggleLayers}
+              onClick={this.toggleLayers}
               className="maputnik-button">
-            {areAllGroupsExpanded === true ?
+              {this.state.areAllGroupsExpanded === true ?
                 t("Collapse")
                 :
                 t("Expand")
@@ -300,7 +310,7 @@ function LayerListContainerInternal({
         <div className="maputnik-default-property">
           <div className="maputnik-multibutton">
             <button
-            onClick={() => toggleModal("add")}
+              onClick={this.toggleModal.bind(this, "add")}
               data-wd-key="layer-list:add-layer"
               className="maputnik-button maputnik-button-selected">
               {t("Add Layer")}
@@ -317,15 +327,16 @@ function LayerListContainerInternal({
         </ul>
       </div>
     </section>;
+  }
 }
 
-const LayerListContainer = withTranslation()(React.memo(LayerListContainerInternal, arePropsEqual));
+const LayerListContainer = withTranslation()(LayerListContainerInternal);
 
 type LayerListProps = LayerListContainerProps & {
   onMoveLayer: OnMoveLayerCallback
 };
 
-export const LayerList: React.FC<LayerListProps> = (props) => {
+const LayerList: React.FC<LayerListProps> = (props) => {
   const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }));
 
   const handleDragEnd = (event: DragEndEvent) => {
@@ -350,3 +361,5 @@ export const LayerList: React.FC<LayerListProps> = (props) => {
     </DndContext>
   );
 };
+
+export default LayerList;

src/components/LayerListGroup.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { Collapser } from "./Collapser";
+import Collapser from "./Collapser";
 
 type LayerListGroupProps = {
   title: string
@@ -9,24 +9,26 @@ type LayerListGroupProps = {
   "aria-controls"?: string
 };
 
-export const LayerListGroup: React.FC<LayerListGroupProps> = (props) => {
+export default class LayerListGroup extends React.Component<LayerListGroupProps> {
+  render() {
     return <li className="maputnik-layer-list-group">
       <div className="maputnik-layer-list-group-header"
-      data-wd-key={"layer-list-group:"+props["data-wd-key"]}
+        data-wd-key={"layer-list-group:"+this.props["data-wd-key"]}
-      onClick={_e => props.onActiveToggle(!props.isActive)}
+        onClick={_e => this.props.onActiveToggle(!this.props.isActive)}
       >
         <button
           className="maputnik-layer-list-group-title"
-        aria-controls={props["aria-controls"]}
+          aria-controls={this.props["aria-controls"]}
-        aria-expanded={props.isActive}
+          aria-expanded={this.props.isActive}
         >
-        {props.title}
+          {this.props.title}
         </button>
         <span className="maputnik-space" />
         <Collapser
           style={{ height: 14, width: 14 }}
-        isCollapsed={props.isActive}
+          isCollapsed={this.props.isActive}
         />
       </div>
     </li>;
-};
+  }
+}

src/components/LayerListItem.tsx

@@ -5,7 +5,7 @@ import { IconContext } from "react-icons";
 import { useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 
-import { IconLayer } from "./IconLayer";
+import IconLayer from "./IconLayer";
 import type { VisibilitySpecification } from "maplibre-gl";
 
 
@@ -38,9 +38,9 @@ type IconActionProps = {
   classBlockModifier?: string
 };
 
-const IconAction: React.FC<IconActionProps> = (props) => {
+class IconAction extends React.Component<IconActionProps> {
-  function renderIcon() {
+  renderIcon() {
-    switch (props.action) {
+    switch (this.props.action) {
       case "duplicate": return <MdContentCopy />;
       case "show": return <MdVisibility />;
       case "hide": return <MdVisibilityOff />;
@@ -48,7 +48,8 @@ const IconAction: React.FC<IconActionProps> = (props) => {
     }
   }
 
-  const { classBlockName, classBlockModifier } = props;
+  render() {
+    const { classBlockName, classBlockModifier } = this.props;
 
     let classAdditions = "";
     if (classBlockName) {
@@ -61,15 +62,16 @@ const IconAction: React.FC<IconActionProps> = (props) => {
 
     return <button
       tabIndex={-1}
-    title={props.action}
+      title={this.props.action}
       className={`maputnik-layer-list-icon-action ${classAdditions}`}
-    data-wd-key={props.wdKey}
+      data-wd-key={this.props.wdKey}
-    onClick={props.onClick}
+      onClick={this.props.onClick}
       aria-hidden="true"
     >
-    {renderIcon()}
+      {this.renderIcon()}
     </button>;
-};
+  }
+}
 
 type LayerListItemProps = {
   id?: string
@@ -85,7 +87,7 @@ type LayerListItemProps = {
   onLayerVisibilityToggle?(...args: unknown[]): unknown
 };
 
-export const LayerListItem = React.forwardRef<HTMLLIElement, LayerListItemProps>((props, ref) => {
+const LayerListItem = React.forwardRef<HTMLLIElement, LayerListItemProps>((props, ref) => {
   const {
     isSelected = false,
     visibility = "visible",
@@ -160,3 +162,5 @@ export const LayerListItem = React.forwardRef<HTMLLIElement, LayerListItemProps>
     </li>
   </IconContext.Provider>;
 });
+
+export default LayerListItem;

src/components/MapMaplibreGl.tsx

@@ -1,12 +1,12 @@
-import React, {useCallback, useEffect, useReducer, useRef} from "react";
+import React from "react";
 import {createRoot} from "react-dom/client";
 import MapLibreGl, {type LayerSpecification, type LngLat, type Map, type MapOptions, type SourceSpecification, type StyleSpecification} from "maplibre-gl";
 import MaplibreInspect from "@maplibre/maplibre-gl-inspect";
 import colors from "@maplibre/maplibre-gl-inspect/lib/colors";
-import { FeatureLayerPopup as MapMaplibreGlLayerPopup } from "./MapMaplibreGlLayerPopup";
+import MapMaplibreGlLayerPopup from "./MapMaplibreGlLayerPopup";
-import { FeaturePropertyPopup as MapMaplibreGlFeaturePropertyPopup, type InspectFeature } from "./MapMaplibreGlFeaturePropertyPopup";
+import MapMaplibreGlFeaturePropertyPopup, { type InspectFeature } from "./MapMaplibreGlFeaturePropertyPopup";
 import Color from "color";
-import { ZoomControl } from "../libs/zoomcontrol";
+import ZoomControl from "../libs/zoomcontrol";
 import { type HighlightedLayer, colorHighlightedLayer } from "../libs/highlight";
 import "maplibre-gl/dist/maplibre-gl.css";
 import "../maplibregl.css";
@@ -71,65 +71,199 @@ type MapMaplibreGlInternalProps = {
   onChange(value: {center: LngLat, zoom: number, _from: "map" | "app"}): unknown
 } & WithTranslation;
 
-/**
+type MapMaplibreGlState = {
- * Replacement for the previous `shouldComponentUpdate`. `React.memo` expects the
+  map: Map | null;
- * inverse: `true` means "props are equal, skip the render", whereas
+  inspect: MaplibreInspect | null;
- * `shouldComponentUpdate` returned `true` when it *should* re-render.
+  geocoder: MaplibreGeocoder | null;
- * As before, if the props cannot be serialized we treat them as equal and skip
+  zoomControl: ZoomControl | null;
- * the render ("no biggie, carry on").
+  zoom?: number;
- */
+};
-function arePropsEqual(prevProps: MapMaplibreGlInternalProps, nextProps: MapMaplibreGlInternalProps) {
+
+class MapMaplibreGlInternal extends React.Component<MapMaplibreGlInternalProps, MapMaplibreGlState> {
+  static defaultProps = {
+    onMapLoaded: () => {},
+    onDataChange: () => {},
+    onLayerSelect: () => {},
+    onChange: () => {},
+    options: {} as MapOptions,
+  };
+  container: HTMLDivElement | null = null;
+
+  constructor(props: MapMaplibreGlInternalProps) {
+    super(props);
+    this.state = {
+      map: null,
+      inspect: null,
+      geocoder: null,
+      zoomControl: null,
+    };
+    i18next.on("languageChanged", () => {
+      this.forceUpdate();
+    });
+  }
+
+
+  shouldComponentUpdate(nextProps: MapMaplibreGlInternalProps, nextState: MapMaplibreGlState) {
     let should = false;
     try {
-    should = JSON.stringify(prevProps) !== JSON.stringify(nextProps);
+      should = JSON.stringify(this.props) !== JSON.stringify(nextProps) || JSON.stringify(this.state) !== JSON.stringify(nextState);
     } catch(_e) {
       // no biggie, carry on
     }
-  return !should;
+    return should;
-}
+  }
 
-const MapMaplibreGlInternal = ({
+  componentDidUpdate() {
-  onDataChange = () => {},
+    const map = this.state.map;
-  onLayerSelect = () => {},
-  onChange = () => {},
-  options = {},
-  mapStyle,
-  mapView,
-  inspectModeEnabled,
-  highlightedLayer,
-  replaceAccessTokens,
-  t,
-}: MapMaplibreGlInternalProps) => {
-  const container = useRef<HTMLDivElement | null>(null);
 
-  // These used to live in `this.state`, but were never able to trigger a
+    const styleWithTokens = this.props.replaceAccessTokens(this.props.mapStyle);
-  // re-render: `shouldComponentUpdate` stringified the state, which throws for
+    if (map) {
-  // the (circular) maplibre `Map`, so the comparison was swallowed and the
+      // Maplibre GL now does diffing natively so we don't need to calculate
-  // component only ever re-rendered on prop changes. They are imperative
+      // the necessary operations ourselves!
-  // handles, so they are refs here and mutating them does not re-render.
+      // We also need to update the style for inspect to work properly
-  const map = useRef<Map | null>(null);
+      map.setStyle(styleWithTokens, {diff: true});
-  const inspect = useRef<MaplibreInspect | null>(null);
+      map.showTileBoundaries = this.props.options?.showTileBoundaries!;
-  const geocoder = useRef<MaplibreGeocoder | null>(null);
+      map.showCollisionBoxes = this.props.options?.showCollisionBoxes!;
-  const zoomControl = useRef<ZoomControl | null>(null);
+      map.showOverdrawInspector = this.props.options?.showOverdrawInspector!;
-  const zoom = useRef<number | undefined>(undefined);
 
-  // `componentDidUpdate` did not run on mount, so neither may the effect below.
+      // set the map view when the prop was updated from outside
-  const hasMounted = useRef(false);
+      if (this.props.mapView._from === "app") {
+        map.jumpTo(this.props.mapView);
+      }
+    }
 
-  const [, forceUpdate] = useReducer((tick: number) => tick + 1, 0);
+    if(this.state.inspect && this.props.inspectModeEnabled !== this.state.inspect._showInspectMap) {
+      this.state.inspect.toggleInspector();
+    }
+    if (this.state.inspect && this.props.inspectModeEnabled) {
+      this.state.inspect.setOriginalStyle(styleWithTokens);
+      // In case the sources are the same, there's a need to refresh the style
+      setTimeout(() => {
+        this.state.inspect!.render();
+      }, 500);
+    }
 
-  // The maplibre event handlers/callbacks below are registered once (on mount)
+  }
-  // but read `this.props` at call time in the class version, so they must not
-  // close over the props of the first render.
-  const latestProps = useRef({onDataChange, onLayerSelect, onChange, mapStyle, inspectModeEnabled, highlightedLayer, t});
-  latestProps.current = {onDataChange, onLayerSelect, onChange, mapStyle, inspectModeEnabled, highlightedLayer, t};
 
-  const onLayerSelectById = useCallback((id: string) => {
+  componentDidMount() {
-    const index = latestProps.current.mapStyle.layers.findIndex(layer => layer.id === id);
+    const mapOpts = {
-    latestProps.current.onLayerSelect(index);
+      ...this.props.options,
-  }, []);
+      container: this.container!,
+      style: this.props.mapStyle,
+      hash: true,
+      maxZoom: 24,
+      // make root relative urls in stylefiles work as maplibre gl js does
+      // not support this for everything:
+      // https://github.com/maplibre/maplibre-gl-js/issues/6818
+      transformRequest: (url) => {
+        if (url.startsWith("/")) {
+          url = `${window.location.origin}${url}`;
+        }
+        return { url };
+      },
+      // setting to always load glyphs of CJK fonts from server
+      // https://maplibre.org/maplibre-gl-js/docs/examples/local-ideographs/
+      localIdeographFontFamily: false
+    } satisfies MapOptions;
 
-  const initGeocoder = useCallback((mapInstance: Map) => {
+    const protocol = new Protocol({metadata: true});
+    MapLibreGl.addProtocol("pmtiles",protocol.tile);
+    const map = new MapLibreGl.Map(mapOpts);
+
+    const mapViewChange = () => {
+      const center = map.getCenter();
+      const zoom = map.getZoom();
+      this.props.onChange({center, zoom, _from: "map"});
+    };
+    mapViewChange();
+
+    map.showTileBoundaries = mapOpts.showTileBoundaries!;
+    map.showCollisionBoxes = mapOpts.showCollisionBoxes!;
+    map.showOverdrawInspector = mapOpts.showOverdrawInspector!;
+
+    const geocoder = this.initGeocoder(map);
+
+    const zoomControl = new ZoomControl();
+    map.addControl(zoomControl, "top-right");
+
+    const nav = new MapLibreGl.NavigationControl({visualizePitch:true});
+    map.addControl(nav, "top-right");
+
+    const tmpNode = document.createElement("div");
+    const root = createRoot(tmpNode);
+
+    const inspectPopup = new MapLibreGl.Popup({
+      closeOnClick: false
+    });
+
+    const inspect = new MaplibreInspect({
+      popup: inspectPopup,
+      showMapPopup: true,
+      showMapPopupOnHover: false,
+      showInspectMapPopupOnHover: true,
+      showInspectButton: false,
+      blockHoverPopupOnClick: true,
+      assignLayerColor: (layerId: string, alpha: number) => {
+        return Color(colors.brightColor(layerId, alpha)).desaturate(0.5).string();
+      },
+      buildInspectStyle: (originalMapStyle: StyleSpecification, coloredLayers: HighlightedLayer[]) => buildInspectStyle(originalMapStyle, coloredLayers, this.props.highlightedLayer),
+      renderPopup: (features: InspectFeature[]) => {
+        if(this.props.inspectModeEnabled) {
+          inspectPopup.once("open", () => {
+            root.render(<MapMaplibreGlFeaturePropertyPopup features={features} />);
+          });
+          return tmpNode;
+        } else {
+          inspectPopup.once("open", () => {
+            root.render(<MapMaplibreGlLayerPopup
+              features={features}
+              onLayerSelect={this.onLayerSelectById}
+              zoom={this.state.zoom}
+            />,);
+          });
+          return tmpNode;
+        }
+      }
+    });
+    map.addControl(inspect);
+
+    map.on("style.load", () => {
+      this.setState({
+        map,
+        inspect,
+        geocoder,
+        zoomControl,
+        zoom: map.getZoom()
+      });
+    });
+
+    map.on("data", e => {
+      if(e.dataType !== "tile") return;
+      this.props.onDataChange!({
+        map: this.state.map
+      });
+    });
+
+    map.on("error", e => {
+      console.log("ERROR", e);
+    });
+
+    map.on("zoom", _e => {
+      this.setState({
+        zoom: map.getZoom()
+      });
+    });
+
+    map.on("dragend", mapViewChange);
+    map.on("zoomend", mapViewChange);
+  }
+
+  onLayerSelectById = (id: string) => {
+    const index = this.props.mapStyle.layers.findIndex(layer => layer.id === id);
+    this.props.onLayerSelect(index);
+  };
+
+  initGeocoder(map: Map) {
     const geocoderConfig = {
       forwardGeocode: async (config: MaplibreGeocoderApiConfig) => {
         const features = [];
@@ -166,190 +300,27 @@ const MapMaplibreGlInternal = ({
         };
       },
     } as unknown as MaplibreGeocoderApi;
-    const geocoderInstance = new MaplibreGeocoder(geocoderConfig, {
+    const geocoder = new MaplibreGeocoder(geocoderConfig, {
-      placeholder: latestProps.current.t("Search"),
+      placeholder: this.props.t("Search"),
       maplibregl: MapLibreGl,
     });
-    mapInstance.addControl(geocoderInstance, "top-left");
+    map.addControl(geocoder, "top-left");
-    return geocoderInstance;
+    return geocoder;
-  }, []);
-
-  // Was the `i18next.on("languageChanged", () => this.forceUpdate())` in the
-  // constructor. `forceUpdate` bypassed `shouldComponentUpdate`; a state update
-  // likewise bypasses `React.memo`.
-  useEffect(() => {
-    const onLanguageChanged = () => {
-      forceUpdate();
-    };
-    i18next.on("languageChanged", onLanguageChanged);
-    return () => {
-      i18next.off("languageChanged", onLanguageChanged);
-    };
-  }, []);
-
-  // componentDidMount
-  useEffect(() => {
-    const mapOpts = {
-      ...options,
-      container: container.current!,
-      style: mapStyle,
-      hash: true,
-      maxZoom: 24,
-      // make root relative urls in stylefiles work as maplibre gl js does
-      // not support this for everything:
-      // https://github.com/maplibre/maplibre-gl-js/issues/6818
-      transformRequest: (url) => {
-        if (url.startsWith("/")) {
-          url = `${window.location.origin}${url}`;
-        }
-        return { url };
-      },
-      // setting to always load glyphs of CJK fonts from server
-      // https://maplibre.org/maplibre-gl-js/docs/examples/local-ideographs/
-      localIdeographFontFamily: false
-    } satisfies MapOptions;
-
-    const protocol = new Protocol({metadata: true});
-    MapLibreGl.addProtocol("pmtiles",protocol.tile);
-    const mapInstance = new MapLibreGl.Map(mapOpts);
-
-    const mapViewChange = () => {
-      const center = mapInstance.getCenter();
-      const currentZoom = mapInstance.getZoom();
-      latestProps.current.onChange({center, zoom: currentZoom, _from: "map"});
-    };
-    mapViewChange();
-
-    mapInstance.showTileBoundaries = mapOpts.showTileBoundaries!;
-    mapInstance.showCollisionBoxes = mapOpts.showCollisionBoxes!;
-    mapInstance.showOverdrawInspector = mapOpts.showOverdrawInspector!;
-
-    const geocoderInstance = initGeocoder(mapInstance);
-
-    const zoomControlInstance = new ZoomControl();
-    mapInstance.addControl(zoomControlInstance, "top-right");
-
-    const nav = new MapLibreGl.NavigationControl({visualizePitch:true});
-    mapInstance.addControl(nav, "top-right");
-
-    const tmpNode = document.createElement("div");
-    const root = createRoot(tmpNode);
-
-    const inspectPopup = new MapLibreGl.Popup({
-      closeOnClick: false
-    });
-
-    const inspectInstance = new MaplibreInspect({
-      popup: inspectPopup,
-      showMapPopup: true,
-      showMapPopupOnHover: false,
-      showInspectMapPopupOnHover: true,
-      showInspectButton: false,
-      blockHoverPopupOnClick: true,
-      assignLayerColor: (layerId: string, alpha: number) => {
-        return Color(colors.brightColor(layerId, alpha)).desaturate(0.5).string();
-      },
-      buildInspectStyle: (originalMapStyle: StyleSpecification, coloredLayers: HighlightedLayer[]) => buildInspectStyle(originalMapStyle, coloredLayers, latestProps.current.highlightedLayer),
-      renderPopup: (features: InspectFeature[]) => {
-        if(latestProps.current.inspectModeEnabled) {
-          inspectPopup.once("open", () => {
-            root.render(<MapMaplibreGlFeaturePropertyPopup features={features} />);
-          });
-          return tmpNode;
-        } else {
-          inspectPopup.once("open", () => {
-            root.render(<MapMaplibreGlLayerPopup
-              features={features}
-              onLayerSelect={onLayerSelectById}
-              zoom={zoom.current}
-            />,);
-          });
-          return tmpNode;
-        }
-      }
-    });
-    mapInstance.addControl(inspectInstance);
-
-    mapInstance.on("style.load", () => {
-      map.current = mapInstance;
-      inspect.current = inspectInstance;
-      geocoder.current = geocoderInstance;
-      zoomControl.current = zoomControlInstance;
-      zoom.current = mapInstance.getZoom();
-    });
-
-    mapInstance.on("data", e => {
-      if(e.dataType !== "tile") return;
-      latestProps.current.onDataChange!({
-        map: map.current
-      });
-    });
-
-    mapInstance.on("error", e => {
-      console.log("ERROR", e);
-    });
-
-    mapInstance.on("zoom", _e => {
-      zoom.current = mapInstance.getZoom();
-    });
-
-    mapInstance.on("dragend", mapViewChange);
-    mapInstance.on("zoomend", mapViewChange);
-    // Mount only, exactly like componentDidMount: the map is created from the
-    // props of the first render and kept up to date imperatively below (the
-    // handlers read `latestProps`, so no prop belongs in the dependencies). The
-    // class had no componentWillUnmount, so there is no teardown here either.
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- mount-only: adding mapStyle/options would re-create the map
-  }, [initGeocoder, onLayerSelectById]);
-
-  // componentDidUpdate. It had no `prevProps` guards, so it ran after *every*
-  // re-render; the equivalent is an effect without a dependency array. Since the
-  // component only re-renders when `arePropsEqual` reports a prop change (or on
-  // a language change, as before), this runs exactly as often as it used to.
-  useEffect(() => {
-    if (!hasMounted.current) {
-      // componentDidUpdate does not run on mount.
-      hasMounted.current = true;
-      return;
   }
 
-    const styleWithTokens = replaceAccessTokens(mapStyle);
+  render() {
-    if (map.current) {
+    const t = this.props.t;
-      // Maplibre GL now does diffing natively so we don't need to calculate
+    this.state.geocoder?.setPlaceholder(t("Search"));
-      // the necessary operations ourselves!
+    this.state.zoomControl?.setLabel(t("Zoom:"));
-      // We also need to update the style for inspect to work properly
-      map.current.setStyle(styleWithTokens, {diff: true});
-      map.current.showTileBoundaries = options?.showTileBoundaries!;
-      map.current.showCollisionBoxes = options?.showCollisionBoxes!;
-      map.current.showOverdrawInspector = options?.showOverdrawInspector!;
-
-      // set the map view when the prop was updated from outside
-      if (mapView._from === "app") {
-        map.current.jumpTo(mapView);
-      }
-    }
-
-    if(inspect.current && inspectModeEnabled !== inspect.current._showInspectMap) {
-      inspect.current.toggleInspector();
-    }
-    if (inspect.current && inspectModeEnabled) {
-      inspect.current.setOriginalStyle(styleWithTokens);
-      // In case the sources are the same, there's a need to refresh the style
-      setTimeout(() => {
-        inspect.current!.render();
-      }, 500);
-    }
-  });
-
-  geocoder.current?.setPlaceholder(t("Search"));
-  zoomControl.current?.setLabel(t("Zoom:"));
     return <div
       className="maputnik-map__map"
       role="region"
       aria-label={t("Map view")}
-    ref={container}
+      ref={x => {this.container = x;}}
       data-wd-key="maplibre:map"
     ></div>;
-};
+  }
+}
 
-export const MapMaplibreGl = withTranslation()(React.memo(MapMaplibreGlInternal, arePropsEqual));
+const MapMaplibreGl = withTranslation()(MapMaplibreGlInternal);
+export default MapMaplibreGl;

src/components/MapMaplibreGlFeaturePropertyPopup.tsx

@@ -63,8 +63,9 @@ type FeaturePropertyPopupProps = {
   features: InspectFeature[]
 };
 
-export const FeaturePropertyPopup: React.FC<FeaturePropertyPopupProps> = (props) => {
+class FeaturePropertyPopup extends React.Component<FeaturePropertyPopupProps> {
-  const features = removeDuplicatedFeatures(props.features);
+  render() {
+    const features = removeDuplicatedFeatures(this.props.features);
     return <div className="maputnik-feature-property-popup" dir="ltr" data-wd-key="feature-property-popup">
       <table className="maputnik-popup-table">
         <tbody>
@@ -72,4 +73,8 @@ export const FeaturePropertyPopup: React.FC<FeaturePropertyPopupProps> = (props)
         </tbody>
       </table>
     </div>;
-};
+  }
+}
+
+
+export default FeaturePropertyPopup;

src/components/MapMaplibreGlLayerPopup.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { IconLayer } from "./IconLayer";
+import IconLayer from "./IconLayer";
 import type {InspectFeature} from "./MapMaplibreGlFeaturePropertyPopup";
 
 function groupFeaturesBySourceLayer(features: InspectFeature[]) {
@@ -32,8 +32,8 @@ type FeatureLayerPopupProps = {
   zoom?: number
 };
 
-export const FeatureLayerPopup: React.FC<FeatureLayerPopupProps> = (props) => {
+class FeatureLayerPopup extends React.Component<FeatureLayerPopupProps> {
-  function _getFeatureColor(feature: InspectFeature, _zoom?: number) {
+  _getFeatureColor(feature: InspectFeature, _zoom?: number) {
     // Guard because openlayers won't have this
     if (!feature.layer.paint) {
       return;
@@ -65,11 +65,12 @@ export const FeatureLayerPopup: React.FC<FeatureLayerPopupProps> = (props) => {
     }
   }
 
-  const sources = groupFeaturesBySourceLayer(props.features);
+  render() {
+    const sources = groupFeaturesBySourceLayer(this.props.features);
 
     const items = Object.keys(sources).map(vectorLayerId => {
       const layers = sources[vectorLayerId].map((feature: InspectFeature, idx: number) => {
-      const featureColor = _getFeatureColor(feature, props.zoom);
+        const featureColor = this._getFeatureColor(feature, this.props.zoom);
 
         return <div
           key={idx}
@@ -82,7 +83,7 @@ export const FeatureLayerPopup: React.FC<FeatureLayerPopupProps> = (props) => {
           <label
             className="maputnik-popup-layer__label"
             onClick={() => {
-            props.onLayerSelect(feature.layer.id);
+              this.props.onLayerSelect(feature.layer.id);
             }}
           >
             {feature.layer.type &&
@@ -106,4 +107,8 @@ export const FeatureLayerPopup: React.FC<FeatureLayerPopupProps> = (props) => {
     return <div className="maputnik-feature-layer-popup" data-wd-key="feature-layer-popup" dir="ltr">
       {items}
     </div>;
-};
+  }
+}
+
+
+export default FeatureLayerPopup;

src/components/MapOpenLayers.tsx

@@ -1,8 +1,8 @@
-import {useCallback, useEffect, useMemo, useRef, useState} from "react";
+import React from "react";
 import {throttle} from "lodash";
 import { type WithTranslation, withTranslation } from "react-i18next";
 
-import { FeatureLayerPopup as MapMaplibreGlLayerPopup } from "./MapMaplibreGlLayerPopup";
+import MapMaplibreGlLayerPopup from "./MapMaplibreGlLayerPopup";
 
 import "ol/ol.css";
 //@ts-ignore
@@ -35,52 +35,56 @@ type MapOpenLayersInternalProps = {
   onChange(...args: unknown[]): unknown
 } & WithTranslation;
 
-const MapOpenLayersInternal = ({
+type MapOpenLayersState = {
-  onLayerSelect = () => {},
+  zoom: string
-  mapStyle,
+  rotation: string
-  style,
+  cursor: string[]
-  debugToolbox,
+  center: string[]
-  replaceAccessTokens,
+  selectedFeatures?: any[]
-  onChange,
+};
-  t,
-}: MapOpenLayersInternalProps) => {
-  const [zoom, setZoom] = useState("0");
-  const [rotation, setRotation] = useState("0");
-  const [cursor, setCursor] = useState<string[]>([]);
-  const [center, setCenter] = useState<string[]>([]);
-  // Never assigned in the class version either, kept for the popup below.
-  const [selectedFeatures] = useState<any[] | undefined>(undefined);
 
-  // Imperative handles: they were plain instance fields, so they are refs and
+class MapOpenLayersInternal extends React.Component<MapOpenLayersInternalProps, MapOpenLayersState> {
-  // mutating them must not re-render.
+  static defaultProps = {
-  const map = useRef<Map | null>(null);
+    onMapLoaded: () => {},
-  const container = useRef<HTMLDivElement | null>(null);
+    onDataChange: () => {},
-  const overlay = useRef<Overlay | undefined>(undefined);
+    onLayerSelect: () => {},
-  const popupContainer = useRef<HTMLDivElement | null>(null);
+  };
+  updateStyle: any;
+  map: any;
+  container: HTMLDivElement | null = null;
+  overlay: Overlay | undefined;
+  popupContainer: HTMLElement | null = null;
 
-  // componentDidUpdate did not run on mount, and componentDidMount already
+  constructor(props: MapOpenLayersInternalProps) {
-  // applies the initial style, so the style effect below must skip the mount.
+    super(props);
-  const hasMounted = useRef(false);
+    this.state = {
+      zoom: "0",
+      rotation: "0",
+      cursor: [] as string[],
+      center: [],
+    };
+    this.updateStyle = throttle(this._updateStyle.bind(this), 200);
+  }
 
-  // The openlayers event handlers are registered on mount but read `this.props`
+  _updateStyle(newMapStyle: StyleSpecification) {
-  // at call time in the class version.
+    if(!this.map) return;
-  const latestProps = useRef({mapStyle, replaceAccessTokens, onChange});
-  latestProps.current = {mapStyle, replaceAccessTokens, onChange};
-
-  // Was `this.updateStyle = throttle(this._updateStyle.bind(this), 200)` in the
-  // constructor: created once per instance, so it is memoized once here.
-  const updateStyle = useMemo(() => throttle((newMapStyle: StyleSpecification) => {
-    if(!map.current) return;
 
     // See <https://github.com/openlayers/ol-mapbox-style/issues/215#issuecomment-493198815>
-    map.current.getLayers().clear();
+    this.map.getLayers().clear();
-    apply(map.current, newMapStyle);
+    apply(this.map, newMapStyle);
-  }, 200), []);
+  }
 
-  // componentDidMount
+  componentDidUpdate(prevProps: MapOpenLayersInternalProps) {
-  useEffect(() => {
+    if (this.props.mapStyle !== prevProps.mapStyle) {
-    overlay.current = new Overlay({
+      this.updateStyle(
-      element: popupContainer.current!,
+        this.props.replaceAccessTokens(this.props.mapStyle)
+      );
+    }
+  }
+
+  componentDidMount() {
+    this.overlay = new Overlay({
+      element: this.popupContainer!,
       autoPan: {
         animation: {
           duration: 250
@@ -88,131 +92,117 @@ const MapOpenLayersInternal = ({
       },
     });
 
-    const mapInstance = new Map({
+    const map = new Map({
-      target: container.current!,
+      target: this.container!,
-      overlays: [overlay.current],
+      overlays: [this.overlay],
       view: new View({
         zoom: 1,
         center: [180, -90],
       })
     });
 
-    mapInstance.on("pointermove", (evt) => {
+    map.on("pointermove", (evt) => {
       const coords = toLonLat(evt.coordinate);
-      setCursor([
+      this.setState({
+        cursor: [
           coords[0].toFixed(2),
           coords[1].toFixed(2)
-      ]);
+        ]
+      });
     });
 
     const onMoveEnd = () => {
-      const currentZoom = mapInstance.getView().getZoom();
+      const zoom = map.getView().getZoom();
-      const currentCenter = toLonLat(mapInstance.getView().getCenter()!);
+      const center = toLonLat(map.getView().getCenter()!);
 
-      latestProps.current.onChange({
+      this.props.onChange({
-        zoom: currentZoom,
+        zoom,
         center: {
-          lng: currentCenter[0],
+          lng: center[0],
-          lat: currentCenter[1],
+          lat: center[1],
         },
       });
     };
 
     onMoveEnd();
-    mapInstance.on("moveend", onMoveEnd);
+    map.on("moveend", onMoveEnd);
 
-    mapInstance.on("postrender", (_e) => {
+    map.on("postrender", (_e) => {
-      const currentCenter = toLonLat(mapInstance.getView().getCenter()!);
+      const center = toLonLat(map.getView().getCenter()!);
-      setCenter([
+      this.setState({
-        currentCenter[0].toFixed(2),
+        center: [
-        currentCenter[1].toFixed(2),
+          center[0].toFixed(2),
-      ]);
+          center[1].toFixed(2),
-      setRotation(mapInstance.getView().getRotation().toFixed(2));
+        ],
-      setZoom(mapInstance.getView().getZoom()!.toFixed(2));
+        rotation: map.getView().getRotation().toFixed(2),
+        zoom: map.getView().getZoom()!.toFixed(2)
+      });
     });
 
 
 
-    map.current = mapInstance;
+    this.map = map;
-    updateStyle(
+    this.updateStyle(
-      latestProps.current.replaceAccessTokens(latestProps.current.mapStyle) as StyleSpecification
+      this.props.replaceAccessTokens(this.props.mapStyle)
     );
-    // Mount only, like componentDidMount. The class had no componentWillUnmount,
-    // so there is no teardown here either. The props read above are read from
-    // latestProps/the first render on purpose, so they are not dependencies.
-  }, [updateStyle]);
-
-  // componentDidUpdate: `if (this.props.mapStyle !== prevProps.mapStyle)`.
-  useEffect(() => {
-    if (!hasMounted.current) {
-      // componentDidUpdate does not run on mount; componentDidMount already
-      // applied the initial style, and applying it twice would push a second
-      // (throttled) clear + apply through ol-mapbox-style.
-      hasMounted.current = true;
-      return;
   }
-    updateStyle(
-      replaceAccessTokens(mapStyle) as StyleSpecification
-    );
-    // `replaceAccessTokens` is deliberately *not* a dependency: the parent
-    // re-creates it on every render, so depending on it would re-apply the style
-    // on every render instead of only when `mapStyle` changes, which is exactly
-    // what the `this.props.mapStyle !== prevProps.mapStyle` guard checked.
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- see above: replaceAccessTokens is a new identity each render
-  }, [mapStyle, updateStyle]);
 
-  const closeOverlay = useCallback((e: any) => {
+  closeOverlay = (e: any) => {
     e.target.blur();
-    overlay.current!.setPosition(undefined);
+    this.overlay!.setPosition(undefined);
-  }, []);
+  };
 
+  render() {
+    const t = this.props.t;
     return <div className="maputnik-ol-container">
       <div
-      ref={popupContainer}
+        ref={x => {this.popupContainer = x;}}
         style={{background: "black"}}
         className="maputnik-popup"
       >
         <button
           className="maplibregl-popup-close-button"
-        onClick={closeOverlay}
+          onClick={this.closeOverlay}
           aria-label={t("Close popup")}
         >
           ×
         </button>
         <MapMaplibreGlLayerPopup
-        features={selectedFeatures || []}
+          features={this.state.selectedFeatures || []}
-        onLayerSelect={onLayerSelect}
+          onLayerSelect={this.props.onLayerSelect}
         />
       </div>
       <div className="maputnik-ol-zoom">
-      {t("Zoom:")} {zoom}
+        {t("Zoom:")} {this.state.zoom}
       </div>
-    {debugToolbox &&
+      {this.props.debugToolbox &&
         <div className="maputnik-ol-debug">
           <div>
             <label>{t("cursor:")} </label>
-          <span>{renderCoords(cursor)}</span>
+            <span>{renderCoords(this.state.cursor)}</span>
           </div>
           <div>
             <label>{t("center:")} </label>
-          <span>{renderCoords(center)}</span>
+            <span>{renderCoords(this.state.center)}</span>
           </div>
           <div>
             <label>{t("rotation:")} </label>
-          <span>{rotation}</span>
+            <span>{this.state.rotation}</span>
           </div>
         </div>
       }
       <div
         className="maputnik-ol"
-      ref={container}
+        ref={x => {this.container = x;}}
         role="region"
         aria-label={t("Map view")}
         style={{
-        ...style,
+          ...this.props.style,
         }}>
       </div>
     </div>;
-};
+  }
+}
 
-export const MapOpenLayers = withTranslation()(MapOpenLayersInternal);
+const MapOpenLayers = withTranslation()(MapOpenLayersInternal);
+export default MapOpenLayers;

src/components/PropertyGroup.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 
-import { FieldFunction } from "./FieldFunction";
+import FieldFunction from "./FieldFunction";
 import type {LayerSpecification} from "maplibre-gl";
 import { type MappedLayerErrors } from "../libs/definitions";
 
@@ -40,18 +40,19 @@ type PropertyGroupProps = {
   errors?: MappedLayerErrors
 };
 
-export const PropertyGroup: React.FC<PropertyGroupProps> = (props) => {
+export default class PropertyGroup extends React.Component<PropertyGroupProps> {
-  const onPropertyChange = (property: string, newValue: any) => {
+  onPropertyChange = (property: string, newValue: any) => {
-    const group = getGroupName(props.spec, props.layer.type, property);
+    const group = getGroupName(this.props.spec, this.props.layer.type, property);
-    props.onChange(group ,property, newValue);
+    this.props.onChange(group ,property, newValue);
   };
 
-  const {errors} = props;
+  render() {
-  const fields = props.groupFields.map(fieldName => {
+    const {errors} = this.props;
-    const fieldSpec = getFieldSpec(props.spec, props.layer.type, fieldName);
+    const fields = this.props.groupFields.map(fieldName => {
+      const fieldSpec = getFieldSpec(this.props.spec, this.props.layer.type, fieldName);
 
-    const paint = props.layer.paint || {};
+      const paint = this.props.layer.paint || {};
-    const layout = props.layer.layout || {};
+      const layout = this.props.layer.layout || {};
       const fieldValue = fieldName in paint
         ? paint[fieldName as keyof typeof paint]
         : layout[fieldName as keyof typeof layout];
@@ -59,7 +60,7 @@ export const PropertyGroup: React.FC<PropertyGroupProps> = (props) => {
 
       return <FieldFunction
         errors={errors}
-      onChange={onPropertyChange}
+        onChange={this.onPropertyChange}
         key={fieldName}
         fieldName={fieldName}
         value={fieldValue}
@@ -71,4 +72,5 @@ export const PropertyGroup: React.FC<PropertyGroupProps> = (props) => {
     return <div className="maputnik-property-group">
       {fields}
     </div>;
-};
+  }
+}

src/components/ScrollContainer.tsx

@@ -4,8 +4,10 @@ type ScrollContainerProps = {
   children?: React.ReactNode
 };
 
-export const ScrollContainer: React.FC<ScrollContainerProps> = (props) => {
+export default class ScrollContainer extends React.Component<ScrollContainerProps> {
+  render() {
     return <div className="maputnik-scroll-container">
-    {props.children}
+      {this.props.children}
     </div>;
-};
+  }
+}

src/components/SingleFilterEditor.tsx

@@ -1,9 +1,9 @@
 import React from "react";
 
 import {otherFilterOps} from "../libs/filterops";
-import { InputString } from "./InputString";
+import InputString from "./InputString";
-import { InputAutocomplete } from "./InputAutocomplete";
+import InputAutocomplete from "./InputAutocomplete";
-import { InputSelect } from "./InputSelect";
+import InputSelect from "./InputSelect";
 
 function tryParseInt(v: string | number) {
   if (v === "") return v;
@@ -40,21 +40,23 @@ type SingleFilterEditorProps = {
   properties?: {[key: string]: string}
 };
 
-export const SingleFilterEditor: React.FC<SingleFilterEditorProps> = ({
+export default class SingleFilterEditor extends React.Component<SingleFilterEditorProps> {
-  properties = {},
+  static defaultProps = {
-  ...props
+    properties: {},
-}) => {
+  };
-  function onFilterPartChanged(filterOp: string, propertyName: string, filterArgs: string[]) {
+
+  onFilterPartChanged(filterOp: string, propertyName: string, filterArgs: string[]) {
     let newFilter = [filterOp, propertyName, ...filterArgs.map(parseFilter)];
     if(filterOp === "has" || filterOp === "!has") {
       newFilter = [filterOp, propertyName];
     } else if(filterArgs.length === 0) {
       newFilter = [filterOp, propertyName, ""];
     }
-    props.onChange(newFilter);
+    this.props.onChange(newFilter);
   }
 
-  const f = props.filter;
+  render() {
+    const f = this.props.filter;
     const filterOp = f[0];
     const propertyName = f[1];
     const filterArgs = f.slice(2);
@@ -64,15 +66,15 @@ export const SingleFilterEditor: React.FC<SingleFilterEditorProps> = ({
         <InputAutocomplete
           aria-label="key"
           value={propertyName}
-        options={Object.keys(properties).map(propName => [propName, propName])}
+          options={Object.keys(this.props.properties!).map(propName => [propName, propName])}
-        onChange={(newPropertyName: string) => onFilterPartChanged(filterOp, newPropertyName, filterArgs)}
+          onChange={(newPropertyName: string) => this.onFilterPartChanged(filterOp, newPropertyName, filterArgs)}
         />
       </div>
       <div className="maputnik-filter-editor-operator">
         <InputSelect
           aria-label="function"
           value={filterOp}
-        onChange={(newFilterOp: string) => onFilterPartChanged(newFilterOp, propertyName, filterArgs)}
+          onChange={(newFilterOp: string) => this.onFilterPartChanged(newFilterOp, propertyName, filterArgs)}
           options={otherFilterOps}
         />
       </div>
@@ -81,9 +83,10 @@ export const SingleFilterEditor: React.FC<SingleFilterEditorProps> = ({
         <InputString
           aria-label="value"
           value={filterArgs.join(",")}
-        onChange={(v: string) => onFilterPartChanged(filterOp, propertyName, v.split(","))}
+          onChange={(v: string) => this.onFilterPartChanged(filterOp, propertyName, v.split(","))}
         />
       </div>
       }
     </div>;
-};
+  }
+}

src/components/SmallError.tsx

@@ -7,13 +7,16 @@ type SmallErrorInternalProps = {
   children?: React.ReactNode
 } & WithTranslation;
 
-const SmallErrorInternal: React.FC<SmallErrorInternalProps> = (props) => {
+class SmallErrorInternal extends React.Component<SmallErrorInternalProps> {
-  const t = props.t;
+  render () {
+    const t = this.props.t;
     return (
       <div className="SmallError">
-      {t("Error:")} {props.children}
+        {t("Error:")} {this.props.children}
       </div>
     );
-};
+  }
+}
 
-export const SmallError = withTranslation()(SmallErrorInternal);
+const SmallError = withTranslation()(SmallErrorInternal);
+export default SmallError;

src/components/SpecProperty.tsx

@@ -1,44 +0,0 @@
-import React from "react";
-
-import { FieldSpec, type FieldSpecProps } from "./FieldSpec";
-import { FunctionInputButtons as FunctionButtons } from "./FunctionButtons";
-
-import { labelFromFieldName } from "../libs/label-from-field-name";
-
-
-type SpecPropertyProps = FieldSpecProps & {
-  fieldName?: string
-  fieldType?: string
-  fieldSpec?: any
-  value?: any
-  errors?: {[key: string]: {message: string}}
-  onZoomClick(): void
-  onDataClick(): void
-  onExpressionClick?(): void
-  onElevationClick?(): void
-};
-
-
-export const SpecProperty: React.FC<SpecPropertyProps> = (props) => {
-  const {errors = {}, fieldName, fieldType} = props;
-
-  const functionBtn = <FunctionButtons
-    fieldSpec={props.fieldSpec}
-    onZoomClick={props.onZoomClick}
-    onDataClick={props.onDataClick}
-    onExpressionClick={props.onExpressionClick}
-    onElevationClick={props.onElevationClick}
-  />;
-
-  const error = errors[fieldType+"."+fieldName as any] as any;
-
-  const propsWithDefaults = {...props, errors};
-
-  return <FieldSpec
-    {...propsWithDefaults}
-    error={error}
-    fieldSpec={props.fieldSpec}
-    label={labelFromFieldName(props.fieldName || "")}
-    action={functionBtn}
-  />;
-};

src/components/ZoomProperty.tsx

@@ -1,246 +0,0 @@
-import React, { useRef } from "react";
-import { PiListPlusBold } from "react-icons/pi";
-import { TbMathFunction } from "react-icons/tb";
-import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
-import { type WithTranslation, withTranslation } from "react-i18next";
-
-import { InputButton } from "./InputButton";
-import { InputSpec } from "./InputSpec";
-import { InputNumber } from "./InputNumber";
-import { InputSelect } from "./InputSelect";
-import { Block } from "./Block";
-
-import { DeleteStopButton } from "./DeleteStopButton";
-import { labelFromFieldName } from "../libs/label-from-field-name";
-
-import { generateUniqueId as docUid } from "../libs/document-uid";
-import { sortNumerically } from "../libs/sort-numerically";
-import { type MappedLayerErrors } from "../libs/definitions";
-
-
-/**
- * We cache a reference for each stop by its index.
- *
- * When the stops are reordered the references are also updated (see this.orderStops) this allows React to use the same key for the element and keep keyboard focus.
- */
-function setStopRefs(props: ZoomPropertyInternalProps, state: ZoomPropertyState) {
-  // This is initialised below only if required to improved performance.
-  let newRefs: {[key: number]: string} = {};
-
-  if(props.value && (props.value as ZoomWithStops).stops) {
-    (props.value as ZoomWithStops).stops.forEach((_val, idx: number) => {
-      if(Object.prototype.hasOwnProperty.call(!state.refs, idx)) {
-        if(!newRefs) {
-          newRefs = {...state};
-        }
-        newRefs[idx] = docUid("stop-");
-      } else {
-        newRefs[idx] = state.refs[idx];
-      }
-    });
-  }
-  return newRefs;
-}
-
-type ZoomWithStops = {
-  stops: [number | undefined, number][]
-  base?: number
-};
-
-
-type ZoomPropertyInternalProps = {
-  onChange?(...args: unknown[]): unknown
-  onChangeToDataFunction?(...args: unknown[]): unknown
-  onDeleteStop?(...args: unknown[]): unknown
-  onAddStop?(...args: unknown[]): unknown
-  onExpressionClick?(...args: unknown[]): unknown
-  fieldType?: string
-  fieldName: string
-  fieldSpec?: {
-    "property-type"?: string
-    "function-type"?: string
-  }
-  errors?: MappedLayerErrors
-  value?: ZoomWithStops
-} & WithTranslation;
-
-type ZoomPropertyState = {
-  refs: {[key: number]: string}
-};
-
-const ZoomPropertyInternal: React.FC<ZoomPropertyInternalProps> = ({ errors = {}, ...rest }) => {
-  const props = { errors, ...rest } as ZoomPropertyInternalProps;
-
-  // The stop refs never reach the rendered output (the row key is derived from
-  // the stop itself), so they live in a ref rather than state: keeping them in
-  // state would mean setting state during render on every pass.
-  const refs = useRef<{[key: number]: string}>({});
-  refs.current = setStopRefs(props, { refs: refs.current });
-
-  // Order the stops altering the refs to reflect their new position.
-  function orderStopsByZoom(stops: ZoomWithStops["stops"]) {
-    const mappedWithRef = stops
-      .map((stop, idx) => {
-        return {
-          ref: refs.current[idx],
-          data: stop
-        };
-      })
-    // Sort by zoom
-      .sort((a, b) => sortNumerically(a.data[0]!, b.data[0]!));
-
-    // Fetch the new position of the stops
-    const newRefs: {[key:number]: string} = {};
-    mappedWithRef
-      .forEach((stop, idx) =>{
-        newRefs[idx] = stop.ref;
-      });
-
-    refs.current = newRefs;
-
-    return mappedWithRef.map((item) => item.data);
-  }
-
-  function changeZoomStop(changeIdx: number, stopData: number | undefined, value: number) {
-    const stops = (props.value as ZoomWithStops).stops.slice(0);
-    stops[changeIdx] = [stopData, value];
-
-    const orderedStops = orderStopsByZoom(stops);
-
-    const changedValue = {
-      ...props.value as ZoomWithStops,
-      stops: orderedStops
-    };
-    props.onChange!(props.fieldName, changedValue);
-  }
-
-  function changeBase(newValue: number | undefined) {
-    const changedValue = {
-      ...props.value,
-      base: newValue
-    };
-
-    if (changedValue.base === undefined) {
-      delete changedValue["base"];
-    }
-    props.onChange!(props.fieldName, changedValue);
-  }
-
-  const changeDataType = (type: string) => {
-    if (type !== "interpolate" && props.onChangeToDataFunction) {
-      props.onChangeToDataFunction(type);
-    }
-  };
-
-  function getDataFunctionTypes(fieldSpec: {
-    "property-type"?: string
-    "function-type"?: string
-  }) {
-    if (fieldSpec["property-type"] === "data-driven") {
-      return ["interpolate", "categorical", "interval", "exponential", "identity"];
-    }
-    else {
-      return ["interpolate"];
-    }
-  }
-
-  const t = props.t;
-  const zoomFields = props.value?.stops.map((stop, idx) => {
-    const zoomLevel = stop[0];
-    const value = stop[1];
-    const deleteStopBtn = <DeleteStopButton onClick={props.onDeleteStop?.bind(null, idx)} />;
-    return <tr
-      key={`${stop[0]}-${stop[1]}`}
-    >
-      <td>
-        <InputNumber
-          aria-label={t("Zoom")}
-          value={zoomLevel}
-          onChange={changedStop => changeZoomStop(idx, changedStop, value)}
-          min={0}
-          max={22}
-        />
-      </td>
-      <td>
-        <InputSpec
-          aria-label={t("Output value")}
-          fieldName={props.fieldName}
-          fieldSpec={props.fieldSpec as any}
-          value={value}
-          onChange={(_, newValue) => changeZoomStop(idx, zoomLevel, newValue as number)}
-        />
-      </td>
-      <td>
-        {deleteStopBtn}
-      </td>
-    </tr>;
-  });
-
-  // return <div className="maputnik-zoom-spec-property">
-  return <div className="maputnik-data-spec-block">
-    <fieldset className="maputnik-data-spec-property">
-      <legend>{labelFromFieldName(props.fieldName)}</legend>
-      <div className="maputnik-data-fieldset-inner">
-        <Block
-          label={t("Function")}
-          data-wd-key="function-type"
-        >
-          <div className="maputnik-data-spec-property-input">
-            <InputSelect
-              value={"interpolate"}
-              onChange={(propVal: string) => changeDataType(propVal)}
-              title={t("Select a type of data scale (default is 'categorical').")}
-              options={getDataFunctionTypes(props.fieldSpec!)}
-            />
-          </div>
-        </Block>
-        <Block
-          label={t("Base")}
-          data-wd-key="function-base"
-        >
-          <div className="maputnik-data-spec-property-input">
-            <InputSpec
-              fieldName={"base"}
-              fieldSpec={latest.function.base as typeof latest.function.base & { type: "number" }}
-              value={props.value?.base}
-              onChange={(_, newValue) => changeBase(newValue as number | undefined)}
-            />
-          </div>
-        </Block>
-        <div className="maputnik-function-stop">
-          <table className="maputnik-function-stop-table maputnik-function-stop-table--zoom">
-            <caption>{t("Stops")}</caption>
-            <thead>
-              <tr>
-                <th>{t("Zoom")}</th>
-                <th rowSpan={2}>{t("Output value")}</th>
-              </tr>
-            </thead>
-            <tbody>
-              {zoomFields}
-            </tbody>
-          </table>
-        </div>
-        <div className="maputnik-toolbox">
-          <InputButton
-            className="maputnik-add-stop"
-            onClick={props.onAddStop?.bind(null)}
-          >
-            <PiListPlusBold style={{ verticalAlign: "text-bottom" }} />
-            {t("Add stop")}
-          </InputButton>
-          <InputButton
-            className="maputnik-add-stop"
-            data-wd-key="convert-to-expression"
-            onClick={props.onExpressionClick?.bind(null)}
-          >
-            <TbMathFunction style={{ verticalAlign: "text-bottom" }} />
-            {t("Convert to expression")}
-          </InputButton>
-        </div>
-      </div>
-    </fieldset>
-  </div>;
-};
-
-export const ZoomProperty = withTranslation()(ZoomPropertyInternal);

src/components/_DataProperty.tsx

@@ -0,0 +1,384 @@
+import React from "react";
+import {PiListPlusBold} from "react-icons/pi";
+import {TbMathFunction} from "react-icons/tb";
+import latest from "@maplibre/maplibre-gl-style-spec/dist/latest.json";
+
+import InputButton from "./InputButton";
+import InputSpec from "./InputSpec";
+import InputNumber from "./InputNumber";
+import InputString from "./InputString";
+import InputSelect from "./InputSelect";
+import Block from "./Block";
+import docUid from "../libs/document-uid";
+import sortNumerically from "../libs/sort-numerically";
+import {findDefaultFromSpec} from "../libs/spec-helper";
+import { type WithTranslation, withTranslation } from "react-i18next";
+
+import labelFromFieldName from "../libs/label-from-field-name";
+import DeleteStopButton from "./_DeleteStopButton";
+import { type MappedLayerErrors } from "../libs/definitions";
+
+
+
+function setStopRefs(props: DataPropertyInternalProps, state: DataPropertyState) {
+  // This is initialised below only if required to improved performance.
+  let newRefs: {[key: number]: string} | undefined;
+
+  if(props.value && props.value.stops) {
+    props.value.stops.forEach((_val, idx) => {
+      if(!Object.prototype.hasOwnProperty.call(state.refs, idx)) {
+        if(!newRefs) {
+          newRefs = {...state};
+        }
+        newRefs[idx] = docUid("stop-");
+      }
+    });
+  }
+
+  return newRefs;
+}
+
+type DataPropertyInternalProps = {
+  onChange?(fieldName: string, value: any): unknown
+  onDeleteStop?(...args: unknown[]): unknown
+  onAddStop?(...args: unknown[]): unknown
+  onExpressionClick?(...args: unknown[]): unknown
+  onChangeToZoomFunction?(...args: unknown[]): unknown
+  fieldName: string
+  fieldType?: string
+  fieldSpec?: object
+  value?: DataPropertyValue
+  errors?: MappedLayerErrors
+} & WithTranslation;
+
+type DataPropertyState = {
+  refs: {[key: number]: string}
+};
+
+type DataPropertyValue = {
+  default?: any
+  property?: string
+  base?: number
+  type?: string
+  stops: Stop[]
+};
+
+export type Stop = [{
+  zoom: number
+  value: number
+}, number];
+
+class DataPropertyInternal extends React.Component<DataPropertyInternalProps, DataPropertyState> {
+  state = {
+    refs: {} as {[key: number]: string}
+  };
+
+  componentDidMount() {
+    const newRefs = setStopRefs(this.props, this.state);
+
+    if(newRefs) {
+      this.setState({
+        refs: newRefs
+      });
+    }
+  }
+
+  static getDerivedStateFromProps(props: Readonly<DataPropertyInternalProps>, state: DataPropertyState) {
+    const newRefs = setStopRefs(props, state);
+    if(newRefs) {
+      return {
+        refs: newRefs
+      };
+    }
+    return null;
+  }
+
+  getFieldFunctionType(fieldSpec: any) {
+    if (fieldSpec.expression.interpolated) {
+      return "exponential";
+    }
+    if (fieldSpec.type === "number") {
+      return "interval";
+    }
+    return "categorical";
+  }
+
+  getDataFunctionTypes(fieldSpec: any) {
+    if (fieldSpec.expression.interpolated) {
+      return ["interpolate", "categorical", "interval", "exponential", "identity"];
+    }
+    else {
+      return ["categorical", "interval", "identity"];
+    }
+  }
+
+  // Order the stops altering the refs to reflect their new position.
+  orderStopsByZoom(stops: Stop[]) {
+    const mappedWithRef = stops
+      .map((stop, idx) => {
+        return {
+          ref: this.state.refs[idx],
+          data: stop
+        };
+      })
+    // Sort by zoom
+      .sort((a, b) => sortNumerically(a.data[0].zoom, b.data[0].zoom));
+
+    // Fetch the new position of the stops
+    const newRefs = {} as {[key: number]: string};
+    mappedWithRef
+      .forEach((stop, idx) =>{
+        newRefs[idx] = stop.ref;
+      });
+
+    this.setState({
+      refs: newRefs
+    });
+
+    return mappedWithRef.map((item) => item.data);
+  }
+
+  onChange = (fieldName: string, value: any) => {
+    if (value.type === "identity") {
+      value = {
+        type: value.type,
+        property: value.property,
+      };
+    }
+    else {
+      const stopValue = value.type === "categorical" ? "" : 0;
+      value = {
+        property: "",
+        type: value.type,
+        // Default props if they don't already exist.
+        stops: [
+          [{zoom: 6, value: stopValue}, findDefaultFromSpec(this.props.fieldSpec as any)],
+          [{zoom: 10, value: stopValue}, findDefaultFromSpec(this.props.fieldSpec as any)]
+        ],
+        ...value,
+      };
+    }
+    this.props.onChange!(fieldName, value);
+  };
+
+  changeStop(changeIdx: number, stopData: { zoom: number | undefined, value: number }, value: number) {
+    const stops = this.props.value?.stops.slice(0) || [];
+    // const changedStop = stopData.zoom === undefined ? stopData.value : stopData
+    stops[changeIdx] = [
+      {
+        value: stopData.value,
+        zoom: (stopData.zoom === undefined) ? 0 : stopData.zoom,
+      },
+      value
+    ];
+
+    const orderedStops = this.orderStopsByZoom(stops);
+
+    const changedValue = {
+      ...this.props.value,
+      stops: orderedStops,
+    };
+    this.onChange(this.props.fieldName, changedValue);
+  }
+
+  changeBase(newValue: number | undefined) {
+    const changedValue = {
+      ...this.props.value,
+      base: newValue
+    };
+
+    if (changedValue.base === undefined) {
+      delete changedValue["base"];
+    }
+    this.props.onChange!(this.props.fieldName, changedValue);
+  }
+
+  changeDataType(propVal: string) {
+    if (propVal === "interpolate" && this.props.onChangeToZoomFunction) {
+      this.props.onChangeToZoomFunction();
+    }
+    else {
+      this.onChange(this.props.fieldName, {
+        ...this.props.value,
+        type: propVal,
+      });
+    }
+  }
+
+  changeDataProperty(propName: "property" | "default", propVal: any) {
+    if (propVal) {
+      this.props.value![propName] = propVal;
+    }
+    else {
+      delete this.props.value![propName];
+    }
+    this.onChange(this.props.fieldName, this.props.value);
+  }
+
+  render() {
+    const t = this.props.t;
+
+    if (typeof this.props.value?.type === "undefined") {
+      this.props.value!.type = this.getFieldFunctionType(this.props.fieldSpec);
+    }
+
+    let dataFields;
+    if (this.props.value?.stops) {
+      dataFields = this.props.value.stops.map((stop, idx) => {
+        const zoomLevel = typeof stop[0] === "object" ? stop[0].zoom : undefined;
+        const key  = this.state.refs[idx];
+        const dataLevel = typeof stop[0] === "object" ? stop[0].value : stop[0];
+        const value = stop[1];
+        const deleteStopBtn = <DeleteStopButton onClick={this.props.onDeleteStop?.bind(this, idx)} />;
+
+        const dataProps = {
+          "aria-label": t("Input value"),
+          label: t("Data value"),
+          value: dataLevel as any,
+          onChange: (newData: string | number | undefined) => this.changeStop(idx, { zoom: zoomLevel, value: newData as number }, value)
+        };
+
+        let dataInput;
+        if(this.props.value?.type === "categorical") {
+          dataInput = <InputString {...dataProps} />;
+        }
+        else {
+          dataInput = <InputNumber {...dataProps} />;
+        }
+
+        let zoomInput = null;
+        if(zoomLevel !== undefined) {
+          zoomInput = <div>
+            <InputNumber
+              aria-label="Zoom"
+              value={zoomLevel}
+              onChange={newZoom => this.changeStop(idx, {zoom: newZoom, value: dataLevel}, value)}
+              min={0}
+              max={22}
+            />
+          </div>;
+        }
+
+        return <tr key={key}>
+          <td>
+            {zoomInput}
+          </td>
+          <td>
+            {dataInput}
+          </td>
+          <td>
+            <InputSpec
+              aria-label={t("Output value")}
+              fieldName={this.props.fieldName}
+              fieldSpec={this.props.fieldSpec}
+              value={value}
+              onChange={(_, newValue) => this.changeStop(idx, {zoom: zoomLevel, value: dataLevel}, newValue as number)}
+            />
+          </td>
+          <td>
+            {deleteStopBtn}
+          </td>
+        </tr>;
+      });
+    }
+
+    return <div className="maputnik-data-spec-block">
+      <fieldset className="maputnik-data-spec-property">
+        <legend>{labelFromFieldName(this.props.fieldName)}</legend>
+        <div className="maputnik-data-fieldset-inner">
+          <Block
+            label={t("Function")}
+            key="function"
+          >
+            <div className="maputnik-data-spec-property-input">
+              <InputSelect
+                value={this.props.value!.type}
+                onChange={(propVal: string) => this.changeDataType(propVal)}
+                title={t("Select a type of data scale (default is 'categorical').")}
+                options={this.getDataFunctionTypes(this.props.fieldSpec)}
+              />
+            </div>
+          </Block>
+          {this.props.value?.type !== "identity" &&
+            <Block
+              label={t("Base")}
+              key="base"
+            >
+              <div className="maputnik-data-spec-property-input">
+                <InputSpec
+                  fieldName={"base"}
+                  fieldSpec={latest.function.base as typeof latest.function.base & { type: "number" }}
+                  value={this.props.value?.base}
+                  onChange={(_, newValue) => this.changeBase(newValue as number)}
+                />
+              </div>
+            </Block>
+          }
+          <Block
+            label={"Property"}
+            key="property"
+          >
+            <div className="maputnik-data-spec-property-input">
+              <InputString
+                value={this.props.value?.property}
+                title={t("Input a data property to base styles off of.")}
+                onChange={propVal => this.changeDataProperty("property", propVal)}
+              />
+            </div>
+          </Block>
+          {dataFields &&
+            <Block
+              label={t("Default")}
+              key="default"
+            >
+              <InputSpec
+                fieldName={this.props.fieldName}
+                fieldSpec={this.props.fieldSpec}
+                value={this.props.value?.default}
+                onChange={(_, propVal) => this.changeDataProperty("default", propVal)}
+              />
+            </Block>
+          }
+          {dataFields &&
+            <div className="maputnik-function-stop">
+              <table className="maputnik-function-stop-table">
+                <caption>{t("Stops")}</caption>
+                <thead>
+                  <tr>
+                    <th>{t("Zoom")}</th>
+                    <th>{t("Input value")}</th>
+                    <th rowSpan={2}>{t("Output value")}</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {dataFields}
+                </tbody>
+              </table>
+            </div>
+          }
+          <div className="maputnik-toolbox">
+            {dataFields &&
+              <InputButton
+                className="maputnik-add-stop"
+                onClick={this.props.onAddStop?.bind(this)}
+              >
+                <PiListPlusBold style={{ verticalAlign: "text-bottom" }} />
+                {t("Add stop")}
+              </InputButton>
+            }
+            <InputButton
+              className="maputnik-add-stop"
+              onClick={this.props.onExpressionClick?.bind(this)}
+            >
+              <TbMathFunction style={{ verticalAlign: "text-bottom" }} />
+              {t("Convert to expression")}
+            </InputButton>
+          </div>
+        </div>
+      </fieldset>
+    </div>;
+  }
+}
+
+const DataProperty = withTranslation()(DataPropertyInternal);
+export default DataProperty;

src/components/_DeleteStopButton.tsx

@@ -0,0 +1,27 @@
+import React from "react";
+
+import InputButton from "./InputButton";
+import {MdDelete} from "react-icons/md";
+import { type WithTranslation, withTranslation } from "react-i18next";
+
+
+type DeleteStopButtonInternalProps = {
+  onClick?(...args: unknown[]): unknown
+} & WithTranslation;
+
+
+class DeleteStopButtonInternal extends React.Component<DeleteStopButtonInternalProps> {
+  render() {
+    const t = this.props.t;
+    return <InputButton
+      className="maputnik-delete-stop"
+      onClick={this.props.onClick}
+      title={t("Remove zoom level from stop")}
+    >
+      <MdDelete />
+    </InputButton>;
+  }
+}
+
+const DeleteStopButton = withTranslation()(DeleteStopButtonInternal);
+export default DeleteStopButton;

src/components/_ExpressionProperty.tsx

@@ -0,0 +1,94 @@
+import React from "react";
+import {MdDelete, MdUndo} from "react-icons/md";
+import { type WithTranslation, withTranslation } from "react-i18next";
+
+import Block from "./Block";
+import InputButton from "./InputButton";
+import labelFromFieldName from "../libs/label-from-field-name";
+import FieldJson from "./FieldJson";
+import type { StylePropertySpecification } from "maplibre-gl";
+import { type MappedLayerErrors } from "../libs/definitions";
+
+
+type ExpressionPropertyInternalProps = {
+  fieldName: string
+  fieldType?: string
+  fieldSpec?: StylePropertySpecification
+  value?: any
+  errors?: MappedLayerErrors
+  onDelete?(...args: unknown[]): unknown
+  onChange(value: object): void
+  onUndo?(...args: unknown[]): unknown
+  canUndo?(...args: unknown[]): unknown
+  onFocus?(...args: unknown[]): unknown
+  onBlur?(...args: unknown[]): unknown
+} & WithTranslation;
+
+class ExpressionPropertyInternal extends React.Component<ExpressionPropertyInternalProps> {
+  static defaultProps = {
+    errors: {},
+    onFocus: () => {},
+    onBlur: () => {},
+  };
+
+  constructor(props: ExpressionPropertyInternalProps) {
+    super(props);
+    this.state = {
+      jsonError: false,
+    };
+  }
+
+  render() {
+    const {t, value, canUndo} = this.props;
+    const undoDisabled = canUndo ? !canUndo() : true;
+
+    const deleteStopBtn = (
+      <>
+        {this.props.onUndo &&
+          <InputButton
+            key="undo_action"
+            onClick={this.props.onUndo}
+            disabled={undoDisabled}
+            className="maputnik-delete-stop"
+            title={t("Revert from expression")}
+          >
+            <MdUndo />
+          </InputButton>
+        }
+        <InputButton
+          key="delete_action"
+          onClick={this.props.onDelete}
+          className="maputnik-delete-stop"
+          title={t("Delete expression")}
+        >
+          <MdDelete />
+        </InputButton>
+      </>
+    );
+    let error = undefined;
+    if (this.props.errors) {
+      const fieldKey = this.props.fieldType ? this.props.fieldType + "." + this.props.fieldName : this.props.fieldName;
+      error = this.props.errors[fieldKey];
+    }
+    return <Block
+      fieldSpec={this.props.fieldSpec}
+      label={t(labelFromFieldName(this.props.fieldName))}
+      action={deleteStopBtn}
+      wideMode={true}
+      error={error}
+    >
+      <FieldJson
+        lintType="expression"
+        spec={this.props.fieldSpec}
+        className="maputnik-expression-editor"
+        onFocus={this.props.onFocus}
+        onBlur={this.props.onBlur}
+        value={value}
+        onChange={this.props.onChange}
+      />
+    </Block>;
+  }
+}
+
+const ExpressionProperty = withTranslation()(ExpressionPropertyInternal);
+export default ExpressionProperty;

src/components/_FunctionButtons.tsx

@@ -0,0 +1,71 @@
+import React from "react";
+
+import InputButton from "./InputButton";
+import {MdFunctions, MdInsertChart} from "react-icons/md";
+import { TbMathFunction } from "react-icons/tb";
+import { type WithTranslation, withTranslation } from "react-i18next";
+
+type FunctionInputButtonsInternalProps = {
+  fieldSpec?: any
+  onZoomClick?(): void
+  onDataClick?(): void
+  onExpressionClick?(): void
+  onElevationClick?(): void
+} & WithTranslation;
+
+class FunctionInputButtonsInternal extends React.Component<FunctionInputButtonsInternalProps> {
+  render() {
+    const t = this.props.t;
+
+    if (this.props.fieldSpec.expression?.parameters.includes("zoom")) {
+      const expressionInputButton = (
+        <InputButton
+          className="maputnik-make-zoom-function"
+          onClick={this.props.onExpressionClick}
+          title={t("Convert to expression")}
+        >
+          <TbMathFunction />
+        </InputButton>
+      );
+
+      const makeZoomInputButton = <InputButton
+        className="maputnik-make-zoom-function"
+        onClick={this.props.onZoomClick}
+        title={t("Convert property into a zoom function")}
+      >
+        <MdFunctions />
+      </InputButton>;
+
+      let makeDataInputButton;
+      if (this.props.fieldSpec["property-type"] === "data-driven") {
+        makeDataInputButton = <InputButton
+          className="maputnik-make-data-function"
+          onClick={this.props.onDataClick}
+          title={t("Convert property to data function")}
+        >
+          <MdInsertChart />
+        </InputButton>;
+      }
+      return <div>
+        {expressionInputButton}
+        {makeDataInputButton}
+        {makeZoomInputButton}
+      </div>;
+    } else if (this.props.fieldSpec.expression?.parameters.includes("elevation")) {
+      const inputElevationButton = <InputButton
+        className="maputnik-make-elevation-function"
+        onClick={this.props.onElevationClick}
+        title={t("Convert property into a elevation function")}
+        data-wd-key='make-elevation-function'
+      >
+        <MdFunctions />
+      </InputButton>;
+      return <div>{inputElevationButton}</div>;
+    } else {
+      return <div></div>;
+    }
+  }
+}
+
+const FunctionInputButtons = withTranslation()(FunctionInputButtonsInternal);
+export default FunctionInputButtons;

src/components/_SpecProperty.tsx

@@ -0,0 +1,48 @@
+import React from "react";
+
+import FieldSpec, {type FieldSpecProps} from "./FieldSpec";
+import FunctionButtons from "./_FunctionButtons";
+
+import labelFromFieldName from "../libs/label-from-field-name";
+
+
+type SpecPropertyProps = FieldSpecProps & {
+  fieldName?: string
+  fieldType?: string
+  fieldSpec?: any
+  value?: any
+  errors?: {[key: string]: {message: string}}
+  onZoomClick(): void
+  onDataClick(): void
+  onExpressionClick?(): void
+  onElevationClick?(): void
+};
+
+
+export default class SpecProperty extends React.Component<SpecPropertyProps> {
+  static defaultProps = {
+    errors: {},
+  };
+
+  render() {
+    const {errors, fieldName, fieldType} = this.props;
+
+    const functionBtn = <FunctionButtons
+      fieldSpec={this.props.fieldSpec}
+      onZoomClick={this.props.onZoomClick}
+      onDataClick={this.props.onDataClick}
+      onExpressionClick={this.props.onExpressionClick}
+      onElevationClick={this.props.onElevationClick}
+    />;
+
+    const error = errors![fieldType+"."+fieldName as any] as any;
+
+    return <FieldSpec
+      {...this.props}
+      error={error}
+      fieldSpec={this.props.fieldSpec}
+      label={labelFromFieldName(this.props.fieldName || "")}
+      action={functionBtn}
+    />;
+  }
+}