@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/api/extension/render.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Drawing: the renderers of custom feature types and overlays, the values they draw with,
+ * and the shared renderers they can draw through
+ */
+import type { Position } from 'geojson';
+import type { Map as MaplibreMap, ProjectionData } from 'maplibre-gl';
+import type { Feature, LineStyle, PointShape } from '../model.js';
+import type { TerrainAnchors } from './context.js';
+/**
+ * The shader prelude the map passes to a custom layer, for compiling programs for the current
+ * projection.
+ */
+export interface ShaderData {
+    /** The GLSL the map prepends to a vertex shader (its projection functions) */
+    vertexShaderPrelude: string;
+    /** The `#define` lines of the current projection */
+    define: string;
+    /** The name of the projection variant; a program is compiled again when it changes */
+    variantName: string;
+}
+/**
+ * The values for drawing positions relative to the center of the view, which keeps the
+ * precision of 32-bit floats near the camera.
+ */
+export interface OffsetUniforms {
+    /** The center, rounded to 32-bit floats for the shader */
+    centerLngLat: [number, number];
+    /** The center at 64-bit precision, for the offsets computed on the CPU */
+    centerLngLat64: [number, number];
+    /** The Mercator coordinates of the center, at 64-bit precision */
+    centerMercator: [number, number];
+    /** The center of the view in clip space, at 64-bit precision */
+    projectionCenter: [number, number, number, number];
+    /** The Mercator units per degree of longitude and latitude at the center */
+    unitsPerDegree: [number, number, number];
+    /** The second-order correction of `unitsPerDegree` for the change with latitude */
+    unitsPerDegree2: [number, number, number];
+}
+/**
+ * The shared renderer of lines. It only draws; the zoom, the projection and the terrain come
+ * from the {@link RenderContext} it was taken from.
+ */
+export interface LineRenderer {
+    /**
+     * Draws a line.
+     *
+     * @param coordinates - The positions of the line
+     * @param style - The width in pixels, the CSS color, the opacity from 0 to 1, the dash
+     *   pattern, and a custom `[dash, gap]` in pixels
+     * @param options - `closed` joins the last position to the first; `widthUnit` says whether
+     *   the width is in pixels or meters; `createdZoom` is the zoom at which the width applies,
+     *   so that the line grows and shrinks with the zoom
+     */
+    draw(coordinates: readonly Position[], style: {
+        width: number;
+        color: string;
+        opacity: number;
+        lineStyle: LineStyle;
+        dashArray?: number[];
+    }, options?: {
+        closed?: boolean;
+        widthUnit?: 'pixels' | 'meters';
+        createdZoom?: number;
+    }): void;
+}
+/**
+ * The shared renderer of areas. It only draws; the zoom, the projection and the terrain come
+ * from the {@link RenderContext} it was taken from.
+ */
+export interface FillRenderer {
+    /**
+     * Fills an area.
+     *
+     * @param rings - The outer ring first, then the holes
+     * @param style - The CSS color and the opacity from 0 to 1
+     */
+    draw(rings: readonly (readonly Position[])[], style: {
+        color: string;
+        opacity: number;
+    }): void;
+}
+/**
+ * The shared renderer of point markers. It only draws; the zoom, the projection and the
+ * terrain come from the {@link RenderContext} it was taken from.
+ */
+export interface PointRenderer {
+    /**
+     * Draws a point marker.
+     *
+     * @param position - The position
+     * @param style - The shape, the size in pixels, the fill and the outline (CSS colors,
+     *   opacities from 0 to 1, the outline width in pixels)
+     * @param options - `elevationMeters` places the marker at this height instead of on the
+     *   ground
+     */
+    draw(position: Position, style: {
+        shape: PointShape;
+        size: number;
+        fillColor: string;
+        fillOpacity: number;
+        strokeColor: string;
+        strokeWidth: number;
+        strokeOpacity: number;
+    }, options?: {
+        elevationMeters?: number;
+    }): void;
+}
+/**
+ * Everything a renderer needs to draw a frame. The offsets are already computed.
+ */
+export interface RenderContext {
+    /** The WebGL context of the map */
+    readonly gl: WebGL2RenderingContext;
+    /** The shader prelude of the current projection */
+    readonly shader: ShaderData;
+    /** The values for drawing relative to the center of the view */
+    readonly offset: OffsetUniforms;
+    /** The projection of the frame, as the map passes it to a custom layer */
+    readonly projection: ProjectionData;
+    /** The zoom of the frame */
+    readonly zoom: number;
+    /** The pixel ratio of the drawing */
+    readonly pixelRatio: number;
+    /** The opacity of the layer being drawn, from 0 to 1 */
+    readonly opacity: number;
+    /**
+     * The positions and the heights on the terrain. The building blocks of the `/webgl` entry
+     * that draw on the terrain take it, or the whole render context.
+     */
+    readonly terrain: TerrainAnchors;
+    /** The shared renderer of lines */
+    readonly line: LineRenderer;
+    /** The shared renderer of areas */
+    readonly fill: FillRenderer;
+    /** The shared renderer of point markers */
+    readonly point: PointRenderer;
+}
+/**
+ * How the features of a custom type are drawn. The methods take their arguments in the order
+ * of a custom layer of the map.
+ */
+export interface FeatureRenderer {
+    /** Called when the renderer is added to the map; create the programs and buffers here. */
+    onAdd(map: MaplibreMap, gl: WebGL2RenderingContext): void;
+    /** Draws one feature. */
+    draw(feature: Feature, ctx: RenderContext): void;
+    /** Called when the renderer is removed; release what `onAdd` created. */
+    onRemove(map: MaplibreMap, gl: WebGL2RenderingContext): void;
+}
+/**
+ * A renderer that draws above the features, or between the layers.
+ */
+export interface OverlayRenderer {
+    /** The name it is registered under */
+    readonly name: string;
+    /**
+     * The order among the overlays: a lower one is drawn first, below a higher one. Overlays of
+     * the same order are drawn in the order they were added; 0 when it is left out.
+     */
+    readonly order?: number;
+    /** Called when the renderer is added to the map; create the programs and buffers here. */
+    onAdd(map: MaplibreMap, gl: WebGL2RenderingContext): void;
+    /** Draws above every layer. */
+    draw(ctx: RenderContext): void;
+    /** Draws just above one layer, for an overlay drawn between the layers. */
+    drawForLayer?(layerId: string, ctx: RenderContext): void;
+    /**
+     * Draws the vertices of what the overlay shows, above the features of every layer and the
+     * selection, so that they stay visible over a layer further back.
+     */
+    drawVertices?(ctx: RenderContext): void;
+    /** Whether some of its drawing has not finished yet. */
+    hasPendingWork?(): boolean;
+    /** Called when the renderer is removed; release what `onAdd` created. */
+    onRemove(map: MaplibreMap, gl: WebGL2RenderingContext): void;
+}

