@sakuzu/maplibre-gl-draw 1.0.0

package/dist/api/feature-api.js

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Feature API
+ *
+ * Provides the Feature CRUD operations of MapLibreGLDraw.
+ * It is composed into createDrawAPI by spreading.
+ */
+import { isFeatureLocked } from '../store/lock.js';
+export function createFeatureApi(deps) {
+    const { store, generateFeatureId, getActiveLayerId } = deps;
+    return {
+        addFeature(input) {
+            const feature = {
+                id: input.id ?? generateFeatureId(),
+                type: input.type,
+                coordinates: input.coordinates,
+                layerId: input.layerId ?? getActiveLayerId(),
+                properties: input.properties ?? {},
+                style: input.style,
+                locked: input.locked ?? false,
+                visible: input.visible ?? true,
+            };
+            // A write refused because the Store is read-only returns null
+            return store.createFeature(feature) ? feature.id : null;
+        },
+        getFeature(id) {
+            return store.getFeature(id);
+        },
+        getAllFeatures() {
+            return featuresInDisplayOrder(store);
+        },
+        getVisibleFeatures() {
+            return store.getOrderedFeatures();
+        },
+        updateFeature(id, updates) {
+            // While locked (either itself, its group or its layer), reject changes to any
+            // attribute other than locked/visible (Miro-style full protection). locked/visible are
+            // allowed so that it can be unlocked and its visibility toggled.
+            const feature = store.getFeature(id);
+            if (feature && isFeatureLocked(feature, store) && !onlyLockOrVisibility(updates)) {
+                return false;
+            }
+            // An id that does not exist throws in the Store (unless it is read-only)
+            return store.updateFeature(id, updates);
+        },
+        deleteFeature(id) {
+            return store.deleteFeature(id);
+        },
+        deleteAllFeatures() {
+            const features = store.getAllFeatures();
+            return store.transact(() => {
+                let applied = true;
+                for (const feature of features) {
+                    if (!store.getFeature(feature.id))
+                        continue;
+                    applied = store.deleteFeature(feature.id) && applied;
+                }
+                return applied;
+            });
+        },
+    };
+}
+/** Whether an update changes nothing but `locked` / `visible` (what a lock still allows) */
+export function onlyLockOrVisibility(updates) {
+    return Object.keys(updates).every((key) => key === 'locked' || key === 'visible');
+}
+/**
+ * Every feature in display order (layer order -> order within the layer -> order within the
+ * group), whatever the visible flags say. A feature that no container lists (which the
+ * Store's containment invariant rules out) is appended at the end.
+ */
+function featuresInDisplayOrder(store) {
+    const result = [];
+    const seen = new Set();
+    const push = (id) => {
+        const feature = store.getFeature(id);
+        if (feature && !seen.has(id)) {
+            seen.add(id);
+            result.push(feature);
+        }
+    };
+    for (const layerId of store.getLayerOrder()) {
+        const layer = store.getLayer(layerId);
+        if (!layer)
+            continue;
+        for (const itemId of layer.order) {
+            const group = store.getGroup(itemId);
+            if (group) {
+                for (const featureId of group.featureIds)
+                    push(featureId);
+            }
+            else {
+                push(itemId);
+            }
+        }
+    }
+    for (const feature of store.getAllFeatures())
+        push(feature.id);
+    return result;
+}

