@ngis/plugin-ui 0.4.0

package/dist/src/domain/map/types.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Pure data types for the map domain layer. Extracted mechanically from
+ * `SceneMapCanvas.tsx` (session C1) — no behavior change. Types re-exported
+ * from `SceneMapCanvas.tsx` are part of the frozen compat contract (see
+ * `docs/componentization_stage/README.md`); consumer import paths must not
+ * change.
+ */
+import type { LayerSpecification } from "maplibre-gl";
+import type { RasterColorLayer } from "../../lib/raster-color-layer/RasterColorLayer";
+import type { GisMeasureKind } from "../../types/gis";
+/** Measurement flavour, re-exported so rail consumers import it from one place. */
+export type SceneMeasureKind = GisMeasureKind;
+/** Map camera state — used to restore (`initialView`) and persist (`onViewChange`). */
+export interface SceneMapView {
+    center: [number, number];
+    zoom: number;
+    pitch?: number;
+    bearing?: number;
+}
+export type SceneMapCoordinate = number | SceneMapCoordinate[] | number[];
+export interface SceneMapGeometry {
+    type: string;
+    coordinates?: SceneMapCoordinate;
+    geometries?: SceneMapGeometry[];
+}
+export type SceneMapFeatureProperties = Record<string, unknown>;
+export interface SceneMapFeature {
+    type: "Feature";
+    id?: string | number;
+    geometry: SceneMapGeometry;
+    properties: SceneMapFeatureProperties;
+}
+export interface SceneMapFeatureCollection {
+    type: "FeatureCollection";
+    features: SceneMapFeature[];
+}
+export type SceneMapDrawFeatureCollection = SceneMapFeatureCollection;
+export interface SceneMapQueryableLayer {
+    sceneLayerId: string;
+    mapLayerId: string;
+    sourceId: string;
+    resourceId: string;
+    effectiveFileId: string;
+    layerName: string;
+    layerType: "fill" | "line" | "circle";
+}
+export interface SceneMapQueriedFeature {
+    id?: string | number;
+    sceneLayerId: string;
+    resourceId: string;
+    effectiveFileId: string;
+    layerName: string;
+    properties: SceneMapFeatureProperties;
+    geometry: SceneMapGeometry;
+}
+export interface SceneMapDrawQueryResult {
+    drawFeatures: SceneMapDrawFeatureCollection;
+    features: SceneMapQueriedFeature[];
+    featureCollection: SceneMapFeatureCollection;
+}
+/** A rendered raster layer at an identify click. Numeric samples require a
+ * dedicated raster-sampling service; MapLibre image tiles carry no raw cells. */
+export interface SceneMapIdentifyRasterLayer {
+    sceneLayerId: string;
+    resourceId: string;
+    effectiveFileId: string;
+    layerName: string;
+}
+/** Result of a one-point map identify operation. */
+export interface SceneMapIdentifyResult {
+    coordinate: [number, number];
+    features: SceneMapQueriedFeature[];
+    rasterLayers: SceneMapIdentifyRasterLayer[];
+}
+/**
+ * Live state of the (Terra Draw–backed) measurement overlay. Emitted on every
+ * change so the rail's contextual strip can show a running total; the on-map
+ * labels with units are rendered by `MaplibreMeasureControl` itself. `features`
+ * are the raw measure geometries (guidance vertices filtered out) — the caller
+ * derives length/area from them, keeping the geodesic math in one place.
+ */
+export interface SceneMeasureState {
+    kind: SceneMeasureKind;
+    features: SceneMapFeatureCollection;
+    finished: boolean;
+}
+export interface SceneMapHighlightFeature {
+    layer: SceneMapQueryableLayer;
+    properties: SceneMapFeatureProperties;
+}
+export type HighlightFilterExpression = unknown[];
+/** Attribute-table highlight for one scene layer. */
+export interface SceneLayerHighlight {
+    /** Scene layer id whose rendered source should be highlighted. */
+    layerId: string;
+    /** Row ids (== tile `uuid`) to mark as selected. */
+    featureIds: string[];
+    /** Highlight every feature in the layer, apart from explicit exclusions. */
+    allFeatures?: boolean;
+    /** Only meaningful with `allFeatures`; rows unchecked after select-all. */
+    excludedFeatureIds?: string[];
+}
+export type SceneLayerStyle = Record<string, unknown>;
+export type SceneLayerRenderMode = "maplibre" | "custom-raster-color" | "custom-flow-field";
+export type RenderedSceneLayer = {
+    sceneLayerId: string;
+    layerId: string;
+    sourceId: string;
+    sourceKey: string;
+    renderMode: SceneLayerRenderMode;
+    layerType: LayerSpecification["type"] | "custom";
+    paintKeys: string[];
+    layoutKeys: string[];
+    customLayer?: RasterColorLayer;
+    customInstance?: {
+        update?(input: SceneLayerStyle): boolean;
+        setVisible?(visible: boolean): void;
+        destroy?(): void;
+    };
+};
+export type ResourceBounds = [number, number, number, number];
+export type SceneTileTarget = {
+    mode: "live" | "snapshot";
+    id: string;
+};
+export type QueryableRenderedSceneLayer = RenderedSceneLayer & {
+    layerType: "fill" | "line" | "circle";
+};

