@sakuzu/maplibre-gl-draw 1.0.0 → 2.1.0

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

@@ -0,0 +1,123 @@
+/**
+ * The input contract: the events a mode and a plugin receive, and the handler of a mode
+ *
+ * One rule holds for every input handler: returning true consumes the event, so that nothing
+ * after the handler receives it.
+ */
+import type { Position } from 'geojson';
+import type { ScreenPoint } from '../events.js';
+import type { SnapPreference, SnapResult } from '../state.js';
+import type { ModeContext } from './context.js';
+/** The modifier keys held during an input. */
+export interface Modifiers {
+    /** Whether Shift was held */
+    shift: boolean;
+    /** Whether Control was held */
+    ctrl: boolean;
+    /** Whether Alt (Option on macOS) was held */
+    alt: boolean;
+    /** Whether Meta (Command on macOS) was held */
+    meta: boolean;
+}
+/** A pointer input on the map, as a mode and a plugin receive it. */
+export interface DrawPointerEvent {
+    /** The point on the screen */
+    point: ScreenPoint;
+    /** The position on the map */
+    lngLat: Position;
+    /** Where the input snaps to; the position of the pointer when nothing is snapped to */
+    snapped: SnapResult;
+    /** The modifier keys held */
+    modifiers: Modifiers;
+    /** The kind of pointer */
+    pointerType: 'mouse' | 'touch' | 'pen';
+    /** The event of the browser */
+    original: PointerEvent;
+    /**
+     * True when the input was made from code by `draw.drawing` (`addVertex`, `moveTo`), not by
+     * the pointer. Its position is exact: a mode applies no click tolerance to it, so a vertex
+     * placed a few pixels from another is kept, and only one at exactly the same position is
+     * the same vertex. Left out for the input of the pointer.
+     */
+    programmatic?: boolean;
+}
+/** A key input, as a mode and a plugin receive it. */
+export interface DrawKeyEvent {
+    /** The key, as `KeyboardEvent.key` gives it */
+    key: string;
+    /** The modifier keys held */
+    modifiers: Modifiers;
+    /** The event of the browser */
+    original: KeyboardEvent;
+}
+/**
+ * The receivers of the input; `Plugin.input` and `ModeHandler` take any of them. Returning
+ * true consumes the event, so that nothing after the receiver gets it.
+ */
+export interface InputHandlers {
+    /** A pointer was pressed */
+    onPointerDown(event: DrawPointerEvent): boolean | void;
+    /** The pointer moved without a drag */
+    onPointerMove(event: DrawPointerEvent): boolean | void;
+    /** A pointer was released */
+    onPointerUp(event: DrawPointerEvent): boolean | void;
+    /** The pointer left the map */
+    onPointerLeave(): boolean | void;
+    /** A click */
+    onClick(event: DrawPointerEvent): boolean | void;
+    /** A double click */
+    onDoubleClick(event: DrawPointerEvent): boolean | void;
+    /** A drag started */
+    onDragStart(event: DrawPointerEvent): boolean | void;
+    /** The pointer moved during a drag */
+    onDrag(event: DrawPointerEvent): boolean | void;
+    /** A drag ended */
+    onDragEnd(event: DrawPointerEvent): boolean | void;
+    /** A drag was cancelled */
+    onDragCancel(event: DrawPointerEvent): boolean | void;
+    /** A key was pressed */
+    onKeyDown(event: DrawKeyEvent): boolean | void;
+    /** A key was released */
+    onKeyUp(event: DrawKeyEvent): boolean | void;
+}
+/**
+ * The contract of a mode: how it enters, exits and receives the input. Every member is
+ * optional; returning true from an input receiver consumes the event.
+ */
+export interface ModeHandler extends Partial<InputHandlers> {
+    /**
+     * Whether the mode writes new features. Such a mode is entered only while a layer can be
+     * written, and a double click never zooms the map while it is the current mode, whether or
+     * not it takes the double click; false when it is left out.
+     */
+    readonly writes?: boolean;
+    /** How the mode wants the positions of its input snapped; every input snaps when left out */
+    readonly snapPreference?: SnapPreference;
+    /** Called when the mode is entered */
+    onEnter?(): void;
+    /** Called when the mode is left */
+    onExit?(): void;
+    /**
+     * Called when the mode is interrupted: by an Escape that neither a plugin nor the mode
+     * consumed, or when the Store replaces its whole document (a notification with
+     * `reset: true`). The mode drops what it was drawing and stays the current mode.
+     */
+    onCancel?(): void;
+    /**
+     * Removes the last vertex of the shape being drawn, as `ctx.drawing.undoVertex` asks.
+     *
+     * @returns True when a vertex was removed
+     */
+    onUndoVertex?(): boolean;
+    /**
+     * Puts back the vertex the last `onUndoVertex` removed, as `ctx.drawing.redoVertex` asks.
+     *
+     * @returns True when a vertex was put back
+     */
+    onRedoVertex?(): boolean;
+}
+/**
+ * The function that creates the handler of a mode. It is registered once, under its name,
+ * with `draw.extensions.modes.add(name, factory)`.
+ */
+export type ModeFactory = (ctx: ModeContext) => ModeHandler;

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

