@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/api/impl/features.js

@@ -0,0 +1,445 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * `draw.features`: the features of the document
+ */
+import { differenceAll, intersectionAll, unionAll } from '../../geometry/boolean.js';
+import { getBoundingBox } from '../../shared/utils/feature-bbox.js';
+import { isFeatureLocked } from '../../store/lock.js';
+import { listEveryFeatureInOrder } from '../../store/ordering.js';
+import { getStyleRuleChannel, resolveFeatureStyle } from '../../view/style-rule.js';
+import { DrawError } from '../errors.js';
+import { applyResult } from './geometry/apply.js';
+import { runBuffer } from './geometry/buffer.js';
+import { runSplit } from './geometry/split.js';
+import { isAreaFeature, isBufferableFeature, isSplitLineFeature, toAreaCoordinates, toResultGeometry, } from './geometry/targets.js';
+import { describeGeometryProblem } from './import-export/geometry-validation.js';
+import { setOwnProperty } from './import-export/own-property.js';
+import { describeStyleProblem } from './import-export/style-validation.js';
+import { toAppliedDefaults } from './options.js';
+import { moveFeatures, resolveMoveTarget } from './placement.js';
+import { featureLocked, filterEntries, invalidInput, isRecord, isTaken, matches, notFound, onlyKeys, onlyLockOrVisibility, optionalBoolean, requireId, requireIds, requireRecord, } from './shared.js';
+const INPUT_KEYS = [
+    'type',
+    'geometry',
+    'id',
+    'layerId',
+    'groupId',
+    'properties',
+    'style',
+    'visible',
+    'locked',
+];
+const PATCH_KEYS = ['geometry', 'properties', 'style', 'visible', 'locked'];
+const FILTER_KEYS = ['layerId', 'groupId', 'type', 'visible', 'shown', 'locked', 'bbox'];
+/**
+ * Creates `draw.features`
+ *
+ * @internal
+ */
+export function createFeatures(deps) {
+    const { store } = deps;
+    const geometryDeps = {
+        store,
+        generateFeatureId: deps.generateId,
+    };
+    const require = (id) => {
+        const feature = typeof id === 'string' ? store.getFeature(id) : undefined;
+        if (!feature)
+            throw notFound('feature', id);
+        return feature;
+    };
+    const requireAll = (ids) => requireIds(ids).map(require);
+    /** The features in stacking order, from the back */
+    const inStackingOrder = (features) => {
+        const position = new Map(listEveryFeatureInOrder(store).map((f, index) => [f.id, index]));
+        return [...features].sort((a, b) => (position.get(a.id) ?? 0) - (position.get(b.id) ?? 0));
+    };
+    /**
+     * The checks of a filter: the entries compared as they are, and the IDs within the extent
+     * when the filter has one
+     */
+    const filterOf = (filter) => {
+        const all = filterEntries(filter, FILTER_KEYS);
+        const shown = all.find(([key]) => key === 'shown')?.[1];
+        if (shown !== undefined && typeof shown !== 'boolean') {
+            throw invalidInput('shown must be a boolean');
+        }
+        const entries = all.filter(([key]) => key !== 'shown');
+        const bbox = entries.find(([key]) => key === 'bbox')?.[1];
+        if (bbox === undefined)
+            return { entries, inside: null, shown };
+        if (!Array.isArray(bbox) ||
+            bbox.length !== 4 ||
+            bbox.some((value) => typeof value !== 'number' || !Number.isFinite(value))) {
+            throw invalidInput('bbox must be [west, south, east, north] in degrees');
+        }
+        const [minX, minY, maxX, maxY] = bbox;
+        const bounds = { minX, minY, maxX, maxY };
+        const inside = new Set(deps.spatialIndex
+            ? deps.spatialIndex.findInBounds(bounds)
+            : store
+                .listFeatures()
+                .filter((feature) => {
+                const box = getBoundingBox(feature);
+                return box.minX <= maxX && box.maxX >= minX && box.minY <= maxY && box.maxY >= minY;
+            })
+                .map((feature) => feature.id));
+        return { entries: entries.filter(([key]) => key !== 'bbox'), inside, shown };
+    };
+    /** Whether the feature, its group and its layer are all visible in the document */
+    const isShown = (feature) => feature.visible &&
+        (feature.groupId === undefined || store.getGroup(feature.groupId)?.visible !== false) &&
+        store.getLayer(feature.layerId)?.visible !== false;
+    const keep = (feature, { entries, inside, shown }) => (inside === null || inside.has(feature.id)) &&
+        (shown === undefined || isShown(feature) === shown) &&
+        matches(feature, entries);
+    const list = (filter) => {
+        const checks = filterOf(filter);
+        return listEveryFeatureInOrder(store).filter((feature) => keep(feature, checks));
+    };
+    return {
+        get: (id) => store.getFeature(id),
+        getMany(ids) {
+            if (!Array.isArray(ids))
+                throw invalidInput('The IDs must be an array');
+            return ids.map((id) => store.getFeature(id));
+        },
+        list,
+        count(filter) {
+            const checks = filterOf(filter);
+            if (checks.entries.length === 0 && checks.inside === null && checks.shown === undefined) {
+                return store.listFeatures().length;
+            }
+            return store.listFeatures().filter((feature) => keep(feature, checks)).length;
+        },
+        has: (id) => store.getFeature(id) !== undefined,
+        create(input) {
+            const feature = prepareFeature(deps, input, new Set());
+            if (store.isReadOnly())
+                return null;
+            store.createFeature(feature);
+            return store.getFeature(feature.id) ?? null;
+        },
+        createMany(inputs) {
+            if (!Array.isArray(inputs))
+                throw invalidInput('The inputs must be an array');
+            const pending = new Set();
+            const features = inputs.map((input) => {
+                const feature = prepareFeature(deps, input, pending);
+                pending.add(feature.id);
+                return feature;
+            });
+            if (store.isReadOnly())
+                return null;
+            store.transact(() => {
+                for (const feature of features)
+                    store.createFeature(feature);
+            });
+            return features.map((feature) => store.getFeature(feature.id));
+        },
+        update(id, patch) {
+            const feature = require(id);
+            const updates = preparePatch(feature, patch);
+            if (store.isReadOnly())
+                return null;
+            if (featureLocked(store, feature) && !onlyLockOrVisibility(patch))
+                return null;
+            store.updateFeature(feature.id, updates);
+            return store.getFeature(feature.id) ?? null;
+        },
+        updateMany(patches) {
+            if (!Array.isArray(patches))
+                throw invalidInput('The patches must be an array');
+            const seen = new Set();
+            const prepared = patches.map((entry) => {
+                requireRecord(entry, 'Each entry');
+                const feature = require(entry.id);
+                if (seen.has(feature.id))
+                    throw invalidInput(`The ID ${feature.id} is given twice`);
+                seen.add(feature.id);
+                return { feature, patch: entry.patch, updates: preparePatch(feature, entry.patch) };
+            });
+            if (store.isReadOnly())
+                return null;
+            const refused = prepared.some(({ feature, patch }) => featureLocked(store, feature) && !onlyLockOrVisibility(patch));
+            if (refused)
+                return null;
+            store.transact(() => {
+                for (const { feature, updates } of prepared)
+                    store.updateFeature(feature.id, updates);
+            });
+            return prepared.map(({ feature }) => store.getFeature(feature.id));
+        },
+        delete(id) {
+            const feature = require(id);
+            if (store.isReadOnly() || featureLocked(store, feature))
+                return false;
+            return store.deleteFeature(feature.id);
+        },
+        deleteMany(ids) {
+            const features = requireAll(ids);
+            if (store.isReadOnly())
+                return false;
+            if (features.some((feature) => featureLocked(store, feature)))
+                return false;
+            store.transact(() => {
+                for (const feature of features) {
+                    if (store.getFeature(feature.id))
+                        store.deleteFeature(feature.id);
+                }
+            });
+            return true;
+        },
+        move(id, to) {
+            return moveMany([id], to);
+        },
+        moveMany,
+        isEditable(id) {
+            const feature = require(id);
+            return !store.isReadOnly() && !isFeatureLocked(feature, store);
+        },
+        getAppliedStyle(id) {
+            const feature = store.getFeature(id);
+            if (!feature)
+                return undefined;
+            return appliedStyle(store, feature, deps.getStyleOptions());
+        },
+        union(ids) {
+            const inputs = requireAreas(ids, 2);
+            if (refuseChange(inputs))
+                return null;
+            return runAreaOperation(inputs, inputs[inputs.length - 1], inputs, unionAll);
+        },
+        difference(id, subtractIds) {
+            const [subject] = requireAreas([id], 1);
+            const others = requireAreas(subtractIds, 1);
+            if (others.some((other) => other.id === subject.id)) {
+                throw invalidInput('An area cannot be subtracted from itself');
+            }
+            if (refuseChange([subject]))
+                return null;
+            const inputs = inStackingOrder([subject, ...others]);
+            return runAreaOperation(inputs, subject, [subject], (areas) => differenceAll(areas[inputs.indexOf(subject)], areas.filter((_, index) => inputs[index] !== subject)));
+        },
+        intersection(ids) {
+            const inputs = requireAreas(ids, 2);
+            if (refuseChange(inputs))
+                return null;
+            return runAreaOperation(inputs, inputs[inputs.length - 1], inputs, intersectionAll);
+        },
+        split(id, lineId) {
+            const area = require(id);
+            const line = require(lineId);
+            if (!isAreaFeature(area))
+                throw invalidInput(`The feature ${area.id} is not an area`);
+            if (!isSplitLineFeature(line))
+                throw invalidInput(`The feature ${line.id} is not a line`);
+            if (refuseChange([area]))
+                return null;
+            return runSplit(geometryDeps, area, line, false).map((resultId) => store.getFeature(resultId));
+        },
+        buffer(ids, options) {
+            const inputs = inStackingOrder(requireAll(ids));
+            requireRecord(options, 'The options');
+            const { distanceMeters, segments } = options;
+            if (typeof distanceMeters !== 'number' || !Number.isFinite(distanceMeters)) {
+                throw invalidInput('distanceMeters must be a finite number');
+            }
+            if (segments !== undefined && (typeof segments !== 'number' || !(segments > 0))) {
+                throw invalidInput('segments must be a positive number');
+            }
+            for (const input of inputs) {
+                if (!isBufferableFeature(input)) {
+                    throw invalidInput(`The feature ${input.id} cannot be buffered`);
+                }
+            }
+            if (refuseChange(inputs))
+                return null;
+            if (distanceMeters === 0 || inputs.length === 0)
+                return [];
+            return runBuffer(geometryDeps, inputs, { distanceMeters, segments }, false).map((resultId) => store.getFeature(resultId));
+        },
+    };
+    function moveMany(ids, to) {
+        const features = inStackingOrder(requireAll(ids));
+        const target = resolveMoveTarget(store, to);
+        if (store.isReadOnly())
+            return false;
+        if (features.some((feature) => featureLocked(store, feature)))
+            return false;
+        if (target.locked)
+            return false;
+        moveFeatures(store, features, target);
+        return true;
+    }
+    /** The features as areas in stacking order, at least `min` of them */
+    function requireAreas(ids, min) {
+        const features = inStackingOrder(requireAll(ids));
+        if (features.length < min) {
+            throw invalidInput(`At least ${min} areas are needed`);
+        }
+        for (const feature of features) {
+            if (!isAreaFeature(feature))
+                throw invalidInput(`The feature ${feature.id} is not an area`);
+        }
+        return features;
+    }
+    /** Whether a change of these features is refused: read-only, or one of them is locked */
+    function refuseChange(features) {
+        return store.isReadOnly() || features.some((feature) => featureLocked(store, feature));
+    }
+    /**
+     * Runs a boolean operation on areas and puts the result in the place of `anchor`
+     *
+     * @returns The result, or null when the result has no area (nothing changes then)
+     */
+    function runAreaOperation(inputs, anchor, removed, compute) {
+        const areas = inputs.map((feature) => toAreaCoordinates(feature));
+        const geometry = toResultGeometry(compute(areas));
+        if (geometry === null)
+            return null;
+        const resultId = store.transact(() => applyResult(geometryDeps, {
+            anchor,
+            removedIds: removed.map((feature) => feature.id),
+            geometry,
+        }));
+        return store.getFeature(resultId) ?? null;
+    }
+}
+// ============================================================================
+// Inputs and patches
+// ============================================================================
+/** Checks an input and builds the feature to store; throws DrawError on a wrong input */
+function prepareFeature(deps, input, pending) {
+    const { store } = deps;
+    requireRecord(input, 'The input');
+    const record = input;
+    onlyKeys(record, INPUT_KEYS, 'The input');
+    if (typeof input.type !== 'string' || input.type === '') {
+        throw invalidInput('type must be a non-empty string');
+    }
+    const geometryProblem = describeGeometryProblem(input.type, input.geometry);
+    if (geometryProblem)
+        throw invalidInput(`The input has ${geometryProblem}`);
+    if (input.properties !== undefined && !isRecord(input.properties)) {
+        throw invalidInput('properties must be an object');
+    }
+    if (input.style !== undefined) {
+        const styleProblem = describeStyleProblem(input.style);
+        if (styleProblem)
+            throw invalidInput(`The input has ${styleProblem}`);
+    }
+    optionalBoolean(record, 'visible');
+    optionalBoolean(record, 'locked');
+    let id;
+    if (input.id === undefined) {
+        id = deps.generateId();
+    }
+    else {
+        id = requireId(input.id);
+        if (isTaken(store, id) || pending.has(id)) {
+            throw new DrawError('already-exists', `The ID ${JSON.stringify(id)} is already taken`, {
+                id,
+            });
+        }
+    }
+    const group = input.groupId === undefined ? undefined : store.getGroup(requireId(input.groupId));
+    if (input.groupId !== undefined && !group)
+        throw notFound('group', input.groupId);
+    let layerId;
+    if (input.layerId !== undefined) {
+        layerId = requireId(input.layerId);
+        if (!store.getLayer(layerId))
+            throw notFound('layer', layerId);
+        if (group && group.layerId !== layerId) {
+            throw invalidInput(`The group ${group.id} is not in the layer ${layerId}`);
+        }
+    }
+    else if (group) {
+        layerId = group.layerId;
+    }
+    else {
+        layerId = deps.getActiveLayerId();
+        if (!store.getLayer(layerId)) {
+            throw new DrawError('invalid-state', 'There is no layer to put the feature in');
+        }
+    }
+    return {
+        id,
+        type: input.type,
+        geometry: input.geometry,
+        layerId,
+        groupId: group?.id,
+        properties: withoutUndefined(input.properties ?? {}),
+        style: withoutUndefined(input.style ?? {}),
+        visible: input.visible ?? true,
+        locked: input.locked ?? false,
+    };
+}
+/**
+ * Checks a patch and builds the updates of the Store; throws DrawError on a wrong patch
+ *
+ * @internal
+ */
+export function preparePatch(feature, patch) {
+    requireRecord(patch, 'The patch');
+    const record = patch;
+    onlyKeys(record, PATCH_KEYS, 'The patch');
+    optionalBoolean(record, 'visible');
+    optionalBoolean(record, 'locked');
+    const updates = {};
+    if (patch.geometry !== undefined) {
+        const problem = describeGeometryProblem(feature.type, patch.geometry);
+        if (problem)
+            throw invalidInput(`The patch has ${problem}`);
+        updates.geometry = patch.geometry;
+    }
+    if (patch.properties !== undefined) {
+        if (!isRecord(patch.properties))
+            throw invalidInput('properties must be an object');
+        updates.properties = merged(feature.properties, patch.properties);
+    }
+    if (patch.style !== undefined) {
+        const problem = describeStyleProblem(patch.style);
+        if (problem)
+            throw invalidInput(`The patch has ${problem}`);
+        updates.style = merged(feature.style, patch.style);
+    }
+    if (patch.visible !== undefined)
+        updates.visible = patch.visible;
+    if (patch.locked !== undefined)
+        updates.locked = patch.locked;
+    return updates;
+}
+/** The keys of `base` with the keys of `patch` set, and removed where they are undefined */
+function merged(base, patch) {
+    const result = {};
+    for (const [key, value] of Object.entries(base))
+        setOwnProperty(result, key, value);
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined)
+            delete result[key];
+        else
+            setOwnProperty(result, key, value);
+    }
+    return result;
+}
+/** A copy without the keys whose value is undefined */
+function withoutUndefined(value) {
+    return merged({}, value);
+}
+// ============================================================================
+// The applied style
+// ============================================================================
+/**
+ * The look a feature is drawn with: the defaults of the options, the color of the layer rule
+ * and the style of the feature, in that order. The colors of the options and of the feature
+ * are the strings given, never rounded
+ */
+function appliedStyle(store, feature, style) {
+    const defaults = toAppliedDefaults(style, feature.type);
+    const layer = store.getLayer(feature.layerId);
+    const own = resolveFeatureStyle(feature, layer?.styleRule, getStyleRuleChannel(feature.type)) ?? {};
+    return { ...defaults, ...withoutUndefined(own) };
+}

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