package/dist/src/features/gis/components/GisAttributeTable.d.ts

@@ -0,0 +1,56 @@
+import { type DatasetAttributeSelection, type DatasetFeatureRow } from "../../../api/resources";
+/**
+ * **Exported for `@ngis/plugin-ui`'s `<AttributeTable>` (Stage 14 Y4b).** It was
+ * file-private while this component had exactly one call site
+ * (`src/features/gis/panels/registrations.tsx`). The wrapper is a second, and it
+ * derives its bridge from this declaration (`Pick<GisAttributeTableProps, …>`)
+ * rather than re-typing the callbacks — a hand-copied shape drifts the first
+ * time a prop here changes, and `tsc` would not say so. Exporting the interface
+ * is additive: no member is added, removed or retyped by that change.
+ *
+ * That bridge has already earned itself once: dropping `onClose` and adding
+ * `active` here (the tabbed bottom dock, `24c471b`) landed as a **type error in
+ * the wrapper** on the `main` merge rather than as a dead prop nobody noticed.
+ * Changing this interface is expected to break `AttributeTable.tsx` — fix it
+ * there, do not re-add a member here to keep it quiet.
+ */
+export interface GisAttributeTableProps {
+    /** Effective file id of the selected layer's resource. */
+    fileId: string;
+    layerName: string;
+    active: boolean;
+    /**
+     * Push the enumerated feature ids to highlight on the map (null clears). Only
+     * include-mode selections can be enumerated; all-matching highlight is deferred.
+     */
+    onHighlight: (featureIds: string[] | null) => void;
+    /** Mirrors each user-driven row-selection change back to the map. */
+    onSelectionChange?: (selection: GisAttributeTableSelectionHighlight | null) => void;
+    /** Materialize the current selection into a derived dataset + run-tool flow. */
+    onRunTool: (selection: DatasetAttributeSelection) => Promise<void>;
+    /** A selection made with the scene's feature-select tool, keyed by stable row id. */
+    mapSelection?: {
+        featureIds: string[];
+        /** Attribute values present in the selected vector-tile features. */
+        rows?: DatasetFeatureRow[];
+        serial: number;
+    } | null;
+}
+/** The table's complete selection meaning, forwarded to the map highlight. */
+export type GisAttributeTableSelectionHighlight = {
+    featureIds: string[];
+    allFeatures?: false;
+} | {
+    featureIds: [];
+    allFeatures: true;
+    excludedFeatureIds: string[];
+};
+/**
+ * Attribute table for the selected vector layer's dataset. Server-driven:
+ * columns from `attributes/meta`, rows lazily windowed through `attributes/query`
+ * (cursor paging + cache, via {@link useDatasetFeatureWindow}). Supports an
+ * infinite-scroll (virtualized) or paged view, server sort on sortable columns,
+ * a column picker, a filter builder, and dataset-wide selection keyed by the
+ * stable feature `id` (so it spans windows that aren't even loaded).
+ */
+export declare function GisAttributeTable({ fileId, layerName, active, onHighlight, onSelectionChange, onRunTool, mapSelection, }: GisAttributeTableProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/features/gis/hooks/useDatasetFeatureWindow.d.ts

@@ -0,0 +1,51 @@
+import { type DatasetAttributeQueryParams, type DatasetAttributeWhereOp, type DatasetFeatureRow } from "../../../api/resources";
+/** One server-side sort directive (single-column for now). */
+export interface FeatureSort {
+    field: string;
+    dir: "asc" | "desc";
+}
+/** One server-side filter condition (mirrors the query `where` clause). */
+export interface FeatureFilter {
+    field: string;
+    op: DatasetAttributeWhereOp;
+    value: unknown;
+}
+export interface DatasetFeatureWindowParams {
+    fileId: string;
+    /** Active sort (null = server default order). */
+    sort: FeatureSort | null;
+    /** Active filter conditions (AND-combined). */
+    filters: FeatureFilter[];
+    /** Columns to request (empty = all). `id` is always returned regardless. */
+    select: string[];
+    enabled?: boolean;
+}
+export interface DatasetFeatureWindow {
+    /** All rows loaded so far, in order (for infinite-scroll rendering). */
+    rows: DatasetFeatureRow[];
+    /** Loaded rows grouped by the chunk they arrived in (for paged rendering). */
+    chunks: DatasetFeatureRow[][];
+    /** Another page is available via the cursor. */
+    hasMore: boolean;
+    /** First page is loading and no rows are visible yet. */
+    loading: boolean;
+    /** A subsequent page is being appended. */
+    loadingMore: boolean;
+    error: string | null;
+    /** Append the next cursor page (no-op while loading or exhausted). */
+    loadMore: () => void;
+    /** Force a fresh reload of the current signature (drops its cache entry). */
+    reload: () => void;
+}
+/** Attribute-table page size shared by the cursor loader and its pager UI. */
+export declare const DATASET_FEATURE_WINDOW_CHUNK_SIZE = 100;
+export declare function buildFeatureQueryParams(params: DatasetFeatureWindowParams, cursor: string | null): DatasetAttributeQueryParams;
+/**
+ * Cursor-windowed loader for a vector dataset's features. Loads fixed-size
+ * chunks sequentially via `attributes/query` (cursor paging), keeps them in
+ * order, and caches the loaded window per query signature (sort + filter +
+ * select) with a small LRU so toggling a filter back is instant. Changing the
+ * signature resets the window — sorting/filtering reorders the whole dataset,
+ * so prior chunks no longer apply.
+ */
+export declare function useDatasetFeatureWindow(params: DatasetFeatureWindowParams): DatasetFeatureWindow;

package/dist/src/lib/api-error.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The one place a client extracts a server-supplied message from an `ApiError`.
+ *
+ * **F14.15 froze this function's signature and its resolution order at W0 and no
+ * session owned it.** YB2 landed the backend half in W1 — `include-message:
+ * always` in `ngis-workflow` and `ngis-extension` — so those two services now put
+ * real messages on the wire. Nothing on the client ever read them: a repo-wide
+ * grep at the W4 kickoff found no `readApiErrorMessage` anywhere, and the
+ * prevailing idiom is `err instanceof Error ? err.message : t("failed")`, which
+ * renders the *transport's* message ("HTTP 400") rather than the server's.
+ *
+ * It is authored at the **W4 kickoff** rather than assigned to a session because
+ * both W4 sessions need it and neither owns the other's copy:
+ *
+ *   - **Y6** — every nested-recipe refusal is a `BizException` from
+ *     `ngis-workflow` whose whole content is its message: depth (400), cycle
+ *     (409), discriminator ambiguity (400), `"input slot <key> is missing
+ *     bindInputKey"` (400), `"at least one output slot is required"` (400). F14.6
+ *     says in as many words that nested recipes are an F14.15-dependent feature,
+ *     and `ExtensionKindReferenceValidator`'s messages are the reference-version
+ *     wizard's only diagnostics.
+ *   - **Y7** — a batch row that fails must show *why* on that row. A failed row
+ *     does not cancel the rest (F14.21), so the message is the only per-row
+ *     signal there is.
+ *
+ * Two copies of this would be the W2 `primaryOutput` lesson repeated at wave
+ * scale, and the disagreement would be invisible: both would return *a* string.
+ */
+import { ApiError } from "./api";
+/**
+ * Extract the server's message from an `ApiError`, or `null` when it carried
+ * none. **The caller renders a generic host string on `null` — never an empty
+ * toast** (F14.15).
+ *
+ * Resolution order, first non-blank wins:
+ *
+ *   1. `body.detail` — FastAPI (`ngis-geoanalysis`, `ngis-geoprocess`, `ngis-ai`,
+ *      `ngis-tile`, `ngis-mcp`). A `detail` that is an *array* is FastAPI's
+ *      422 validation shape and is deliberately **not** joined here — it is
+ *      structured per-field data, and `asSkillPackageValidationError` is the
+ *      precedent for narrowing it at the call site.
+ *   2. `body.errors[]` — field-level binding errors, joined — **but only when `message` is
+ *      Spring's generic validation preamble**, which names no field and is the same sentence for
+ *      every rejected body. See {@link isGenericValidationPreamble}.
+ *   3. `body.message` — Spring with `include-message: always` (`ngis-workflow`,
+ *      `ngis-extension` after YB2).
+ *   4. `body.error` — the `BizException` advices (`ngis-workflow`, `ngis-file`,
+ *      `ngis-geocanvas`, `ngis-scene`, `ngis-codeenv`) — **but only when it does
+ *      not equal the HTTP reason phrase for the status.** In the advice shape
+ *      `error` is the human message; in Spring's default shape the same key is
+ *      literally `"Bad Request"`. Without the guard a client renders the reason
+ *      phrase as though it were a validation message, which is worse than
+ *      rendering nothing: it looks like an answer.
+ *   5. `body.errors[]` — for a body that carried them beside a *specific* message.
+ *   6. `null`.
+ *
+ * **Step 2 is `V-374`, and it is the whole reason `joinBindingErrors` was reachable
+ * from nowhere.** With `include-binding-errors: always`, Spring sends *both* a
+ * generic `message` — `"Validation failed for object='createExtensionRequest'.
+ * Error count: 2"` — and an `errors[]` array carrying the field names. The generic
+ * message is non-blank, so it won step 3 every time and `joinBindingErrors`, which
+ * exists and is correct and would have rendered *"version: must not be blank;
+ * minNgisVersion: must not be blank"*, was never reached. **The field names reached
+ * the wire and the client discarded them one layer above it**, which is F-1's own
+ * failure mode repeated inside the fix for F-1. The guard is deliberately narrow:
+ * it fires only on Spring's own preamble, so a service that sends a real sentence
+ * beside `errors[]` still wins at step 3.
+ *
+ * `error.message` — the transport's own string — is **never** consulted. It is
+ * synthesized by `handleResponse` and saying "HTTP 400" where the server said
+ * "at least one output slot is required" is the defect this function exists to
+ * remove.
+ */
+export declare function readApiErrorMessage(error: ApiError): string | null;
+/**
+ * The same read for an `unknown` caught value — the shape a `catch` block
+ * actually has. Returns `null` for anything that is not an `ApiError`, so a
+ * caller still needs its own fallback; this only saves the `instanceof` dance at
+ * the dozens of call sites that would otherwise each write it.
+ */
+export declare function readServerMessage(error: unknown): string | null;

package/dist/src/lib/api.d.ts

@@ -0,0 +1,82 @@
+export declare const GATEWAY_ORIGIN: string;
+export declare const SERVER_GATEWAY_ORIGIN: string;
+export declare const API_BASE_URL: string;
+export declare const WS_BASE_URL: string;
+export interface CommonResult<T = unknown> {
+    code: number;
+    message: string;
+    data: T;
+    traceId?: string | null;
+    details?: unknown;
+}
+export type ApiResponse<T> = CommonResult<T>;
+export interface ApiRequestOptions {
+    signal?: AbortSignal;
+    headers?: HeadersInit;
+}
+export declare class ApiError extends Error {
+    code: number;
+    traceId?: string | null;
+    /**
+     * The parsed error payload, **verbatim**, or `null` when the body was absent
+     * or not JSON.
+     *
+     * Deliberately **not** named `detail` (Stage 12 W2.2): FastAPI's error body
+     * *contains* a `detail` key, while the Java services put a `CommonResult`
+     * envelope in exactly the same position. One field carries both, and callers
+     * narrow it themselves — see `asSkillPackageValidationError` in
+     * `src/api/skills.ts` for the structured-422 case this exists for.
+     *
+     * `unknown` on purpose: nothing may read a property off it without a guard.
+     */
+    body?: unknown;
+    constructor(message: string, code: number, traceId?: string | null, body?: unknown);
+}
+export declare function getErrorMessage(err: unknown, t: (key: string) => string): string;
+/** Called after login/refresh with the new `{accessToken, csrfToken}` pair. */
+export declare function setSession(accessToken: string, csrfToken: string): void;
+/** Drops the in-memory session (logout / session-expired). Does not touch the server-side cookie. */
+export declare function clearSession(): void;
+/**
+ * Silent-refresh bootstrap (SG2): call once on app startup (see `AuthProvider`) to re-derive an
+ * in-memory access token from the HttpOnly refresh cookie, since memory doesn't survive a page
+ * reload. Returns whether a session was recovered; failure (no cookie / expired) just means
+ * "not logged in" and is never surfaced as an error.
+ */
+export declare function bootstrapSession(): Promise<boolean>;
+export declare function getAccessToken(): string | null;
+export declare function getAccessTokenSubject(): string | null;
+export declare function getAuthHeaders(token?: string): HeadersInit;
+export declare function fetchWithAuth(input: string, init?: RequestInit, token?: string): Promise<Response>;
+/**
+ * Mints a short-lived, single-use WebSocket handshake ticket (SG2) via the authenticated
+ * `POST /api/auth/ws-ticket`. Call this immediately before opening the socket — the ticket
+ * expires quickly (`expiresInSec`, ~30s) and is consumed on first use, so don't cache the result.
+ */
+export declare function getWsTicket(): Promise<string | null>;
+/**
+ * Builds an authenticated WS URL (SG2). Replaces the previous `?token=<JWT>` pattern — which
+ * leaked the access token into server logs/browser history/referrers and, on the backend side,
+ * was never even validated — with a single-use `?ticket=` minted right before connecting. Async:
+ * returns `null` if minting the ticket fails (e.g. not authenticated), in which case the caller
+ * should not attempt to open the socket.
+ */
+export declare function buildAuthorizedWsUrl(path: string, params?: Record<string, string | undefined | null>): Promise<string | null>;
+export declare function buildAuthorizedApiUrl(input: string, params?: Record<string, string | undefined | null>): string;
+/**
+ * CSRF-aware POST for the `/api/auth/**` endpoints that require the double-submit header
+ * (SG2: `refresh`/`logout`) — kept out of the generic `api` client below since no other
+ * endpoint needs it. Auth/token state stays owned by this file per the architecture rule.
+ */
+export declare function postAuthCsrf<T>(endpoint: string, body?: unknown, options?: {
+    readonly keepalive?: boolean;
+}): Promise<T>;
+export declare const api: {
+    get<T>(endpoint: string, params?: Record<string, unknown>, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    post<T>(endpoint: string, body?: unknown, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    postForm<T>(endpoint: string, formData: FormData, token?: string, signal?: AbortSignal): Promise<T>;
+    put<T>(endpoint: string, body: unknown, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    patch<T>(endpoint: string, body: unknown, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    delete<T>(endpoint: string, token?: string, signalOrOptions?: AbortSignal | ApiRequestOptions): Promise<T>;
+    deleteWithBody<T>(endpoint: string, body: unknown, token?: string, signal?: AbortSignal): Promise<T>;
+};

package/dist/src/lib/auth-session.d.ts

@@ -0,0 +1,22 @@
+export declare const SESSION_EXPIRED_EVENT = "glmw:session-expired";
+export declare const SESSION_EXPIRED_REDIRECT_PATH = "/login";
+/** The minimal user profile we persist alongside the session. Not sensitive — no tokens here. */
+export interface StoredUser {
+    id?: string;
+    email?: string;
+    username?: string;
+    avatar?: string;
+    role?: string;
+}
+export declare function getStoredDeviceId(): string;
+/**
+ * SG2: only the display profile is cached here now — no tokens. `src/lib/api.ts` owns the
+ * actual session (in-memory access token + CSRF token, backed by the HttpOnly refresh cookie).
+ */
+export declare function storeUser(user: StoredUser | null): void;
+export declare function getStoredUser(): StoredUser | null;
+/** Bumps the cross-tab auth-epoch marker — call on login/logout so other tabs re-hydrate. */
+export declare function bumpAuthEpoch(): void;
+/** True if a `storage` event's key is the auth-epoch marker (vs. some unrelated key). */
+export declare function isAuthEpochKey(key: string | null): boolean;
+export declare function notifySessionExpired(): void;

package/dist/src/lib/hooks/useColumnResize.d.ts

@@ -0,0 +1,57 @@
+import type { PointerEvent as ReactPointerEvent } from "react";
+/**
+ * The attribute in `[data-column-cell]` form. A resize handle finds the box it
+ * is sizing by walking up to the nearest element carrying it, so a flexible
+ * (`1fr`) column can be measured on screen instead of guessed.
+ */
+export declare const COLUMN_CELL_SELECTOR = "[data-column-cell]";
+/** How far one arrow-key press moves a boundary. */
+declare const KEYBOARD_STEP = 16;
+/** One resizable column's sizing contract. */
+export interface ResizableColumn {
+    id: string;
+    /** Hard floor in px — no drag or nudge may take the column below it. */
+    min: number;
+    /**
+     * Starting width in px. Omit to let the column absorb leftover space
+     * (`minmax(min, 1fr)`) until its first drag, after which it is pinned.
+     */
+    initial?: number;
+    /** Ceiling in px (defaults to 960). */
+    max?: number;
+}
+export interface ColumnResizeApi {
+    /** Pinned width in px, or null while the column is still flexible. */
+    widthOf: (id: string) => number | null;
+    /** A `grid-template-columns` track list for `ids` (default: every column). */
+    template: (ids?: string[]) => string;
+    /** Sum of the current widths, flexible columns counted at their minimum. */
+    minTotal: number;
+    /** The column currently being dragged, for handle affordances. */
+    resizingId: string | null;
+    startResize: (id: string, event: ReactPointerEvent<HTMLElement>) => void;
+    /**
+     * Resize the boundary between two adjacent columns while keeping their
+     * combined width stable. The first column grows to the right; the second
+     * column yields the same amount, subject to both columns' bounds.
+     */
+    startAdjacentResize: (id: string, nextId: string, event: ReactPointerEvent<HTMLElement>) => void;
+    /** Keyboard counterpart of {@link startAdjacentResize}. */
+    nudgeAdjacent: (id: string, nextId: string, deltaPx: number, from?: HTMLElement | null) => void;
+    /** Keyboard resize; `from` is any node inside the column being sized. */
+    nudge: (id: string, deltaPx: number, from?: HTMLElement | null) => void;
+    /** Drop one column's pinned width, or every column's when called bare. */
+    reset: (id?: string) => void;
+}
+/**
+ * Column-width state for a table the user can resize by dragging the boundary
+ * in its header. Layout-agnostic: {@link ColumnResizeApi.template} drives a CSS
+ * grid, {@link ColumnResizeApi.widthOf} drives a `<colgroup>` under
+ * `table-fixed`. Widths live in React state (per mount) — nothing is persisted.
+ *
+ * A drag listens on `window` rather than capturing the pointer, so releasing
+ * outside the viewport still ends it, and the listeners are torn down on
+ * unmount. `columns` should be memoized by the caller; only its contents matter.
+ */
+export declare function useColumnResize(columns: ResizableColumn[]): ColumnResizeApi;
+export { KEYBOARD_STEP as COLUMN_RESIZE_STEP };

package/dist/src/lib/raster-color-layer/RasterColorLayer.d.ts

@@ -0,0 +1,48 @@
+import type { CustomLayerInterface, CustomRenderMethodInput, Map as MapLibreMap } from "maplibre-gl";
+import { type TileBounds, type TileRequestInitFactory } from "./TileGrid";
+import { type ColorStop, type RasterColorMode } from "./colorRamp";
+import { type ZoomStop } from "./zoomInterpolate";
+export type RasterColorLayerOptions = {
+    urlTemplate: string;
+    maxZoom: number;
+    mix: [number, number, number, number];
+    range: [number, number];
+    ramp: ColorStop[];
+    colorMode?: RasterColorMode;
+    classBreaks?: number[];
+    valueRange?: [number, number];
+    opacity: number | ZoomStop[];
+    visibleZoomRange?: [number, number];
+    bounds?: TileBounds;
+    getRequestInit?: TileRequestInitFactory;
+};
+export declare function getRasterProjectionMatrix(options: Pick<CustomRenderMethodInput, "defaultProjectionData">): import("maplibre-gl").ProjectionMatrix;
+export declare class RasterColorLayer implements CustomLayerInterface {
+    id: string;
+    type: "custom";
+    renderingMode: "2d";
+    private opts;
+    private map;
+    private gl;
+    private program;
+    private quadBuffer;
+    private tileGrid;
+    private rampTexture;
+    private rampDirty;
+    private uniforms;
+    private attribs;
+    constructor(id: string, options: RasterColorLayerOptions);
+    onAdd(map: MapLibreMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    setColorStyle(options: {
+        ramp: ColorStop[];
+        colorMode?: RasterColorMode;
+        classBreaks?: number[];
+        valueRange?: [number, number];
+    }): void;
+    setRange(range: [number, number]): void;
+    setOpacity(opacity: number | ZoomStop[]): void;
+    setVisibleZoomRange(range: [number, number]): void;
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, options: CustomRenderMethodInput): void;
+    onRemove(): void;
+    private ensureRampTexture;
+}

package/dist/src/lib/raster-color-layer/TileGrid.d.ts

@@ -0,0 +1,31 @@
+export type TileId = {
+    z: number;
+    x: number;
+    y: number;
+};
+export type TileBounds = [number, number, number, number];
+export type TileRequestInitFactory = () => RequestInit | undefined;
+export declare class TileGrid {
+    private gl;
+    private urlTemplate;
+    private maxZoom;
+    private onTileLoaded;
+    private getRequestInit?;
+    private bounds?;
+    private cache;
+    private queue;
+    private activeRequests;
+    private destroyed;
+    private frame;
+    private readonly maxCacheSize;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, urlTemplate: string, maxZoom: number, onTileLoaded: () => void, getRequestInit?: TileRequestInitFactory | undefined, bounds?: TileBounds | undefined);
+    coveringTiles(west: number, south: number, east: number, north: number, zoom: number): TileId[];
+    ensure(tiles: TileId[]): void;
+    getTexture(tile: TileId): WebGLTexture | null;
+    private fetchTile;
+    private pumpQueue;
+    private scheduleRetry;
+    private evictIfNeeded;
+    private disposeEntry;
+    destroy(): void;
+}

package/dist/src/lib/raster-color-layer/colorRamp.d.ts

@@ -0,0 +1,18 @@
+export type ColorStop = {
+    stop: number;
+    color: [number, number, number, number];
+};
+export type RasterColorMode = "continuous" | "classified";
+export type RasterClassificationMethod = "equal-interval" | "manual";
+export declare function buildColorRampData(stops: ColorStop[], resolution?: number): Uint8Array<ArrayBuffer>;
+export declare function isValidClassBreaks(value: unknown, range?: [number, number], colorCount?: number): value is number[];
+export declare function buildEqualIntervalBreaks(min: number, max: number, classCount: number): number[] | null;
+export declare function normalizeClassBreaks(classBreaks: unknown, range: [number, number], colorCount?: number): number[] | null;
+export declare function buildClassifiedColorRampData(stops: ColorStop[], classBreaks: unknown, range: [number, number], resolution?: number): Uint8Array<ArrayBuffer> | null;
+export declare function buildRasterColorRampData(stops: ColorStop[], options?: {
+    colorMode?: RasterColorMode;
+    classBreaks?: unknown;
+    valueRange?: [number, number];
+}, resolution?: number): Uint8Array<ArrayBuffer>;
+export declare function computeRasterColorMix(colorRampRes: number, mix: [number, number, number, number], range: [number, number]): [number, number, number, number];
+export declare function computeRasterColorOffset(colorRampRes: number, offset: number, range: [number, number]): number;

package/dist/src/lib/raster-color-layer/shaders/raster-color.frag.d.ts

@@ -0,0 +1,2 @@
+declare const fragSrc = "\nprecision mediump float;\n\nuniform sampler2D u_tile;\nuniform sampler2D u_color_ramp;\nuniform vec3 u_colorization_mix;\nuniform float u_colorization_offset;\nuniform float u_opacity;\n\nvarying vec2 v_uv;\n\nvoid main() {\n  vec4 c = texture2D(u_tile, v_uv);\n\n  float value = u_colorization_offset + dot(c.rgb, u_colorization_mix);\n  vec4 ramped = texture2D(u_color_ramp, vec2(value, 0.5));\n\n  if (ramped.a > 0.0) ramped.rgb /= ramped.a;\n\n  float alpha = ramped.a * u_opacity * c.a;\n  gl_FragColor = vec4(ramped.rgb * alpha, alpha);\n}\n";
+export default fragSrc;

package/dist/src/lib/raster-color-layer/shaders/raster-color.vert.d.ts

@@ -0,0 +1,2 @@
+declare const vertSrc = "\nattribute vec2 a_pos;\n\nuniform mat4 u_matrix;\nuniform vec2 u_tile_tl;\nuniform vec2 u_tile_scale;\n\nvarying vec2 v_uv;\n\nvoid main() {\n  v_uv = a_pos;\n  vec2 mercator = u_tile_tl + a_pos * u_tile_scale;\n  gl_Position = u_matrix * vec4(mercator, 0.0, 1.0);\n}\n";
+export default vertSrc;

package/dist/src/lib/raster-color-layer/zoomInterpolate.d.ts

@@ -0,0 +1,2 @@
+export type ZoomStop = [zoom: number, value: number];
+export declare function resolveZoomStops(value: number | ZoomStop[], zoom: number): number;

package/dist/src/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;