package/dist/api/extension/render.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/api/extension/store.d.ts

@@ -0,0 +1,190 @@
+/**
+ * The Store: where the document and the state of this client are kept
+ *
+ * The built-in Store keeps them in memory. An application replaces it through the `store`
+ * option of `createDraw`, for example to keep the document somewhere shared.
+ */
+import type { DocumentChange } from '../events.js';
+import type { Feature, FileData, Group, Layer, Metadata } from '../model.js';
+import type { Mode, Selection, SelectionType, VertexSelection } from '../state.js';
+/**
+ * Where a write came from, as it arrives in {@link DocumentChange.source} and in the `source` of
+ * the events.
+ *
+ * - `local`: an operation of the user or a call of the API (the default)
+ * - `silent`: a change that a subscriber recording changes leaves out, such as the selection a
+ *   drawing mode clears as it is entered
+ * - `load`: a load of any format (`document.load`, `document.loadMany`), with the replacement
+ *   of `mode: 'replace'`, in one transaction
+ * - `batch`: a bulk change of an application or an extension recorded as one step; the
+ *   library does not write it
+ * - `remote`: a change a replaced Store applies from outside the instance
+ * - `import`: data an application or an extension loads by its own means
+ *
+ * Any other string can be used by an extension or a Store for the changes it applies itself.
+ */
+export type UpdateSource = 'local' | 'silent' | 'load' | 'batch' | 'remote' | 'import' | (string & Record<never, never>);
+/**
+ * The read side of the Store: the document, the state of this client, and the subscription
+ * to their changes.
+ *
+ * What it returns and notifies keeps these rules:
+ *
+ * - Returned objects are never changed afterwards. Callers treat what a getter returns or a
+ *   notification carries as read-only, and the Store never changes such an object: a change
+ *   stores a new object.
+ * - The stacking order (`getLayerOrder()`) is part of the document. It may hold entries that
+ *   are not layers (a dataset with `order: 'layer-order'`, a separator of the application),
+ *   and its entries are distinct non-empty strings.
+ * - One notification per outermost transaction: `subscribe` delivers one `DocumentChange`
+ *   per outermost `transact` (or per write outside one), with its `source`. The transactions
+ *   inside another fold into the outermost one.
+ * - A replacement of the whole document is one `DocumentChange`. A load that replaces the
+ *   document in one `transact` arrives as one change; a document the Store takes from
+ *   elsewhere in one step arrives as one change with `reset: true`, which lists what was
+ *   replaced.
+ * - A write of the selection, the editing or the mode is notified with its category; a write
+ *   of the vertex selection, read-only, the interaction lock or the hidden items may be
+ *   notified with no category.
+ * - A change applied from outside the instance is notified like a local one, with the source
+ *   `'remote'`. The instance follows it: a deleted item leaves the selection, the editing and
+ *   the hidden items through the writes of {@link Store}.
+ * - An optional field (`Feature.groupId`, `Layer.metadata`, `Layer.styleRule`) may be given as
+ *   `null`: null is accepted and read as `undefined`, so the instance and its API always hand
+ *   out `undefined` for it.
+ * - The state of this client (the selection, the editing, the selected vertices, the mode,
+ *   read-only, the interaction lock and the hidden items) is not part of the document: it is
+ *   not saved, and a change from outside the instance does not carry it.
+ */
+export interface StoreView {
+    /** A feature by ID, or `undefined` */
+    getFeature(id: string): Feature | undefined;
+    /** Every feature, in no particular order */
+    listFeatures(): Feature[];
+    /** Every feature in stacking order, from the back */
+    listFeaturesInOrder(): Feature[];
+    /** A layer by ID, or `undefined` */
+    getLayer(id: string): Layer | undefined;
+    /** Every layer, in no particular order */
+    listLayers(): Layer[];
+    /** The stacking order, from the back: the layers and the entries from outside the document */
+    getLayerOrder(): readonly string[];
+    /** A group by ID, or `undefined` */
+    getGroup(id: string): Group | undefined;
+    /** Every group */
+    listGroups(): Group[];
+    /** An embedded file by ID, or `undefined` */
+    getFile(id: string): FileData | undefined;
+    /** Every embedded file */
+    listFiles(): FileData[];
+    /** The title and the description */
+    getMetadata(): Metadata;
+    /** The selection of this client */
+    getSelection(): Selection;
+    /** The IDs of the features being edited */
+    getEditingIds(): readonly string[];
+    /** The selected vertices, or `null` */
+    getVertexSelection(): VertexSelection | null;
+    /** The current mode */
+    getMode(): Mode;
+    /** Whether the document is read-only */
+    isReadOnly(): boolean;
+    /** Whether the interaction lock is on */
+    isInteractionLocked(): boolean;
+    /** Whether this client hides the item */
+    isHidden(id: string): boolean;
+    /** The IDs this client hides */
+    listHidden(): ReadonlySet<string>;
+    /**
+     * Subscribes to the changes; one notification arrives per outermost transaction.
+     *
+     * @returns The function that unsubscribes
+     */
+    subscribe(listener: (changes: DocumentChange) => void): () => void;
+    /**
+     * Runs `fn` as one transaction, so that its writes arrive as one notification.
+     *
+     * @returns What `fn` returns
+     */
+    transact<T>(fn: () => T, source?: UpdateSource): T;
+}
+/**
+ * The Store with its writes: what the `store` option of `createDraw` takes.
+ *
+ * The instance reads and writes the document and the state of this client only through these
+ * methods, subscribes to it and groups its writes with `transact`. The shape being drawn, the
+ * box selection and the drag stay in the instance. A Store keeps the rules of
+ * {@link StoreView} and these:
+ *
+ * - Unique IDs: the IDs of features and groups are unique together (both are listed in
+ *   `Layer.items`), the IDs of layers are unique, and so are the IDs of files. A write that
+ *   would take an ID in use does not apply.
+ * - `Layer.items` is consistent: every feature is listed in exactly one container, in
+ *   `Group.featureIds` of its group when it has `groupId`, otherwise in `Layer.items` of its
+ *   layer, and every group is listed in `Layer.items` of one layer. The writes keep it so: a
+ *   new feature or group is listed, a deleted one is taken out, a change of `layerId` or
+ *   `groupId` moves the feature, and a group whose last member leaves is deleted.
+ * - `Group.layerId` is maintained by the Store: it is always the layer whose `items` list the
+ *   group.
+ * - The stacking order: `createLayer` adds the new layer at the front unless the order
+ *   already holds it, `deleteLayer` takes it out, and no other write adds or removes entries.
+ * - Writes return whether they were applied: a write of the document returns true when it
+ *   changed the Store, and false when it was refused, changing nothing. A write whose
+ *   argument cannot apply (an ID that names nothing) may throw instead, storing nothing.
+ * - Read-only refusals: the instance does not call the writes of the document while
+ *   `isReadOnly()` is true, and a Store may refuse them then (and for reasons of its own) by
+ *   returning false. The interaction lock does not stop any write. The writes of the state of
+ *   this client return nothing: the instance takes them as applied.
+ */
+export interface Store extends StoreView {
+    /** Creates a feature. */
+    createFeature(feature: Feature): boolean;
+    /** Changes the fields given of a feature; `isIntermediate` marks an edit in progress. */
+    updateFeature(id: string, updates: Partial<Feature>, options?: {
+        isIntermediate?: boolean;
+    }): boolean;
+    /** Drops the intermediate updates of these features that were not followed by a final one. */
+    abortIntermediateUpdates?(ids: string[]): void;
+    /** Deletes a feature. */
+    deleteFeature(id: string): boolean;
+    /** Creates a layer. */
+    createLayer(layer: Layer): boolean;
+    /** Changes the fields given of a layer. */
+    updateLayer(id: string, updates: Partial<Layer>): boolean;
+    /** Deletes a layer. */
+    deleteLayer(id: string): boolean;
+    /** Replaces the stacking order. */
+    setLayerOrder(order: string[]): boolean;
+    /** Moves an item to a position within a layer. */
+    reorderInLayer(itemId: string, layerId: string, newIndex: number): boolean;
+    /** Moves a feature to a position within a group. */
+    reorderInGroup(featureId: string, groupId: string, newIndex: number): boolean;
+    /** Creates a group. */
+    createGroup(group: Group): boolean;
+    /** Changes the fields given of a group. */
+    updateGroup(id: string, updates: Partial<Group>): boolean;
+    /** Deletes a group. */
+    deleteGroup(id: string): boolean;
+    /** Adds an embedded file. */
+    createFile(file: FileData): boolean;
+    /** Deletes an embedded file. */
+    deleteFile(id: string): boolean;
+    /** Changes the fields given of the metadata. */
+    setMetadata(metadata: Partial<Metadata>): boolean;
+    /** Replaces the selection of this client. */
+    setSelection(type: SelectionType | null, ids: string[]): void;
+    /** Marks features as being edited. */
+    startEditing(ids: string[]): void;
+    /** Marks features as no longer being edited. */
+    endEditing(ids: string[]): void;
+    /** Replaces the selected vertices. */
+    setSelectedVertices(selection: VertexSelection | null): void;
+    /** Replaces the mode. */
+    setMode(mode: Mode): void;
+    /** Turns read-only on or off. */
+    setReadOnly(value: boolean): void;
+    /** Turns the interaction lock on or off. */
+    setInteractionLock(value: boolean): void;
+    /** Hides or shows an item in this client. */
+    setLocallyHidden(id: string, hidden: boolean): void;
+}