package/dist/api/geometry/apply.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The common part of the geometry operations: placing a result where its input was, and
+ * announcing what an operation did
+ *
+ *   applyResult   creates one result, deletes the inputs and places it (outside a transaction)
+ *   commitResult  wraps applyResult in one transaction and moves the selection
+ *   emitApplied   emits draw.geometry.applied
+ */
+import type { EventEmitter, GeometryAppliedPayload } from '../../shared/utils/event-emitter.js';
+import type { Feature, FeatureCoordinates, FeatureType } from '../../store/types.js';
+import type { GeometryApiDeps } from './types.js';
+export interface CommitParams {
+    /**
+     * The input whose style, properties and placement are inherited (in a boolean operation, the
+     * frontmost in z order)
+     */
+    anchor: Feature;
+    /**
+     * The IDs of the inputs to delete. Left empty in an operation that keeps the inputs, such as
+     * the buffer
+     */
+    removedIds: string[];
+    geometry: {
+        type: FeatureType;
+        coordinates: FeatureCoordinates;
+    };
+    /**
+     * The properties of the result. When omitted, they are inherited from the anchor with the
+     * Circle-specific properties removed.
+     * It is given explicitly only when the result stays a Circle (the Circle special case of the
+     * buffer).
+     */
+    properties?: Record<string, unknown>;
+}
+/**
+ * Creates one result feature, deletes the inputs and places it.
+ *
+ * It does not open a transaction. Because the caller wraps it in store.transact, even a case
+ * with several results, such as the buffer, is gathered into one StateChanges.
+ */
+export declare function applyResult(deps: GeometryApiDeps, params: CommitParams): string;
+/**
+ * Creates the result feature and deletes the inputs in one transaction, and moves the
+ * selection to the result.
+ *
+ * A subscriber receives it as one StateChanges, which is what makes it one step for anything
+ * that records changes.
+ */
+export declare function commitResult(deps: GeometryApiDeps, params: CommitParams): string;
+/** Emits draw.geometry.applied. */
+export declare function emitApplied(eventEmitter: EventEmitter, payload: GeometryAppliedPayload): void;

package/dist/api/geometry/apply.js

@@ -0,0 +1,114 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * The parametric properties of Circle. They are not inherited by a result that has been
+ * reduced to a polygon (because a Circle becomes a polygon of 64 segments and loses the
+ * notion of a radius).
+ */
+const CIRCLE_ONLY_PROPERTIES = ['radiusMeters', 'radiusHandleAngle'];
+/**
+ * Decides the placement that puts the result at "the place where the input it inherits from
+ * was".
+ *
+ * When the input was a member of a group, the result is put into the same group. The position
+ * is the position that the input it inherits from occupied in the order after the inputs have
+ * been removed. In an operation where the input it inherits from remains (the buffer), the
+ * result is put just in front of that input.
+ */
+function planPlacement(store, anchor, removedIds) {
+    const group = anchor.groupId ? store.getGroup(anchor.groupId) : undefined;
+    const container = group ? group.featureIds : (store.getLayer(anchor.layerId)?.order ?? []);
+    const anchorIndex = container.indexOf(anchor.id);
+    const precedingIds = anchorIndex < 0 ? container : container.slice(0, anchorIndex);
+    const precedingCount = precedingIds.filter((id) => !removedIds.has(id)).length;
+    return {
+        layerId: anchor.layerId,
+        groupId: group?.id,
+        // One further back when the input it inherits from remains (= just in front of it).
+        // When it is deleted, that place is used as is.
+        index: removedIds.has(anchor.id) ? precedingCount : precedingCount + 1,
+    };
+}
+/**
+ * Moves the result that createFeature stacked at the tail (the frontmost) to the z position of
+ * its placement.
+ */
+function moveToPlacement(store, resultId, placement) {
+    if (placement.groupId) {
+        const group = store.getGroup(placement.groupId);
+        if (!group)
+            return;
+        const featureIds = group.featureIds.filter((id) => id !== resultId);
+        featureIds.splice(placement.index, 0, resultId);
+        store.updateGroup(placement.groupId, { featureIds });
+        return;
+    }
+    const layer = store.getLayer(placement.layerId);
+    if (!layer)
+        return;
+    const order = layer.order.filter((id) => id !== resultId);
+    order.splice(placement.index, 0, resultId);
+    store.updateLayer(placement.layerId, { order });
+}
+/**
+ * Inherits the style and the properties from the input it inherits from.
+ */
+function inheritProperties(anchor) {
+    const properties = { ...anchor.properties };
+    for (const key of CIRCLE_ONLY_PROPERTIES) {
+        delete properties[key];
+    }
+    return properties;
+}
+/**
+ * Creates one result feature, deletes the inputs and places it.
+ *
+ * It does not open a transaction. Because the caller wraps it in store.transact, even a case
+ * with several results, such as the buffer, is gathered into one StateChanges.
+ */
+export function applyResult(deps, params) {
+    const { store, generateFeatureId } = deps;
+    const { anchor, removedIds, geometry } = params;
+    const placement = planPlacement(store, anchor, new Set(removedIds));
+    const result = {
+        id: generateFeatureId(),
+        type: geometry.type,
+        coordinates: geometry.coordinates,
+        layerId: placement.layerId,
+        groupId: placement.groupId,
+        properties: params.properties ?? inheritProperties(anchor),
+        style: anchor.style ? { ...anchor.style } : undefined,
+        locked: false,
+        visible: true,
+    };
+    // Create the result first, then delete the inputs. In the reverse order, a group made up of
+    // the inputs alone would be removed by "the automatic deletion of empty groups", and the
+    // place to put the result would be lost.
+    store.createFeature(result);
+    for (const id of removedIds) {
+        if (!store.getFeature(id))
+            continue;
+        store.deleteFeature(id);
+    }
+    moveToPlacement(store, result.id, placement);
+    return result.id;
+}
+/**
+ * Creates the result feature and deletes the inputs in one transaction, and moves the
+ * selection to the result.
+ *
+ * A subscriber receives it as one StateChanges, which is what makes it one step for anything
+ * that records changes.
+ */
+export function commitResult(deps, params) {
+    const { store } = deps;
+    return store.transact(() => {
+        const resultId = applyResult(deps, params);
+        store.setSelection('feature', [resultId]);
+        return resultId;
+    });
+}
+/** Emits draw.geometry.applied. */
+export function emitApplied(eventEmitter, payload) {
+    eventEmitter.emit('geometry.applied', payload);
+}