@@ -0,0 +1,51 @@
+/**
+ * Plugins: bundles of other extensions and state
+ */
+import type { Feature } from '../model.js';
+import type { PluginContext } from './context.js';
+import type { DrawPointerEvent, InputHandlers } from './mode.js';
+/**
+ * A plugin: a bundle of modes, feature types, overlays, providers and state, added with
+ * `draw.extensions.plugins.add`. What it adds through its context is removed by itself when
+ * the plugin is removed. Plugins talk to each other through their `api`.
+ *
+ * @typeParam Api - The API the plugin offers to others
+ */
+export interface Plugin<Api = unknown> {
+    /** The name it is registered under */
+    readonly name: string;
+    /** Called when the plugin is added; add its extensions and subscribe to events here. */
+    onAdd(ctx: PluginContext): void;
+    /** Called when the plugin is removed. */
+    onRemove?(): void;
+    /** The API others get with `draw.extensions.plugins.getApi(name)` */
+    readonly api?: Api;
+    /**
+     * Receivers of the input, called before those of the mode. Returning true consumes the
+     * event, so that the mode does not get it.
+     */
+    readonly input?: Partial<InputHandlers>;
+    /** The hooks of the select mode, and an exclusive interaction of the plugin */
+    readonly interaction?: {
+        /** Narrows the candidates of a selection to the IDs it returns */
+        filterSelection?(candidateIds: readonly string[]): string[];
+        /** A selected feature was clicked again; returning true means the plugin handled it */
+        onFeatureClick?(feature: Feature, event: DrawPointerEvent): boolean;
+        /** A feature was double-clicked; returning true means the plugin handled it */
+        onFeatureDoubleClick?(feature: Feature, event: DrawPointerEvent): boolean;
+        /**
+         * A drawing mode created a feature: a commit of `ModeContext.commitFeature`, which the
+         * built-in drawing modes use too, or the image placed by the load that follows a request
+         * of the image mode
+         */
+        onDrawCommit?(feature: Feature): void;
+        /** Whether the plugin is in an exclusive interaction, during which the mode stays still */
+        isBusy?(): boolean;
+        /** Completes the exclusive interaction */
+        finish?(): void;
+        /** Cancels the exclusive interaction */
+        cancel?(): void;
+        /** The element of the exclusive interaction; clicks inside it are left to the plugin */
+        container?(): HTMLElement | null;
+    };
+}

package/dist/api/extension/plugin.js

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

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

