gtfs-garage-web 0.0.1

package/README.md

@@ -0,0 +1,86 @@
+# gtfs-garage-web
+
+Browse a GTFS feed: a table with filters and foreign-key navigation, and a map
+of its stops, shapes and zones. The viewer of
+[GTFS Garage](https://github.com/MobilityData/gtfs-garage), packaged so it can
+be mounted in another application.
+
+## Install
+
+```sh
+npm install gtfs-garage-web
+```
+
+The map is a separate entry point, and MapLibre an **optional** peer. Install
+it only if you want one:
+
+```sh
+npm install maplibre-gl            # only with the map
+```
+
+Nothing in the main entry mentions MapLibre, so a viewer without a map neither
+downloads it nor needs it installed to build. That is why the map arrives as an
+import rather than a flag: a bundler resolves `import()` specifiers whether or
+not the branch runs, so a flag would still have made MapLibre mandatory.
+
+## React
+
+```tsx
+"use client";
+
+import { GtfsGarage } from "gtfs-garage-web/react";
+import { mapPart } from "gtfs-garage-web/map";
+import "gtfs-garage-web/style.css";
+import "maplibre-gl/dist/maplibre-gl.css";
+
+export default function Feed() {
+  return <GtfsGarage map={mapPart} baseUrl="https://example.org" style={{ height: "80vh" }} />;
+}```
+
+Drop the two `map` imports and the MapLibre stylesheet for a table-only viewer:
+
+```tsx
+<GtfsGarage baseUrl="https://example.org" style={{ height: "80vh" }} />
+```
+
+`"use client"` is required: the viewer builds DOM and cannot render on a server.
+
+**Give the container a height.** The viewer fills whatever box it is given, and
+a box with no height renders an invisible map.
+
+## Without React
+
+```ts
+import { mount } from "gtfs-garage-web";
+import "gtfs-garage-web/style.css";
+
+const viewer = await mount(document.querySelector("#feed")!, {
+  baseUrl: "https://example.org",
+  // map: mapPart,   from "gtfs-garage-web/map"
+});
+
+viewer.destroy(); // releases the map, the history subscription and the markup
+```
+
+## Where the data comes from
+
+By default the viewer talks to a GTFS Garage server at `baseUrl`. To drive it
+from your own backend instead, pass a `source` implementing `ViewerSource` —
+`GtfsSource` for the table, plus `geojsonStream` for the map, which draws a
+large feed's shapes as they arrive rather than all at the end.
+
+## Styling
+
+Every rule is scoped under `.gtfs-viewer`, so the stylesheet cannot reach your
+page. The design tokens are declared on that class and are the theming API:
+
+```css
+.gtfs-viewer {
+  --accent: #2563eb;
+  --font: "Inter", sans-serif;
+}
+```
+
+## Licence
+
+Apache-2.0

package/dist/dataset.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Where a dataset stands, as the host sees it.
+ *
+ * A host knows whether a dataset has been prepared and how far along it is; the
+ * viewer knows how to say so. This interface is the whole of what a host
+ * supplies - facts, never markup - and `mountDataset` renders every state from
+ * it, so no integration writes its own progress bar or its own error box.
+ */
+import type { LoadProgress, ViewerSource } from "./sources/types";
+export type DatasetState = 
+/** Nothing has been prepared yet. `prepare` is offered the chance to start it. */
+{
+    state: "absent";
+}
+/**
+ * Being prepared. `progress` uses the same phases a feed load reports -
+ * download, extract, convert, summarise - so the wording is already written.
+ */
+ | {
+    state: "preparing";
+    progress?: LoadProgress;
+}
+/** Ready to browse. The host supplies the source, so it decides how to read it. */
+ | {
+    state: "ready";
+    source: ViewerSource;
+} | {
+    state: "failed";
+    message: string;
+};
+export interface DatasetProvider {
+    /**
+     * Where the dataset stands. Polled while it is being prepared, and passed an
+     * `AbortSignal` that fires when the viewer goes away mid-request.
+     */
+    status(signal: AbortSignal): Promise<DatasetState>;
+    /**
+     * Start preparing the dataset, for a host that offers that. Called at most
+     * once, on the first `absent` - calling it per poll would queue a conversion
+     * every second.
+     */
+    prepare?(signal: AbortSignal): Promise<void>;
+}
+/**
+ * What to do about a reported state.
+ *
+ * Separated from the mounting so it can be tested without a document, which is
+ * how the rest of this package is arranged: `values.ts` decides and `table.ts`
+ * draws. Every rule that matters - when to stop polling, when to ask for
+ * preparation, what to say - is here.
+ */
+export interface DatasetDecision {
+    /** What to show. Absent when the viewer itself is taking the root over. */
+    line?: string;
+    tone?: "error";
+    /** Stop polling: there is nothing further to wait for. */
+    settled?: boolean;
+    /** Ask the host to begin preparing. Never more than once. */
+    prepare?: boolean;
+    /** Open the viewer on this. */
+    source?: ViewerSource;
+}
+export interface DecisionContext {
+    /** Named in the lines, so a host can say which dataset is meant. */
+    description: string;
+    /** Whether the host offers to start preparation at all. */
+    canPrepare: boolean;
+    /** Whether it has already been asked. */
+    asked: boolean;
+    /** How a progress reading is worded; the viewer's own load phrasing. */
+    phrase: (progress: LoadProgress | null, description: string) => string;
+}
+export declare function decideDataset(status: DatasetState, context: DecisionContext): DatasetDecision;

package/dist/dataset.js

@@ -0,0 +1,64 @@
+import { m as h, p as L } from "./mount-Bpr3Nw4_.js";
+function P(e, s) {
+  const { description: a, canPrepare: n, asked: c, phrase: f } = s;
+  switch (e.state) {
+    case "ready":
+      return { settled: !0, source: e.source };
+    case "failed":
+      return { settled: !0, line: e.message, tone: "error" };
+    case "absent":
+      return n ? c ? { line: `Preparing ${a}…` } : { prepare: !0, line: `Preparing ${a}…` } : { settled: !0, line: `${a} has not been prepared yet.` };
+    case "preparing":
+      return { line: f(e.progress ?? null, a) };
+  }
+}
+const b = 500, o = /* @__PURE__ */ new WeakMap();
+function M(e) {
+  e.classList.add("gtfs-viewer"), e.innerHTML = '<div data-el="dataset-status"><div data-el="empty-state"></div></div>';
+  const s = e.querySelector('[data-el="empty-state"]');
+  return (a, n = "normal") => {
+    s.textContent = a, s.classList.toggle("is-error", n === "error");
+  };
+}
+async function C(e, s) {
+  const { dataset: a, pollMs: n = b, description: c = "the dataset", ...f } = s, g = M(e), d = {};
+  o.set(e, d);
+  const w = new AbortController(), m = (t) => new Promise((r) => setTimeout(r, t));
+  let l = !1, p, i, y = !1;
+  const v = async (t) => {
+    var u;
+    if (l || o.get(e) !== d) return void ((u = t.close) == null ? void 0 : u.call(t));
+    i = t;
+    const r = await h(e, { ...f, source: t });
+    l || o.get(e) !== d ? r.destroy() : p = r;
+  };
+  return (async () => {
+    for (g(`Loading ${c}…`); !l; ) {
+      let t;
+      try {
+        t = await a.status(w.signal);
+      } catch {
+        await m(n);
+        continue;
+      }
+      if (l) return;
+      const r = P(t, {
+        description: c,
+        canPrepare: !!a.prepare,
+        asked: y,
+        phrase: L
+      });
+      if (r.line && g(r.line, r.tone === "error" ? "error" : "normal"), r.prepare && a.prepare && (y = !0, a.prepare(w.signal).catch((u) => g(u.message, "error"))), r.source) return v(r.source);
+      if (r.settled) return;
+      await m(n);
+    }
+  })(), {
+    destroy() {
+      var t;
+      l = !0, w.abort(), p == null || p.destroy(), (t = i == null ? void 0 : i.close) == null || t.call(i), o.get(e) === d && (o.delete(e), e.replaceChildren(), e.classList.remove("gtfs-viewer"));
+    }
+  };
+}
+export {
+  C as mountDataset
+};

package/dist/dom.d.ts

@@ -0,0 +1,24 @@
+/** Small DOM helpers shared by the UI modules. */
+/**
+ * Element lookup scoped to one viewer.
+ *
+ * Every lookup goes through a root rather than `document`, so two viewers can
+ * exist on one page without reaching into each other's markup. That is what a
+ * host embedding this needs: the UI used to resolve 37 fixed ids against the
+ * whole document, which silently assumed it was the only thing on the page.
+ */
+export interface Dom {
+    el<T extends HTMLElement = HTMLElement>(name: string): T;
+}
+export declare function createDom(root: ParentNode): Dom;
+/**
+ * The whole document, for the application that owns the page.
+ *
+ * Embedded viewers build their own with `createDom(root)`; this is the one case
+ * where taking the document is correct rather than an assumption. A function
+ * rather than a constant so that merely importing this module does not require
+ * a document - the tests run without one, which is what keeps the UI's pure
+ * logic testable.
+ */
+export declare function documentDom(): Dom;
+export declare function button(label: string, title: string, onClick: () => void): HTMLButtonElement;

package/dist/gtfs-garage-web.css

@@ -0,0 +1 @@
+.gtfs-viewer{--bg: #f7f7f8;--panel: #ffffff;--border: #dcdde0;--text: #1c1e21;--muted: #6b7280;--accent: #2563eb;--accent-bg: #eef2ff;--chip-bg: #eef1f5;--font: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;font-family:var(--font);color:var(--text);background:var(--bg);display:flex;flex-direction:column;height:100%;min-height:0;position:relative}.gtfs-viewer,.gtfs-viewer *{box-sizing:border-box}.gtfs-viewer header{display:flex;align-items:center;gap:12px;padding:10px 16px;background:var(--panel);border-bottom:1px solid var(--border);flex-shrink:0}.gtfs-viewer header h1{font-size:16px;margin:0}.gtfs-viewer [data-el=source-label]{color:var(--muted);font-size:13px;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.gtfs-viewer button{font:inherit;cursor:pointer;border:1px solid var(--border);background:var(--panel);border-radius:6px;padding:6px 10px}.gtfs-viewer button.primary{background:var(--accent);color:#fff;border-color:var(--accent)}.gtfs-viewer button:disabled{opacity:.45;cursor:default}.gtfs-viewer button:hover{filter:brightness(.97)}.gtfs-viewer [data-el=layout]{flex:1;display:flex;min-height:0}.gtfs-viewer [data-el=sidebar]{width:210px;flex-shrink:0;background:var(--panel);border-right:1px solid var(--border);overflow-y:auto;padding:8px}.gtfs-viewer .table-tab{display:flex;justify-content:space-between;padding:7px 10px;border-radius:6px;cursor:pointer;font-size:13px}.gtfs-viewer .table-tab:hover{background:var(--bg)}.gtfs-viewer .table-tab.active{background:var(--accent-bg);color:var(--accent);font-weight:600}.gtfs-viewer .table-tab .count{color:var(--muted);font-weight:400}.gtfs-viewer .table-tab.active .count{color:var(--accent)}.gtfs-viewer .table-tab.missing{color:var(--muted);cursor:default;font-style:italic}.gtfs-viewer .table-tab.missing:hover{background:none}.gtfs-viewer .table-tab.forbidden .count{font-style:italic}.gtfs-viewer [data-el=content]{flex:1;display:flex;min-width:0;min-height:0}.gtfs-viewer [data-el=table-pane]{flex:1.3;display:flex;flex-direction:column;min-width:0;border-right:1px solid var(--border)}.gtfs-viewer [data-el=map-pane]{flex:1;min-width:0;position:relative}.gtfs-viewer [data-el=map]{position:absolute;top:0;right:0;bottom:0;left:0}.gtfs-viewer [data-el=filter-bar]{display:flex;flex-wrap:wrap;gap:6px;align-items:center;padding:8px 10px;border-bottom:1px solid var(--border);background:var(--panel)}.gtfs-viewer .raw-toggle{display:flex;align-items:center;gap:5px;margin-left:auto;padding:0 4px;font-size:12px;color:var(--muted);cursor:pointer;-webkit-user-select:none;user-select:none}.gtfs-viewer .raw-toggle input{cursor:pointer}.gtfs-viewer .chip{display:flex;align-items:center;gap:6px;background:var(--chip-bg);border-radius:999px;padding:4px 10px;font-size:12px}.gtfs-viewer .chip button{border:none;background:none;padding:0;color:var(--muted);font-size:13px;line-height:1}.gtfs-viewer [data-el=add-filter-form]{display:none;gap:6px;align-items:center;padding:8px 10px;border-bottom:1px solid var(--border);background:var(--bg);font-size:13px}.gtfs-viewer [data-el=add-filter-form].open{display:flex}.gtfs-viewer [data-el=add-filter-form] select,.gtfs-viewer [data-el=add-filter-form] input{font:inherit;padding:4px 6px;border:1px solid var(--border);border-radius:4px}.gtfs-viewer [data-el=dataset-status]{flex:1;display:flex;align-items:center;justify-content:center;padding:24px}.gtfs-viewer [data-el=dataset-status] .is-error{color:#b42318}.gtfs-viewer [data-el=table-scroll]{flex:1;overflow:auto}.gtfs-viewer table{border-collapse:collapse;width:100%;font-size:12.5px}.gtfs-viewer th,.gtfs-viewer td{border-bottom:1px solid var(--border);padding:5px 10px;text-align:left;white-space:nowrap}.gtfs-viewer th{position:sticky;top:0;background:var(--panel);z-index:1}.gtfs-viewer tr:hover td{background:#fafafa}.gtfs-viewer a.fk-link{color:var(--accent);text-decoration:none}.gtfs-viewer a.fk-link:hover{text-decoration:underline}.gtfs-viewer .related-row{display:flex;gap:4px;flex-wrap:wrap;margin-top:2px}.gtfs-viewer .related-btn{font-size:10.5px;padding:1px 6px;border-radius:999px;background:var(--chip-bg);border:none;color:var(--muted)}.gtfs-viewer .related-btn:hover{background:var(--accent-bg);color:var(--accent)}.gtfs-viewer [data-el=pager]{display:flex;align-items:center;gap:8px;padding:6px 10px;border-top:1px solid var(--border);background:var(--panel);font-size:12.5px}.gtfs-viewer [data-el=pager] .spacer{flex:1}.gtfs-viewer [data-el=load-overlay]{position:fixed;top:0;right:0;bottom:0;left:0;background:#14141973;display:flex;align-items:center;justify-content:center;z-index:50}.gtfs-viewer [data-el=load-overlay].hidden{display:none}.gtfs-viewer [data-el=load-panel]{background:var(--panel);border-radius:10px;padding:24px;width:420px;max-width:90vw}.gtfs-viewer [data-el=load-panel] h2{margin-top:0;font-size:16px}.gtfs-viewer [data-el=dropzone]{border:2px dashed var(--border);border-radius:8px;padding:24px;text-align:center;color:var(--muted);font-size:13px;margin-bottom:12px}.gtfs-viewer [data-el=dropzone].drag{border-color:var(--accent);color:var(--accent)}.gtfs-viewer [data-el=load-panel] .or{text-align:center;color:var(--muted);font-size:12px;margin:8px 0}.gtfs-viewer [data-el=load-panel] input[type=text]{width:100%;padding:6px 8px;border:1px solid var(--border);border-radius:6px;font:inherit;margin-bottom:10px}.gtfs-viewer [data-el=load-panel] input[type=text]:focus{outline:2px solid var(--accent);outline-offset:-1px;border-color:var(--accent)}.gtfs-viewer .field-label{display:block;font-size:12px;color:var(--muted);margin-bottom:4px}.gtfs-viewer [data-el=pick-row]{display:flex;gap:8px;margin-bottom:4px}.gtfs-viewer [data-el=pick-row] button{flex:1}.gtfs-viewer [data-el=load-actions]{display:flex;gap:8px;align-items:center}.gtfs-viewer [data-el=load-status]{color:var(--muted);font-size:12.5px;margin-top:8px}.gtfs-viewer [data-el=load-error]{color:[data-el="b91c1c"];font-size:12.5px;margin-top:8px}.gtfs-viewer [data-el=empty-state]{padding:40px;color:var(--muted);text-align:center}.gtfs-viewer [data-el=metrics-btn]{color:var(--muted);font-size:12.5px;padding:4px 8px;flex-shrink:0;white-space:nowrap}.gtfs-viewer [data-el=metrics-panel]{position:absolute;top:46px;right:16px;z-index:5;background:var(--panel);border:1px solid var(--border);border-radius:10px;padding:12px 14px;font-size:12.5px;max-width:90vw;max-height:70vh;overflow:auto;box-shadow:0 6px 20px #0000001f}.gtfs-viewer [data-el=metrics-panel].hidden{display:none}.gtfs-viewer [data-el=metrics-header]{display:flex;align-items:center;gap:12px;margin-bottom:8px}.gtfs-viewer [data-el=metrics-header] strong{flex:1}.gtfs-viewer [data-el=metrics-header] button{padding:0 6px;line-height:1.4}.gtfs-viewer [data-el=metrics-phases]{display:grid;grid-template-columns:auto auto;gap:2px 14px;margin:0 0 12px}.gtfs-viewer [data-el=metrics-phases] dt{color:var(--muted)}.gtfs-viewer [data-el=metrics-phases] dd{margin:0;text-align:right;font-variant-numeric:tabular-nums}.gtfs-viewer [data-el=metrics-body] table{border-collapse:collapse;white-space:nowrap}.gtfs-viewer [data-el=metrics-body] th{text-align:left;color:var(--muted);font-weight:500;border-bottom:1px solid var(--border)}.gtfs-viewer [data-el=metrics-body] th,.gtfs-viewer [data-el=metrics-body] td{padding:3px 10px 3px 0}.gtfs-viewer [data-el=metrics-body] td:not(:first-child){text-align:right;font-variant-numeric:tabular-nums}.gtfs-viewer [data-el=map-progress]{position:absolute;left:12px;bottom:12px;z-index:2;background:var(--panel);border:1px solid var(--border);border-radius:6px;padding:5px 10px;color:var(--muted);font-size:12.5px;font-variant-numeric:tabular-nums;box-shadow:0 2px 8px #0000001a;pointer-events:none}.gtfs-viewer [data-el=table-scroll] td.value-numeric{text-align:right;font-variant-numeric:tabular-nums}.gtfs-viewer [data-el=table-scroll] td.value-implied{color:var(--muted);font-style:italic;cursor:help}.gtfs-viewer [data-el=table-scroll] td.value-malformed{cursor:help}.gtfs-viewer .value-swatch{display:inline-block;width:.75em;height:.75em;margin-right:6px;border:1px solid var(--border);border-radius:2px;vertical-align:baseline}.gtfs-viewer .value-link{color:var(--accent)}

package/dist/map/basemap.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The backdrop under the feed's geometry.
+ *
+ * Presets are keyless, except CARTO, which watermarks its tiles unless an API
+ * key is appended to the URL.
+ *
+ * Attribution is a licence obligation, not decoration: OpenStreetMap data is
+ * ODbL and the styles are CC BY, both of which require credit. It is declared
+ * here rather than taken from the upstream style, which may not carry any.
+ */
+export interface BasemapSpec {
+    kind: "vector" | "raster" | "none";
+    /** Style URL for vector, tile template for raster. */
+    url?: string;
+    attribution?: string;
+}
+export declare const BASEMAPS: Record<string, BasemapSpec>;
+export declare const DEFAULT_BASEMAP = "openfreemap";
+/**
+ * Turn a configured value into a spec. Accepts a preset name, a raster tile
+ * template (recognised by its {z}/{x}/{y} placeholders), or a vector style URL.
+ */
+export declare function resolveBasemap(value?: string | null): BasemapSpec;

package/dist/map/geo.d.ts

@@ -0,0 +1,4 @@
+import type { FeatureCollection } from "../sources/types";
+export type Bbox = [number, number, number, number];
+/** Bounding box of every coordinate in a collection, or null if it has none. */
+export declare function bboxOf(collection: FeatureCollection): Bbox | null;

package/dist/map/layers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The feed's own layers, and how they are combined with a basemap.
+ *
+ * Sources and layers are declared up front rather than added in a `load`
+ * handler: `load` only fires after the first paint, so in a background tab
+ * (where requestAnimationFrame never runs) the layers would never exist and the
+ * feed's data would silently never reach the map.
+ *
+ * Route colouring follows the conventions used by mobilitydatabase.org - colour
+ * from `route_color`, width by `route_type`, a white casing underneath - so the
+ * two read alike. The geometry itself is generated locally from the feed's own
+ * shapes.txt; nothing here depends on that service.
+ */
+import type { BasemapSpec } from "./basemap";
+export declare const EMPTY_FEATURE_COLLECTION: {
+    type: "FeatureCollection";
+    features: never[];
+};
+export declare const SOURCE_IDS: readonly ["locations", "routes", "shapes", "stops", "highlight"];
+export type SourceId = (typeof SOURCE_IDS)[number];
+/**
+ * Build the complete style: the basemap underneath, the feed's layers on top.
+ *
+ * A vector basemap is fetched and merged rather than referenced by URL, so the
+ * map is constructed from one complete style object and the feed's layers exist
+ * from the first frame.
+ */
+export declare function buildStyle(basemap: BasemapSpec): Promise<Record<string, unknown>>;

package/dist/map/map.d.ts

@@ -0,0 +1,60 @@
+import type { Dom } from "../dom";
+import type { FeatureCollection, ViewerSource } from "../sources/types";
+import type { AppState } from "../state";
+export declare class MapController {
+    private readonly maplibregl;
+    private readonly dom;
+    private readonly state;
+    private readonly source;
+    private readonly map;
+    private readonly ready;
+    /**
+     * A vector basemap has to be fetched before the map is constructed, and
+     * MapLibre itself is fetched here rather than imported at the top of the
+     * file.
+     *
+     * That is what keeps it optional. A host that mounts the viewer without the
+     * map part never reaches this method, so its bundler never follows the
+     * import and none of MapLibre's ~1 MB is downloaded. A static import would
+     * make it a cost every consumer pays whether or not they show a map.
+     */
+    static create(dom: Dom, state: AppState, source: ViewerSource, basemap?: string | null): Promise<MapController>;
+    /** Cancels an in-flight refresh when a new feed arrives mid-draw. */
+    private drawing;
+    /** The first full draw, while it is still running. See `highlight`. */
+    private pendingRefresh;
+    /** Layers the server thinned to fit, and by how much. */
+    private readonly simplifiedLayers;
+    private constructor();
+    isVisible(): boolean;
+    /** Restore the saved preference; defaults to shown. */
+    restoreVisibility(): void;
+    setVisible(visible: boolean): void;
+    private setSourceData;
+    private fitTo;
+    highlight(collection: FeatureCollection, options?: {
+        point?: boolean;
+    }): Promise<void>;
+    private showProgress;
+    /**
+     * Draw one layer as it arrives.
+     *
+     * The features are handed over repeatedly rather than once at the end, so a
+     * large feed paints steadily instead of freezing the tab and then jumping.
+     * Returns what was collected, for the caller to frame the view with.
+     */
+    private drawLayer;
+    /** Names the layers the server had to reduce, once everything is drawn. */
+    private simplificationNote;
+    /** Fetch and draw the whole feed. Skipped entirely while the map is hidden. */
+    refresh(): Promise<void>;
+    clear(): Promise<void>;
+    /**
+     * Give up the map and everything holding it.
+     *
+     * An embedded viewer is unmounted and remounted by its host - React does it
+     * twice on every mount in development - and a MapLibre instance left behind
+     * keeps a WebGL context, which browsers allow only a handful of.
+     */
+    destroy(): void;
+}

package/dist/map/redraw.d.ts

@@ -0,0 +1,29 @@
+/**
+ * When to hand a growing layer to MapLibre while it is still arriving.
+ *
+ * Its own module because vitest runs with no DOM, so anything inside
+ * `MapController` is untestable - the same constraint `Navigator.parseUrl` is
+ * written around. The schedule is the part worth testing: get it wrong and a
+ * large feed takes minutes to draw.
+ */
+/**
+ * Redraw once the layer has grown by this factor, rather than on a timer.
+ *
+ * `setData` re-serialises and re-indexes the whole collection every call, so
+ * the cost of a redraw grows with the layer. Redrawing at a fixed interval - or
+ * worse, per batch - therefore does work proportional to the square of the
+ * feature count, which is what made a quarter of a million shapes take minutes.
+ * Growth-based redrawing keeps the total proportional to the layer itself, and
+ * widens the gaps in a way that still reads as filling in.
+ *
+ * `GeoJSONSource.updateData` would remove the need for any of this, but in
+ * MapLibre 5.7 it accepts a diff and silently discards it.
+ */
+export declare const REDRAW_GROWTH_FACTOR = 2;
+/** Features worth drawing before waiting for the layer to double. */
+export declare const FIRST_REDRAW_AT = 5000;
+/**
+ * Returns a predicate: given how many features have arrived, should the layer
+ * be redrawn now? Stateful across calls, one per layer being drawn.
+ */
+export declare function createRedrawSchedule(firstAt?: number, factor?: number): (featureCount: number) => boolean;

package/dist/map-part.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The map, as a separately imported part.
+ *
+ * This is the only module that reaches MapLibre. A host that imports it wants a
+ * map and installs the peer dependency; a host that does not never mentions
+ * either, so nothing about MapLibre appears in its build.
+ */
+import type { MapPart } from "./mount";
+export declare const mapPart: MapPart;
+export type { MapPart, MapHandle } from "./mount";