package/dist/api/geometry/boolean.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The boolean editing operations (union / subtract / intersect) on the area types
+ */
+import type { AreaCoordinates, MultiPolygonCoordinates } from '../../geometry/index.js';
+import type { GeometryOperationName } from '../../shared/utils/event-emitter.js';
+import type { Store } from '../../store/store.js';
+import type { Feature } from '../../store/types.js';
+import type { GeometryApiDeps } from './types.js';
+/**
+ * The common path that runs an operation on the area types and replaces the inputs with the
+ * result.
+ *
+ * @param inputs The targets ordered in z order (the tail is the frontmost)
+ * @param compute The geometric operation that receives the area coordinates in the same order
+ *   as inputs and returns the result
+ */
+export declare function runAreaOperation(deps: GeometryApiDeps, operation: GeometryOperationName, inputs: Feature[], compute: (areas: AreaCoordinates[]) => MultiPolygonCoordinates): string | null;
+/**
+ * Resolves the targets of subtract.
+ *
+ * When targetId is omitted, it is "subtract the group of frontmost features from the backmost
+ * one". When it is given explicitly, that feature is added to the targets even if it is not
+ * included in the list of targets (ids / the selection).
+ */
+export declare function resolveSubtractInputs(store: Store, targetId: string | undefined, ids: string[] | undefined): {
+    inputs: Feature[];
+    targetIndex: number;
+} | null;

package/dist/api/geometry/boolean.js

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { commitResult, emitApplied } from './apply.js';
+import { currentSelectionIds, isAreaFeature, resolveTargetFeatures, toAreaCoordinates, toResultGeometry, } from './targets.js';
+/**
+ * The common path that runs an operation on the area types and replaces the inputs with the
+ * result.
+ *
+ * @param inputs The targets ordered in z order (the tail is the frontmost)
+ * @param compute The geometric operation that receives the area coordinates in the same order
+ *   as inputs and returns the result
+ */
+export function runAreaOperation(deps, operation, inputs, compute) {
+    const inputIds = inputs.map((feature) => feature.id);
+    const areas = [];
+    for (const feature of inputs) {
+        const area = toAreaCoordinates(feature);
+        if (area === null)
+            return null;
+        areas.push(area);
+    }
+    const geometry = toResultGeometry(compute(areas));
+    if (geometry === null) {
+        // An empty result (an intersection that does not overlap, a punch-out where everything was
+        // subtracted). The inputs are not changed at all; only the notification is emitted.
+        emitApplied(deps.eventEmitter, {
+            operation,
+            inputIds,
+            resultId: null,
+            resultIds: [],
+            status: 'empty',
+        });
+        return null;
+    }
+    // The style, the properties and the placement are inherited from the frontmost input.
+    const anchor = inputs[inputs.length - 1];
+    const resultId = commitResult(deps, { anchor, removedIds: inputIds, geometry });
+    emitApplied(deps.eventEmitter, {
+        operation,
+        inputIds,
+        resultId,
+        resultIds: [resultId],
+        status: 'applied',
+    });
+    return resultId;
+}
+/**
+ * Resolves the targets of subtract.
+ *
+ * When targetId is omitted, it is "subtract the group of frontmost features from the backmost
+ * one". When it is given explicitly, that feature is added to the targets even if it is not
+ * included in the list of targets (ids / the selection).
+ */
+export function resolveSubtractInputs(store, targetId, ids) {
+    const baseIds = ids ?? currentSelectionIds(store);
+    const wanted = targetId === undefined ? baseIds : [...new Set([targetId, ...baseIds])];
+    const inputs = resolveTargetFeatures(store, wanted, isAreaFeature);
+    if (inputs.length < 2)
+        return null;
+    // By default the backmost in z order is the side that is subtracted from.
+    const targetIndex = targetId === undefined ? 0 : inputs.findIndex((feature) => feature.id === targetId);
+    if (targetIndex < 0)
+        return null;
+    return { inputs, targetIndex };
+}