@@ -0,0 +1,119 @@
+/**
+ * Providers: extensions that add snapping candidates, handles or companions to feature types
+ * they do not define
+ *
+ * A custom feature type describes its own handles and candidates in its definition; a
+ * provider is for the built-in types and the types of other extensions.
+ */
+import type { Position } from 'geojson';
+import type { Feature, FeaturePatch } from '../model.js';
+import type { HitTestContext, ScreenContext, SnapContext } from './context.js';
+import type { Handle } from './feature-type.js';
+import type { DrawPointerEvent } from './mode.js';
+import type { RenderContext } from './render.js';
+/** What a hit test found. */
+export interface Hit {
+    /** What was hit */
+    kind: 'feature' | 'dataset' | 'companion' | 'handle';
+    /** The ID of what was hit */
+    id: string;
+    /** The ID of the feature it belongs to */
+    featureId?: string;
+    /** The ID of the dataset, for a row of a dataset */
+    datasetId?: string;
+    /** The distance from the point, in pixels */
+    distancePx: number;
+}
+/** One snapping candidate. */
+export interface SnapCandidate {
+    /** The position to snap to */
+    position: Position;
+    /** The kind of candidate; a provider may use a kind of its own */
+    kind: 'vertex' | 'edge' | 'intersection' | 'guide' | (string & {});
+    /** The priority among candidates at the same distance; higher wins */
+    priority?: number;
+    /** Where the candidate came from, for display */
+    source?: string;
+}
+/** An extension that adds snapping candidates. */
+export interface SnapProvider {
+    /** The name it is registered under */
+    readonly name: string;
+    /** The candidates near the point of the context. */
+    candidates(ctx: SnapContext): SnapCandidate[];
+}
+/** An extension that shows handles of its own on the selected features and receives their drags. */
+export interface HandleProvider {
+    /** The name it is registered under */
+    readonly name: string;
+    /**
+     * The handles of a selected feature. The engine draws them with the look of the vertex
+     * handles, hit tests them at the same size, and gives their drags to `onDrag`.
+     */
+    handles(feature: Feature, ctx: ScreenContext): Handle[];
+    /**
+     * The handles that belong to no feature, shown whatever is selected; they are hit and
+     * dragged like the others, and their drag arrives with `feature` as `null`.
+     */
+    globalHandles?(ctx: ScreenContext): Handle[];
+    /**
+     * The change a drag of one of its handles makes. It is called for every move of the drag
+     * and once more when the drag ends; the patch of the end is the one that stays.
+     *
+     * @param feature - The feature the handle is on; `null` for a handle of `globalHandles`
+     * @returns The patch to apply to the feature, or `null` for no change
+     */
+    onDrag(feature: Feature | null, handle: Handle, event: DrawPointerEvent): FeaturePatch | null;
+    /**
+     * A drag of one of its handles is about to start, before the first `onDrag`.
+     *
+     * @param feature - The feature the handle is on; `null` for a handle of `globalHandles`
+     * @returns False to refuse the drag: the pointer then does what it would do without the
+     *   handle, and no `onDrag` nor `onDragEnd` follows
+     */
+    onDragStart?(feature: Feature | null, handle: Handle, event: DrawPointerEvent): boolean;
+    /**
+     * A drag of one of its handles ended, after the last `onDrag` and its patch. It is called
+     * once for every drag that started, also when the drag is cut short.
+     *
+     * @param feature - The feature the handle is on as it is now; `null` for a handle of
+     *   `globalHandles`, or when the feature is gone
+     */
+    onDragEnd?(feature: Feature | null, handle: Handle, event: DrawPointerEvent): void;
+}
+/**
+ * An extension that draws a companion one step below a feature, such as a leader line, and
+ * hit tests it at the same step.
+ */
+export interface CompanionProvider {
+    /** The name it is registered under */
+    readonly name: string;
+    /**
+     * Whether a feature has a companion. It is asked for every feature on every frame and
+     * every hit test, so it must answer at once.
+     */
+    has(feature: Feature): boolean;
+    /** Draws the companion of a feature. */
+    draw(feature: Feature, ctx: RenderContext): void;
+    /**
+     * Hit tests the companion of a feature.
+     *
+     * It is asked at the step of the feature in the stacking order: when the point missed the
+     * feature itself, and before the feature behind it. At one point, the handles of the
+     * selection come first; then, from the front, each feature and then its companions, so a
+     * feature (its marker, its line or its area, with the click tolerance) wins over its own
+     * companion and a companion wins over the features behind its feature; the rows of a
+     * dataset come only after the features and the companions in front of them.
+     *
+     * @returns What was hit, or `null`
+     */
+    hitTest(feature: Feature, ctx: HitTestContext): Hit | null;
+    /**
+     * A companion was clicked.
+     *
+     * @param hit - What `hitTest` returned
+     * @returns True to consume the click, which then changes nothing else; false, or nothing,
+     *   to leave it to the select mode as a click on the feature
+     */
+    onClick?(feature: Feature, hit: Hit, event: DrawPointerEvent): boolean;
+}

package/dist/api/extension/provider.js

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

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 {};