@@ -0,0 +1,32 @@
+import type { Feature, FeatureCoordinates, FeatureType } from '../../../store/types.js';
+import type { GeometryDeps } 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 StoreChange.
+ */
+export declare function applyResult(deps: GeometryDeps, params: CommitParams): string;

package/dist/api/{geometry → impl/geometry}/apply.js

@@ -1,5 +1,7 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+import { setDrawProperty } from '../../../shared/properties.js';
+import { geometryFromCoordinates } from '../../../shared/utils/coordinates.js';
 /**
  * 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
@@ -17,7 +19,7 @@ const CIRCLE_ONLY_PROPERTIES = ['radiusMeters', 'radiusHandleAngle'];
  */
 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 container = group ? group.featureIds : (store.getLayer(anchor.layerId)?.items ?? []);
     const anchorIndex = container.indexOf(anchor.id);
     const precedingIds = anchorIndex < 0 ? container : container.slice(0, anchorIndex);
     const precedingCount = precedingIds.filter((id) => !removedIds.has(id)).length;
@@ -46,17 +48,17 @@ function moveToPlacement(store, resultId, placement) {
     const layer = store.getLayer(placement.layerId);
     if (!layer)
         return;
-    const order = layer.order.filter((id) => id !== resultId);
+    const order = layer.items.filter((id) => id !== resultId);
     order.splice(placement.index, 0, resultId);
-    store.updateLayer(placement.layerId, { order });
+    store.updateLayer(placement.layerId, { items: 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];
+    for (const name of CIRCLE_ONLY_PROPERTIES) {
+        setDrawProperty(properties, name, undefined);
     }
     return properties;
 }
@@ -64,7 +66,7 @@ function inheritProperties(anchor) {
  * 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.
+ * with several results, such as the buffer, is gathered into one StoreChange.
  */
 export function applyResult(deps, params) {
     const { store, generateFeatureId } = deps;
@@ -73,11 +75,11 @@ export function applyResult(deps, params) {
     const result = {
         id: generateFeatureId(),
         type: geometry.type,
-        coordinates: geometry.coordinates,
+        geometry: geometryFromCoordinates(geometry.type, geometry.coordinates),
         layerId: placement.layerId,
         groupId: placement.groupId,
         properties: params.properties ?? inheritProperties(anchor),
-        style: anchor.style ? { ...anchor.style } : undefined,
+        style: { ...anchor.style },
         locked: false,
         visible: true,
     };
@@ -93,22 +95,3 @@ export function applyResult(deps, params) {
     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 → impl/geometry}/buffer.d.ts

@@ -1,5 +1,5 @@
-import type { Feature } from '../../store/types.js';
-import type { GeometryApiDeps, GeometryBufferOptions } from './types.js';
+import type { Feature } from '../../../store/types.js';
+import type { BufferOptions, GeometryDeps } from './types.js';
 /**
  * Runs the buffer and creates the result features.
  *
@@ -7,5 +7,6 @@ import type { GeometryApiDeps, GeometryBufferOptions } from './types.js';
  * 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)
+ * @param select Whether the results become the selection
  */
-export declare function runBuffer(deps: GeometryApiDeps, inputs: Feature[], options: GeometryBufferOptions): string[];
+export declare function runBuffer(deps: GeometryDeps, inputs: Feature[], options: BufferOptions, select?: boolean): string[];

package/dist/api/{geometry → impl/geometry}/buffer.js

@@ -8,10 +8,12 @@
  * creates one result per input, several applyResult calls are gathered into one
  * store.transact, and all the results are selected at the end.
  */
+import { buffer as computeBuffer } from '../../../geometry/buffer.js';
 // 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 { drawProperties } from '../../../shared/properties.js';
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
+import { getCircleRadius } from '../../../shared/utils/property.js';
+import { applyResult } from './apply.js';
 import { toBufferGeometry, toResultGeometry } from './targets.js';
 /**
  * Plans the buffer of a Circle input.
@@ -29,10 +31,10 @@ function planCircleBuffer(input, distanceMeters) {
         return null;
     return {
         input,
-        geometry: { type: 'Circle', coordinates: input.coordinates },
+        geometry: { type: 'Circle', coordinates: coordinatesOf(input) },
         // It stays a Circle, so the properties including radiusHandleAngle are inherited and only
         // the radius is replaced.
-        properties: { ...input.properties, radiusMeters: nextRadius },
+        properties: { ...input.properties, ...drawProperties({ radiusMeters: nextRadius }) },
     };
 }
 /**
@@ -63,8 +65,9 @@ function planBuffer(input, options) {
  * 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)
+ * @param select Whether the results become the selection
  */
-export function runBuffer(deps, inputs, options) {
+export function runBuffer(deps, inputs, options, select = true) {
     const { store } = deps;
     const plans = [];
     for (const input of inputs) {
@@ -73,15 +76,7 @@ export function runBuffer(deps, inputs, options) {
             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',
-        });
+        // Every input was skipped or had an empty result. The Store is not changed at all.
         return [];
     }
     const resultIds = store.transact(() => {
@@ -91,15 +86,9 @@ export function runBuffer(deps, inputs, options) {
             geometry: plan.geometry,
             properties: plan.properties,
         }));
-        store.setSelection('feature', ids);
+        if (select)
+            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 → impl/geometry}/split.d.ts

@@ -1,5 +1,5 @@
-import type { Feature } from '../../store/types.js';
-import type { GeometryApiDeps } from './types.js';
+import type { Feature } from '../../../store/types.js';
+import type { GeometryDeps } from './types.js';
 /**
  * Runs the split and replaces the polygon with the group of features that result from the
  * split.
@@ -12,5 +12,6 @@ import type { GeometryApiDeps } from './types.js';
  *
  * @param area The polygon to be cut
  * @param line The cutting line (it is not deleted and remains)
+ * @param select Whether the results become the selection
  */
-export declare function runSplit(deps: GeometryApiDeps, area: Feature, line: Feature): string[];
+export declare function runSplit(deps: GeometryDeps, area: Feature, line: Feature, select?: boolean): string[];