package/dist/api/geometry/buffer.d.ts

@@ -0,0 +1,11 @@
+import type { Feature } from '../../store/types.js';
+import type { GeometryApiDeps, GeometryBufferOptions } from './types.js';
+/**
+ * Runs the buffer and creates the result features.
+ *
+ * The inputs remain, and one result is created per input. The creation of all the results is
+ * gathered into one store.transact, so a single undo removes all of them.
+ *
+ * @param inputs The targets ordered in z order (the tail is the frontmost)
+ */
+export declare function runBuffer(deps: GeometryApiDeps, inputs: Feature[], options: GeometryBufferOptions): string[];

package/dist/api/geometry/buffer.js

@@ -0,0 +1,105 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * The buffer: the area within a distance of each input, created as new features
+ *
+ * It differs from the boolean operations only in that it "keeps the inputs and adds the
+ * results", so it takes the same path with the removedIds of applyResult left empty. Since it
+ * creates one result per input, several applyResult calls are gathered into one
+ * store.transact, and all the results are selected at the end.
+ */
+// buffer is imported under an alias so that the name reads as the geometry module's function.
+import { buffer as computeBuffer } from '../../geometry/index.js';
+import { getCircleRadius } from '../../shared/utils/property.js';
+import { applyResult, emitApplied } from './apply.js';
+import { toBufferGeometry, toResultGeometry } from './targets.js';
+/**
+ * Plans the buffer of a Circle input.
+ *
+ * To keep it parametric, it returns a Circle whose radiusMeters has been grown or shrunk,
+ * without reducing it to a polygon. A shrink that makes the radius 0 or less has an empty
+ * result, so null is returned.
+ */
+function planCircleBuffer(input, distanceMeters) {
+    const radiusMeters = getCircleRadius(input);
+    if (radiusMeters === undefined || radiusMeters <= 0)
+        return null;
+    const nextRadius = radiusMeters + distanceMeters;
+    if (nextRadius <= 0)
+        return null;
+    return {
+        input,
+        geometry: { type: 'Circle', coordinates: input.coordinates },
+        // It stays a Circle, so the properties including radiusHandleAngle are inherited and only
+        // the radius is replaced.
+        properties: { ...input.properties, radiusMeters: nextRadius },
+    };
+}
+/**
+ * Plans the buffer of one input. null when the result is empty or the operation is not
+ * defined.
+ */
+function planBuffer(input, options) {
+    const { distanceMeters, segments } = options;
+    if (input.type === 'Circle')
+        return planCircleBuffer(input, distanceMeters);
+    const geometryInput = toBufferGeometry(input);
+    if (geometryInput === null)
+        return null;
+    // null means "the operation is not defined for that input" (a negative value on a point or
+    // a line), [] means the result is empty.
+    const parts = computeBuffer(geometryInput, distanceMeters, { segments });
+    if (parts === null)
+        return null;
+    const geometry = toResultGeometry(parts);
+    if (geometry === null)
+        return null;
+    return { input, geometry };
+}
+/**
+ * Runs the buffer and creates the result features.
+ *
+ * The inputs remain, and one result is created per input. The creation of all the results is
+ * gathered into one store.transact, so a single undo removes all of them.
+ *
+ * @param inputs The targets ordered in z order (the tail is the frontmost)
+ */
+export function runBuffer(deps, inputs, options) {
+    const { store } = deps;
+    const plans = [];
+    for (const input of inputs) {
+        const plan = planBuffer(input, options);
+        if (plan !== null)
+            plans.push(plan);
+    }
+    if (plans.length === 0) {
+        // Every input was skipped or had an empty result. The Store is not changed at all; only
+        // the notification is emitted.
+        emitApplied(deps.eventEmitter, {
+            operation: 'buffer',
+            inputIds: inputs.map((input) => input.id),
+            resultId: null,
+            resultIds: [],
+            status: 'empty',
+        });
+        return [];
+    }
+    const resultIds = store.transact(() => {
+        const ids = plans.map((plan) => applyResult(deps, {
+            anchor: plan.input,
+            removedIds: [],
+            geometry: plan.geometry,
+            properties: plan.properties,
+        }));
+        store.setSelection('feature', ids);
+        return ids;
+    });
+    emitApplied(deps.eventEmitter, {
+        operation: 'buffer',
+        inputIds: plans.map((plan) => plan.input.id),
+        resultId: resultIds[0],
+        resultIds,
+        status: 'applied',
+    });
+    return resultIds;
+}