package/dist/api/extension/store.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/api/extensions.d.ts

@@ -0,0 +1,306 @@
+/**
+ * `draw.extensions`: the collections of plugins, modes, feature types, overlays and providers
+ *
+ * Every kind of extension is added the same way: `add` registers it and returns the function
+ * that removes it, and `remove(name)` removes it by name.
+ */
+import type { FeatureTypeDefinition } from './extension/feature-type.js';
+import type { ModeFactory } from './extension/mode.js';
+import type { Plugin } from './extension/plugin.js';
+import type { CompanionProvider, HandleProvider, SnapProvider } from './extension/provider.js';
+import type { OverlayRenderer } from './extension/render.js';
+/** The plugins, in the order they were added. */
+export interface PluginsCollection {
+    /**
+     * Gets a plugin by name.
+     *
+     * @returns The plugin, or `undefined` when there is none with this name
+     */
+    get(name: string): Plugin | undefined;
+    /** Lists the plugins in the order they were added. */
+    list(): Plugin[];
+    /** Counts the plugins. */
+    count(): number;
+    /** Whether a plugin with this name was added. */
+    has(name: string): boolean;
+    /**
+     * Adds a plugin.
+     *
+     * @returns The function that removes it again
+     * @throws `DrawError` with the code `already-exists` when a plugin with the same name was
+     *   added
+     *   or with `invalid-input` when the value does not have the shape of the contract
+     */
+    add(plugin: Plugin): () => void;
+    /**
+     * Adds several plugins in one transaction: all of them or none.
+     *
+     * @returns The function that removes them again
+     * @throws `DrawError` with the code `already-exists` when one of the names is taken, or
+     *   `invalid-input` when a value does not have the shape of the contract; nothing is added
+     *   then
+     */
+    addMany(plugins: readonly Plugin[]): () => void;
+    /**
+     * Removes a plugin, with everything it added.
+     *
+     * @returns True when it was removed
+     * @throws `DrawError` with the code `not-found` when there is no plugin with this name
+     */
+    remove(name: string): boolean;
+    /**
+     * Removes several plugins, with everything they added: all of them or none.
+     *
+     * @returns True when they were removed
+     * @throws `DrawError` with the code `not-found` when one of the names does not exist;
+     *   nothing is removed then
+     */
+    removeMany(names: readonly string[]): boolean;
+    /**
+     * The API a plugin offers to others.
+     *
+     * @returns The API, or `undefined` when there is no plugin with this name or it offers none
+     */
+    getApi<T>(name: string): T | undefined;
+}
+/** The modes that were added, by name. */
+export interface ModesCollection {
+    /**
+     * Gets the factory of a mode by name.
+     *
+     * @returns The factory, or `undefined` when there is no mode with this name
+     */
+    get(name: string): ModeFactory | undefined;
+    /** Lists the names of the modes. */
+    list(): string[];
+    /** Counts the modes. */
+    count(): number;
+    /** Whether a mode with this name was added. */
+    has(name: string): boolean;
+    /**
+     * Adds a mode under a name.
+     *
+     * @returns The function that removes it again
+     * @throws `DrawError` with the code `already-exists` when the name is taken
+     *   or with `invalid-input` when the value does not have the shape of the contract
+     */
+    add(name: string, factory: ModeFactory): () => void;
+    /**
+     * Adds several modes in one transaction: all of them or none.
+     *
+     * @returns The function that removes them again
+     * @throws `DrawError` with the code `already-exists` when one of the names is taken, or
+     *   `invalid-input` when a value does not have the shape of the contract; nothing is added
+     *   then
+     */
+    addMany(entries: readonly {
+        name: string;
+        factory: ModeFactory;
+    }[]): () => void;
+    /**
+     * Removes a mode.
+     *
+     * @returns True when it was removed
+     * @throws `DrawError` with the code `not-found` when there is no mode with this name
+     */
+    remove(name: string): boolean;
+    /**
+     * Removes several modes: all of them or none.
+     *
+     * @returns True when they were removed
+     * @throws `DrawError` with the code `not-found` when one of the names does not exist;
+     *   nothing is removed then
+     */
+    removeMany(names: readonly string[]): boolean;
+}
+/**
+ * The custom feature types, by type name, and the definitions that override a built-in type.
+ */
+export interface FeatureTypesCollection {
+    /**
+     * Gets the definition of a feature type by name: a type that was added, or the definition
+     * that overrides a built-in type.
+     *
+     * @returns The definition, or `undefined` when there is none with this name
+     */
+    get(name: string): FeatureTypeDefinition | undefined;
+    /** Lists the names of the feature types that were added or overridden. */
+    list(): string[];
+    /** Counts the feature types that were added or overridden. */
+    count(): number;
+    /** Whether a feature type with this name was added or overridden. */
+    has(name: string): boolean;
+    /**
+     * Adds a custom feature type. The type takes every feature of its type: its `appliesTo`, if
+     * it has one, is ignored.
+     *
+     * @returns The function that removes it again
+     * @throws `DrawError` with the code `already-exists` when the type name is taken
+     *   or with `invalid-input` when the value does not have the shape of the contract
+     */
+    add(definition: FeatureTypeDefinition): () => void;
+    /**
+     * Adds several custom feature types in one transaction: all of them or none.
+     *
+     * @returns The function that removes them again
+     * @throws `DrawError` with the code `already-exists` when one of the names is taken, or
+     *   `invalid-input` when a value does not have the shape of the contract; nothing is added
+     *   then
+     */
+    addMany(definitions: readonly FeatureTypeDefinition[]): () => void;
+    /**
+     * Overrides a built-in feature type (`Point`, `LineString`, `Polygon`, `Circle`,
+     * `Freehand` or `Image`) with a definition of the same `type` and the same kind of
+     * `geometry` as the built-in one (`Point` for a circle and an image, `LineString` for a
+     * freehand line). The features of the type are drawn by its renderer from then on. Its
+     * `hitTest`, `boxSelect`, `bounds`, `outline`, `bbox` and `snapCandidates` replace those of
+     * the built-in type when it has them, and the built-in ones stay for the members it leaves
+     * out. Its `handles` are shown with those of the built-in type. With `appliesTo`, it takes
+     * only the features for which that returns true, and the others keep the built-in type
+     * entirely.
+     *
+     * The built-in type comes back with the function it returns, with `remove(type)`, and, for
+     * a plugin that overrode it through its context, when the plugin is removed. `add` keeps
+     * refusing the names of the built-in types.
+     *
+     * @returns The function that puts the built-in type back
+     * @throws `DrawError` with the code `invalid-input` when the type is not one of the
+     *   built-in types above, its `geometry` is not the one of the built-in type, or the value
+     *   does not have the shape of the contract, and `already-exists` when the type is already
+     *   overridden
+     */
+    override(definition: FeatureTypeDefinition): () => void;
+    /**
+     * Removes a custom feature type, or the definition that overrides a built-in type (the
+     * built-in type comes back).
+     *
+     * @returns True when it was removed
+     * @throws `DrawError` with the code `not-found` when there is no type with this name
+     */
+    remove(name: string): boolean;
+    /**
+     * Removes several custom feature types: all of them or none.
+     *
+     * @returns True when they were removed
+     * @throws `DrawError` with the code `not-found` when one of the names does not exist;
+     *   nothing is removed then
+     */
+    removeMany(names: readonly string[]): boolean;
+}
+/** The renderers that draw above the features or between the layers, by name. */
+export interface OverlaysCollection {
+    /**
+     * Gets an overlay renderer by name.
+     *
+     * @returns The renderer, or `undefined` when there is none with this name
+     */
+    get(name: string): OverlayRenderer | undefined;
+    /** Lists the names of the overlay renderers. */
+    list(): string[];
+    /** Counts the overlay renderers. */
+    count(): number;
+    /** Whether an overlay renderer with this name was added. */
+    has(name: string): boolean;
+    /**
+     * Adds an overlay renderer.
+     *
+     * @returns The function that removes it again
+     * @throws `DrawError` with the code `already-exists` when the name is taken
+     *   or with `invalid-input` when the value does not have the shape of the contract
+     */
+    add(renderer: OverlayRenderer): () => void;
+    /**
+     * Adds several overlay renderers in one transaction: all of them or none.
+     *
+     * @returns The function that removes them again
+     * @throws `DrawError` with the code `already-exists` when one of the names is taken, or
+     *   `invalid-input` when a value does not have the shape of the contract; nothing is added
+     *   then
+     */
+    addMany(renderers: readonly OverlayRenderer[]): () => void;
+    /**
+     * Removes an overlay renderer.
+     *
+     * @returns True when it was removed
+     * @throws `DrawError` with the code `not-found` when there is none with this name
+     */
+    remove(name: string): boolean;
+    /**
+     * Removes several overlay renderers: all of them or none.
+     *
+     * @returns True when they were removed
+     * @throws `DrawError` with the code `not-found` when one of the names does not exist;
+     *   nothing is removed then
+     */
+    removeMany(names: readonly string[]): boolean;
+}
+/**
+ * The providers of one kind, by name: snapping candidates, handles or companions.
+ *
+ * @typeParam T - The kind of provider
+ */
+export interface ProvidersCollection<T> {
+    /**
+     * Gets a provider by name.
+     *
+     * @returns The provider, or `undefined` when there is none with this name
+     */
+    get(name: string): T | undefined;
+    /** Lists the names of the providers. */
+    list(): string[];
+    /** Counts the providers. */
+    count(): number;
+    /** Whether a provider with this name was added. */
+    has(name: string): boolean;
+    /**
+     * Adds a provider.
+     *
+     * @returns The function that removes it again
+     * @throws `DrawError` with the code `already-exists` when the name is taken
+     *   or with `invalid-input` when the value does not have the shape of the contract
+     */
+    add(provider: T): () => void;
+    /**
+     * Adds several providers in one transaction: all of them or none.
+     *
+     * @returns The function that removes them again
+     * @throws `DrawError` with the code `already-exists` when one of the names is taken, or
+     *   `invalid-input` when a value does not have the shape of the contract; nothing is added
+     *   then
+     */
+    addMany(providers: readonly T[]): () => void;
+    /**
+     * Removes a provider.
+     *
+     * @returns True when it was removed
+     * @throws `DrawError` with the code `not-found` when there is no provider with this name
+     */
+    remove(name: string): boolean;
+    /**
+     * Removes several providers: all of them or none.
+     *
+     * @returns True when they were removed
+     * @throws `DrawError` with the code `not-found` when one of the names does not exist;
+     *   nothing is removed then
+     */
+    removeMany(names: readonly string[]): boolean;
+}
+/**
+ * Every collection of extensions of a draw instance.
+ */
+export interface ExtensionsCollections {
+    /** The plugins: bundles of other extensions and state */
+    readonly plugins: PluginsCollection;
+    /** The modes: ways of receiving input */
+    readonly modes: ModesCollection;
+    /** The custom feature types */
+    readonly featureTypes: FeatureTypesCollection;
+    /** The renderers that draw above the features or between the layers */
+    readonly overlays: OverlaysCollection;
+    /** The providers of snapping candidates */
+    readonly snapProviders: ProvidersCollection<SnapProvider>;
+    /** The providers of handles on the selected features */
+    readonly handleProviders: ProvidersCollection<HandleProvider>;
+    /** The providers of companions drawn one step below a feature */
+    readonly companionProviders: ProvidersCollection<CompanionProvider>;
+}

package/dist/api/extensions.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};