package/dist/api/geometry/split.d.ts

@@ -0,0 +1,16 @@
+import type { Feature } from '../../store/types.js';
+import type { GeometryApiDeps } from './types.js';
+/**
+ * Runs the split and replaces the polygon with the group of features that result from the
+ * split.
+ *
+ * All the results are gathered into one store.transact (a single undo goes back to the
+ * original polygon). Only the first result deletes the original polygon, and the results that
+ * follow are stacked just in front of the previous result. The previous result has inherited
+ * both the style and the properties from the original polygon, so using it as the one to
+ * inherit from does not change the content.
+ *
+ * @param area The polygon to be cut
+ * @param line The cutting line (it is not deleted and remains)
+ */
+export declare function runSplit(deps: GeometryApiDeps, area: Feature, line: Feature): string[];

package/dist/api/geometry/split.js

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { splitArea } from '../../geometry/index.js';
+import { applyResult, emitApplied } from './apply.js';
+import { toAreaCoordinates, toResultGeometry, toSplitPaths } from './targets.js';
+/**
+ * Runs the split and replaces the polygon with the group of features that result from the
+ * split.
+ *
+ * All the results are gathered into one store.transact (a single undo goes back to the
+ * original polygon). Only the first result deletes the original polygon, and the results that
+ * follow are stacked just in front of the previous result. The previous result has inherited
+ * both the style and the properties from the original polygon, so using it as the one to
+ * inherit from does not change the content.
+ *
+ * @param area The polygon to be cut
+ * @param line The cutting line (it is not deleted and remains)
+ */
+export function runSplit(deps, area, line) {
+    const { store } = deps;
+    const inputIds = [area.id, line.id];
+    const source = toAreaCoordinates(area);
+    const paths = toSplitPaths(line);
+    const parts = [];
+    if (source !== null && paths.length > 0) {
+        // A MultiLineString cuts one line at a time in order (it cuts the previous result further)
+        let current = splitArea(source, paths[0]);
+        for (let i = 1; i < paths.length; i++) {
+            current = current.flatMap((part) => splitArea(part, paths[i]));
+        }
+        parts.push(...current);
+    }
+    const geometries = [];
+    for (const part of parts) {
+        const geometry = toResultGeometry(part);
+        if (geometry !== null)
+            geometries.push(geometry);
+    }
+    if (geometries.length < 2) {
+        // The line did not divide the polygon. The inputs are not changed at all; only the
+        // notification is emitted.
+        emitApplied(deps.eventEmitter, {
+            operation: 'split',
+            inputIds,
+            resultId: null,
+            resultIds: [],
+            status: 'empty',
+        });
+        return [];
+    }
+    const resultIds = store.transact(() => {
+        const ids = [];
+        let anchor = area;
+        for (const geometry of geometries) {
+            const id = applyResult(deps, {
+                anchor,
+                // The original polygon is deleted only on the first pass
+                removedIds: ids.length === 0 ? [area.id] : [],
+                geometry,
+            });
+            ids.push(id);
+            anchor = store.getFeature(id) ?? anchor;
+        }
+        store.setSelection('feature', ids);
+        return ids;
+    });
+    emitApplied(deps.eventEmitter, {
+        operation: 'split',
+        inputIds,
+        resultId: resultIds[0],
+        resultIds,
+        status: 'applied',
+    });
+    return resultIds;
+}

package/dist/api/geometry/targets.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The targets of the geometry operations: which features each operation accepts, how a
+ * feature is read as the input of the geometry module, and how the result is read back
+ */
+import type { AreaCoordinates, GeometryInput, MultiPolygonCoordinates } from '../../geometry/index.js';
+import type { Store } from '../../store/store.js';
+import type { Coordinate, Feature, FeatureCoordinates, FeatureType } from '../../store/types.js';
+/**
+ * Whether the feature can be a target of a boolean operation.
+ *
+ * The area types (Polygon / MultiPolygon / Circle) only. A Circle without a radius has no
+ * area, so it is excluded from the targets.
+ */
+export declare function isAreaFeature(feature: Feature): boolean;
+/**
+ * Converts a feature into the area coordinates of the geometry module.
+ *
+ * A Circle is reduced to a ring with the default number of segments (64) of
+ * generateCirclePolygon, the same as in the rendering (view/renderers/drawer.ts). An input
+ * that has no area returns null.
+ */
+export declare function toAreaCoordinates(feature: Feature): AreaCoordinates | null;
+/**
+ * Whether the feature can be the cutting side of a split.
+ */
+export declare function isSplitLineFeature(feature: Feature): boolean;
+/**
+ * Reduces a line feature to an array of polylines.
+ *
+ * A MultiLineString becomes one polyline per part. A type that cannot be the cutting side
+ * returns an empty array.
+ */
+export declare function toSplitPaths(feature: Feature): Coordinate[][];
+/**
+ * Whether the feature can be a target of the buffer.
+ *
+ * Only a Circle that has a radius is a target (a Circle without a radius has no starting
+ * point to grow or shrink from).
+ */
+export declare function isBufferableFeature(feature: Feature): boolean;
+/**
+ * Converts a feature into the GeometryInput of the geometry module.
+ *
+ * The shape of the coordinates matches the shape of the core Feature coordinates and is
+ * GeoJSON compatible, so it can be passed by only re-typing it. A Circle is handled as a
+ * special case (growing or shrinking the radius), so it is not converted here.
+ */
+export declare function toBufferGeometry(feature: Feature): GeometryInput | null;
+/**
+ * Builds the type and coordinates of the feature to create from the MultiPolygon coordinates
+ * returned by the geometry module.
+ *
+ * Polygon when there is one part, MultiPolygon when there are several. An empty array (no
+ * area) returns null.
+ */
+export declare function toResultGeometry(parts: MultiPolygonCoordinates): {
+    type: FeatureType;
+    coordinates: FeatureCoordinates;
+} | null;
+/** The IDs of the current feature selection (empty on a group or layer selection). */
+export declare function currentSelectionIds(store: Store): string[];
+/**
+ * Resolves the targets of an operation in z order (the head is the backmost, the tail is the
+ * frontmost).
+ *
+ * The order follows getDisplayFeatures (= getOrderedFeatures with the locally hidden features
+ * removed). That is "the order between the layers -> the order within a layer -> the
+ * featureIds within a group", which is the draw order of core itself. Hidden features (both
+ * the shared visible and the local hidden) do not appear in this list, so they are
+ * automatically excluded from the targets here.
+ * Locked features (the effective lock) are excluded explicitly.
+ *
+ * @param ids The target IDs. When undefined, the current selection
+ * @param accept The acceptance test, on the type and so on
+ */
+export declare function resolveTargetFeatures(store: Store, ids: string[] | undefined, accept: (feature: Feature) => boolean): Feature[];