@sakuzu/maplibre-gl-draw-ui 1.0.0

package/dist/inspector/attributes.d.ts

@@ -0,0 +1,46 @@
+import { type Feature, type FeaturePatch } from '@sakuzu/maplibre-gl-draw';
+/** The attribute that holds the name of a feature */
+export declare const NAME_KEY = "name";
+/** The attribute that holds the description of a feature */
+export declare const DESCRIPTION_KEY = "description";
+/** An attribute as the list shows it */
+export interface AttributeRow {
+    key: string;
+    value: string;
+}
+/** Whether a key of `properties` is kept out of the list of attributes */
+export declare function isReservedKey(key: string): boolean;
+/** A value of `properties` as a string */
+export declare function showValue(value: unknown): string;
+/** The name of a feature, or an empty string */
+export declare function featureName(feature: Pick<Feature, 'properties'>): string;
+/** The description of a feature, or an empty string */
+export declare function featureDescription(feature: Pick<Feature, 'properties'>): string;
+/** The attributes of a feature, in the order of `properties` */
+export declare function attributeRows(feature: Pick<Feature, 'properties'>): AttributeRow[];
+/** The patch that names a feature; an empty name removes the attribute */
+export declare function namePatch(name: string): FeaturePatch;
+/** The patch that describes a feature; an empty description removes the attribute */
+export declare function descriptionPatch(text: string): FeaturePatch;
+/**
+ * The patch of a change of the attribute at `index` of {@link attributeRows}: a new value, a
+ * new name (the old key removed and the new one set), or both. When only the name changes, the
+ * value keeps its type.
+ *
+ * @returns The patch, or null when nothing changes, there is no attribute at `index`, or the
+ *   new name is empty, is the name of another attribute, or is kept (`name`, `description`, a
+ *   key of the library)
+ */
+export declare function attributePatch(feature: Pick<Feature, 'properties'>, index: number, next: AttributeRow): FeaturePatch | null;
+/**
+ * The patch that adds an attribute
+ *
+ * @returns The patch, or null when the name is empty, is taken, or is kept
+ */
+export declare function attributeAdd(feature: Pick<Feature, 'properties'>, item: AttributeRow): FeaturePatch | null;
+/**
+ * The patch that removes the attribute at `index` of {@link attributeRows}
+ *
+ * @returns The patch, or null when there is no attribute at `index`
+ */
+export declare function attributeRemove(feature: Pick<Feature, 'properties'>, index: number): FeaturePatch | null;

package/dist/inspector/measure.d.ts

@@ -0,0 +1,25 @@
+import type { Feature } from '@sakuzu/maplibre-gl-draw';
+import type { Units } from './types.js';
+/** What a row of the measurements is */
+export type MeasureKey = 'longitude' | 'latitude' | 'length' | 'area' | 'perimeter' | 'radius' | 'points';
+/** A row of the measurements: what it is and the value, written out */
+export interface MeasureRow {
+    key: MeasureKey;
+    value: string;
+}
+/** A length in meters, written in the units */
+export declare function formatLength(meters: number, units: Units, locale?: string): string;
+/** An area in square meters, written in the units */
+export declare function formatArea(squareMeters: number, units: Units, locale?: string): string;
+/** A longitude or a latitude in degrees, with six decimals */
+export declare function formatDegrees(degrees: number, locale?: string): string;
+/**
+ * The measurements of a feature: the coordinates of a point, the length of a line, the area and
+ * the perimeter of an area (and the radius of a circle), the number of points of a MultiPoint.
+ * An image and a custom type have none.
+ *
+ * @param feature - The feature
+ * @param units - Metric or imperial
+ * @param locale - The language tag the numbers are written in
+ */
+export declare function measure(feature: Feature, units: Units, locale?: string): MeasureRow[];

package/dist/inspector/operations.d.ts

@@ -0,0 +1,44 @@
+import type { Feature } from '@sakuzu/maplibre-gl-draw';
+import type { InspectorDraw, Units } from './types.js';
+/** An operation on the features selected */
+export type OperationId = 'union' | 'intersection' | 'difference' | 'split' | 'buffer';
+/** The operations, in the order they are offered */
+export declare const OPERATION_IDS: readonly OperationId[];
+/** Whether a feature is an area that union, intersection, difference and split take */
+export declare function isArea(feature: Pick<Feature, 'type' | 'properties'>): boolean;
+/** Whether a feature is a line that a split cuts along */
+export declare function isCuttingLine(feature: Pick<Feature, 'type'>): boolean;
+/** Whether a feature is one that buffer takes */
+export declare function isBufferable(feature: Pick<Feature, 'type' | 'properties'>): boolean;
+/** The area and the line of a split, or null when the features are not one of each */
+export declare function splitPair<T extends Pick<Feature, 'type' | 'properties'>>(features: readonly T[]): {
+    area: T;
+    line: T;
+} | null;
+/** The operations that apply to features, in order */
+export declare function applicableOperations(features: readonly Pick<Feature, 'type' | 'properties'>[]): OperationId[];
+/** The units of the distance of a buffer */
+export type DistanceUnit = 'm' | 'km' | 'ft' | 'mi';
+/** The units of the distance offered for a system of units, the first being the default */
+export declare function distanceUnits(units: Units): DistanceUnit[];
+/** A distance in meters */
+export declare function toMeters(value: number, unit: DistanceUnit): number;
+/**
+ * Runs union, intersection, difference or split on features, and selects what it made
+ *
+ * @param features - The features, in the order of the selection (difference subtracts the
+ *   others from the first)
+ * @returns The IDs of the features made (empty when the line did not cut the area), or null when
+ *   core refused the operation (read-only, a lock) or its result is empty
+ * @throws `DrawError` of core when the features do not suit the operation
+ */
+export declare function runOperation(draw: InspectorDraw, op: Exclude<OperationId, 'buffer'>, features: readonly Feature[]): string[] | null;
+/**
+ * Makes the buffers of features and selects them
+ *
+ * @param distanceMeters - The distance of the outline from the features, in meters
+ * @param segments - The segments of a full circle; core's default when left out
+ * @returns The IDs of the features made, or null when core refused the operation
+ * @throws `DrawError` of core when a feature cannot be buffered or the distance is not finite
+ */
+export declare function runBuffer(draw: InspectorDraw, features: readonly Feature[], distanceMeters: number, segments?: number): string[] | null;

package/dist/inspector/sections.d.ts

@@ -0,0 +1,20 @@
+import type { Feature } from '@sakuzu/maplibre-gl-draw';
+import type { Box } from '../store.js';
+import type { InspectorOptions, InspectorSectionSpec, InspectorSectionsHandle, InspectorSettings, Units } from './types.js';
+/**
+ * The options of the inspector with their defaults
+ *
+ * @param units - The units when the options name none (those of `createDrawUI`)
+ * @throws Error when a tab is not `style` or `attributes`
+ */
+export declare function inspectorSettings(options?: InspectorOptions, units?: Units): InspectorSettings;
+/**
+ * Checks a section of the application
+ *
+ * @throws Error when the ID or the title is missing, or `appliesTo` is not a function
+ */
+export declare function checkSection(spec: InspectorSectionSpec): void;
+/** The sections that apply to features; a section whose appliesTo throws does not */
+export declare function applicableSections(sections: readonly InspectorSectionSpec[], features: readonly Feature[]): InspectorSectionSpec[];
+/** The sections of an inspector, to add to and to remove from */
+export declare function sectionsHandle(sections: Box<InspectorSectionSpec[]>): InspectorSectionsHandle;

package/dist/inspector/style.d.ts

@@ -0,0 +1,57 @@
+import type { Feature, FeatureStyle, FeatureStyleResolved, FeatureType } from '@sakuzu/maplibre-gl-draw';
+import type { Messages } from '../messages.js';
+import type { InspectorDraw, InspectorField } from './types.js';
+/** A key of the style that the inspector edits */
+export type StyleKey = keyof FeatureStyleResolved;
+/** The kind of style a type reads */
+export type StyleKind = 'point' | 'line' | 'area' | 'image';
+/** The values of the line style, as core's LineStyle has them */
+export declare const LINE_STYLES: readonly ["solid", "dashed", "dotted"];
+/** The shapes of a point marker, as core's PointShape has them */
+export declare const POINT_SHAPES: readonly ["circle", "square", "triangle", "star"];
+/** The keys of each kind, in the order of the fields */
+export declare const STYLE_KEYS: Readonly<Record<StyleKind, readonly StyleKey[]>>;
+/** The kind of style of a type, or null for a custom type */
+export declare function styleKind(type: FeatureType): StyleKind | null;
+/** The keys a type reads, in order; none for a custom type */
+export declare function styleKeys(type: FeatureType): readonly StyleKey[];
+/** Whether a key is an opacity, shown as a percentage */
+export declare function isPercentKey(key: string): boolean;
+/** A value of the style as the field shows it: an opacity as a whole percentage */
+export declare function displayValue(key: StyleKey, value: unknown): unknown;
+/**
+ * The keys the features share, in the order of the first one's: the keys of every type of the
+ * selection. Empty when one of them is of a custom type, or when there is no feature
+ */
+export declare function sharedStyleKeys(features: readonly Pick<Feature, 'type'>[]): StyleKey[];
+/**
+ * The fields of the style of features: the keys they share, each with the value they are drawn
+ * with, or `mixed` when their values differ.
+ *
+ * @param features - The features selected
+ * @param applied - The look of a feature as core resolves it (`draw.features.getAppliedStyle`);
+ *   a feature it gives nothing for shows the keys of its own style
+ * @param messages - The words
+ * @param disabled - Whether the fields cannot be changed (read-only, a lock)
+ */
+export declare function styleFields(features: readonly Feature[], applied: (id: string) => FeatureStyleResolved | undefined, messages: Messages, disabled?: boolean): InspectorField[];
+/**
+ * The style that a change of a field writes: an opacity from a percentage to a fraction (clamped
+ * to 0..1), a number as it is, a color or a choice as a string. An empty value (a number
+ * input emptied) removes the key, so the feature takes the layer rule or the default again.
+ */
+export declare function stylePatch(key: string, value: unknown): FeatureStyle;
+/**
+ * The keys of the inspector's fields that the features set in their own style, over the layer
+ * rule and the defaults. Keys the features share no field for (keys of an extension) are left
+ * out, so a reset does not touch them
+ */
+export declare function ownStyleKeys(features: readonly Pick<Feature, 'type' | 'style'>[]): StyleKey[];
+/** The style that removes keys, so the features take the layer rule or the defaults again */
+export declare function resetPatch(keys: readonly string[]): FeatureStyle;
+/**
+ * Writes a style into features, in one transaction
+ *
+ * @returns The features after the change, or null when core refused it (read-only, a lock)
+ */
+export declare function applyStyle(draw: Pick<InspectorDraw, 'transact' | 'features'>, ids: readonly string[], style: FeatureStyle): Feature[] | null;

package/dist/inspector/types.d.ts

@@ -0,0 +1,121 @@
+import type { Draw, Feature } from '@sakuzu/maplibre-gl-draw';
+/** A tab of the inspector of a feature */
+export type InspectorTab = 'style' | 'attributes';
+/** The units of the measurements and of the distance of a buffer */
+export type Units = 'metric' | 'imperial';
+/** What the inspector shows */
+export interface InspectorOptions {
+    /** The tabs of a feature, in order; both when left out */
+    tabs?: InspectorTab[];
+    /**
+     * Whether the measurements of a feature show under its name, before the tabs; true when left
+     * out
+     */
+    measurements?: boolean;
+    /** Whether the operations (union, intersection, difference, split, buffer) show; true when left out */
+    operations?: boolean;
+    /** The units of the measurements; `metric` when left out */
+    units?: Units;
+}
+/** The kind of the control of a field of a section */
+export type InspectorFieldKind = 'text' | 'number' | 'select' | 'color' | 'toggle' | 'slider' | 'segmented';
+/**
+ * A field of a section of the inspector: a name and the control that changes one value. The
+ * values are the application's; a unit is text after the value
+ */
+export interface InspectorField {
+    /** The key the change is reported with */
+    key: string;
+    /** The control */
+    kind: InspectorFieldKind;
+    /** The name before the control */
+    label: string;
+    /** The current value */
+    value?: unknown;
+    /** The features selected do not share one value; no value shows */
+    mixed?: boolean;
+    /** The choices of `select` and `segmented` */
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    /** The range of `number` and `slider` */
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Text after the value, such as `px` or `%` */
+    unit?: string;
+    /** A word shown while a text or a number is empty */
+    placeholder?: string;
+    /** The control cannot be changed */
+    disabled?: boolean;
+    /** A caption under the control */
+    hint?: string;
+}
+/**
+ * A section an application adds to the inspector of features. It shows, on the Style tab of one
+ * feature and among the fields of several, when `appliesTo` accepts the features selected.
+ *
+ * The section either lists fields, whose changes go to `onchange`, or draws itself with `render`
+ * (or both: the fields first, then what `render` draws).
+ */
+export interface InspectorSectionSpec {
+    /** The name of the section, unique in the inspector */
+    id: string;
+    /** The title of the section */
+    title: string;
+    /** Whether the section shows for these features */
+    appliesTo: (features: readonly Feature[]) => boolean;
+    /** The fields of the section for these features */
+    fields?: (features: readonly Feature[]) => InspectorField[];
+    /** Called with the key and the value of a field that was changed, and the features */
+    onchange?: (key: string, value: unknown, features: readonly Feature[]) => void;
+    /**
+     * Draws the section into an element, for what fields cannot show. It is called again with a
+     * new element when the features change; the function it returns, if any, is called before that
+     * and when the section goes away
+     */
+    render?: (element: HTMLElement, features: readonly Feature[]) => undefined | (() => void);
+}
+/** The sections of the inspector that an application added */
+export interface InspectorSectionsHandle {
+    /**
+     * Adds a section after the sections added before it
+     *
+     * @returns The function that removes it again
+     * @throws Error when the section is not valid or its ID is taken
+     */
+    add(spec: InspectorSectionSpec): () => void;
+    /**
+     * Removes a section
+     *
+     * @returns Whether there was a section with this ID
+     */
+    remove(id: string): boolean;
+    /** The sections, in order */
+    list(): InspectorSectionSpec[];
+}
+/** An inspector on the page */
+export interface InspectorHandle {
+    /** The element of the inspector */
+    readonly element: HTMLElement;
+    /** The sections an application added */
+    readonly sections: InspectorSectionsHandle;
+    /** Removes the inspector. A second call does nothing */
+    destroy(): void;
+}
+/** The options of the inspector with their defaults applied */
+export interface InspectorSettings {
+    tabs: InspectorTab[];
+    measurements: boolean;
+    operations: boolean;
+    units: Units;
+}
+/** The members of a draw instance that the inspector uses */
+export type InspectorDraw = Pick<Draw, 'on' | 'off' | 'transact' | 'isReadOnly'> & {
+    readonly features: Pick<Draw['features'], 'get' | 'getMany' | 'getAppliedStyle' | 'update' | 'updateMany' | 'isEditable' | 'union' | 'difference' | 'intersection' | 'split' | 'buffer'>;
+    readonly selection: Pick<Draw['selection'], 'get' | 'set' | 'clear' | 'delete' | 'group' | 'ungroup'>;
+    readonly hidden: Pick<Draw['hidden'], 'has' | 'add' | 'remove'>;
+    readonly layers: Pick<Draw['layers'], 'get' | 'update' | 'count'>;
+    readonly groups: Pick<Draw['groups'], 'get' | 'update'>;
+};

package/dist/inspector/view.d.ts

@@ -0,0 +1,84 @@
+import type { Feature, FeatureStyleResolved, FeatureType, Group, Layer } from '@sakuzu/maplibre-gl-draw';
+import type { Messages } from '../messages.js';
+import { type MeasureRow } from './measure.js';
+import type { InspectorDraw, InspectorSettings, InspectorTab } from './types.js';
+/** The events after which the inspector reads the draw instance again */
+export declare const INSPECTOR_EVENTS: readonly ["selection.changed", "document.changed", "hidden.changed", "readOnly.changed"];
+/** One feature, with what its inspector needs */
+export interface FeatureView {
+    kind: 'feature';
+    feature: Feature;
+    /** The look it is drawn with */
+    applied: FeatureStyleResolved | undefined;
+    /** Its layer */
+    layer: Layer | undefined;
+    /** Whether it can be edited now (not read-only, no lock on it, its group or its layer) */
+    editable: boolean;
+    /** Whether the document is read-only */
+    readOnly: boolean;
+    /** Whether this client hides it */
+    hidden: boolean;
+}
+/** What the inspector shows */
+export type InspectorView = {
+    kind: 'empty';
+} | FeatureView | {
+    kind: 'features';
+    features: Feature[];
+    applied: (FeatureStyleResolved | undefined)[];
+    editable: boolean;
+    readOnly: boolean;
+} | {
+    kind: 'layer';
+    layer: Layer;
+    onlyLayer: boolean;
+    readOnly: boolean;
+} | {
+    kind: 'group';
+    group: Group;
+    layer: Layer | undefined;
+    readOnly: boolean;
+} | {
+    kind: 'items';
+    type: 'layer' | 'group';
+    count: number;
+    readOnly: boolean;
+};
+/** Reads what the inspector shows */
+export declare function readView(draw: InspectorDraw): InspectorView;
+/** What the inspector of one feature shows under its head and in its tabs */
+export interface FeatureLayout {
+    /** The measurements under the head, before the tabs; none when the options leave them out */
+    measurements: MeasureRow[];
+    /**
+     * The description under the head, before the tabs: its text, and whether it can be changed
+     * (an empty one then shows the action that adds it). Null when it is empty and cannot be
+     * changed
+     */
+    description: {
+        text: string;
+        editable: boolean;
+    } | null;
+    /** The tabs, in the order of the options; the Style tab only when it has something to show */
+    tabs: InspectorTab[];
+    /** Whether the Style tab has the fields of the style */
+    style: boolean;
+    /** Whether the Style tab has the buffer, at its end */
+    buffer: boolean;
+}
+/**
+ * Lays out the inspector of one feature
+ *
+ * @param view - The feature, as readView gives it
+ * @param settings - The options of the inspector
+ * @param sections - The number of the sections of the application that apply to the feature
+ * @param locale - The language tag the numbers of the measurements are written in
+ */
+export declare function featureLayout(view: Pick<FeatureView, 'feature' | 'editable'>, settings: InspectorSettings, sections: number, locale?: string): FeatureLayout;
+/** The name of a type: the words of the built-in types, and a custom type as it is named */
+export declare function typeLabel(type: FeatureType, m: Messages): string;
+/** The number of features of each type, in the order the types first appear */
+export declare function kindCounts(features: readonly Pick<Feature, 'type'>[], m: Messages): {
+    label: string;
+    count: number;
+}[];

package/dist/layers/legend.d.ts

@@ -0,0 +1,36 @@
+import { type Messages as CoreMessages, type Feature, type Layer, type LegendEntry } from '@sakuzu/maplibre-gl-draw';
+import type { Messages } from '../messages.js';
+/** The shape of the swatches of a layer, after the kind of what its features draw */
+export type LegendShape = 'box' | 'dot' | 'line' | 'area';
+/** The legend of one layer */
+export interface LegendBlock {
+    /** The ID of the layer */
+    layerId: string;
+    /** The name of the layer */
+    name: string;
+    /** The rows, in the order to show them */
+    entries: LegendEntry[];
+    /** The shape of the swatches */
+    shape: LegendShape;
+}
+/** What the legend reads from the draw instance */
+export interface LegendSource {
+    readonly layers: {
+        get(id: string): Layer | undefined;
+        getOrder(): readonly string[];
+    };
+    readonly features: {
+        list(filter?: {
+            layerId?: string;
+        }): Feature[];
+    };
+}
+/** The words of the labels of a legend, for `deriveLegend` */
+export declare function legendMessages(m: Messages): Partial<CoreMessages>;
+/**
+ * The shape of the swatches for the features of a layer: a dot for points, a line for lines, an
+ * area for areas, and a box when they are mixed or there are none
+ */
+export declare function legendShape(features: readonly Feature[]): LegendShape;
+/** The legend of every layer with a style rule, from the front */
+export declare function legendBlocks(source: LegendSource, m: Messages): LegendBlock[];

package/dist/layers/move.d.ts

@@ -0,0 +1,30 @@
+import type { TreeMove } from '@sakuzu/kata/svelte';
+import type { MoveTarget } from '@sakuzu/maplibre-gl-draw';
+import { type LayerTreeNode } from './tree.js';
+/** The call of core a drop makes */
+export type MovePlan = {
+    kind: 'layers';
+    order: string[];
+} | {
+    kind: 'group';
+    id: string;
+    to: MoveTarget;
+} | {
+    kind: 'feature';
+    id: string;
+    to: MoveTarget;
+};
+/**
+ * The position in a list of core, from the back, of an item that goes just in front of `behind`
+ * (a node of the tree, or undefined when the item goes to the back)
+ */
+export declare function coreIndex(coreList: readonly string[], id: string, behind: string | undefined): number;
+/**
+ * The call of core for a drop in the tree
+ *
+ * @param move - What the tree reported: the node, its new parent (null for the root) and its
+ *   index among the parent's children after the move, from the front
+ * @param nodes - The nodes the tree showed when the node was dropped
+ * @returns The call, or null when the drop is not one the tree allows
+ */
+export declare function planMove(move: TreeMove, nodes: readonly LayerTreeNode[]): MovePlan | null;

package/dist/layers/tree.d.ts

@@ -0,0 +1,87 @@
+import type { IconComponent, IconSource, TreeNode } from '@sakuzu/kata/svelte';
+import { type Group as DrawGroup, type Feature, type FeatureStyleResolved, type Layer, type Selection, type SelectionType } from '@sakuzu/maplibre-gl-draw';
+import type { Messages } from '../messages.js';
+/** The kinds of the nodes, which are the types of the selection of core */
+export type NodeKind = SelectionType;
+/** A node of the tree, with the entity of core it was built from */
+export type LayerTreeNode = TreeNode & {
+    kind: NodeKind;
+    data: Layer | DrawGroup | Feature;
+};
+/** What building the nodes reads from the draw instance */
+export interface TreeSource {
+    readonly layers: {
+        get(id: string): Layer | undefined;
+        getOrder(): readonly string[];
+    };
+    readonly groups: {
+        get(id: string): DrawGroup | undefined;
+    };
+    readonly features: {
+        get(id: string): Feature | undefined;
+        getAppliedStyle(id: string): FeatureStyleResolved | undefined;
+    };
+    /** What this client hides; a node it hides shows as hidden */
+    readonly hidden?: {
+        has(id: string): boolean;
+    };
+}
+/** What the tree shows */
+export interface TreeOptions {
+    /** Whether the features show under the layers and the groups */
+    features: boolean;
+}
+/** The icon of a layer and of a group */
+export declare const LAYER_ICON: IconComponent;
+export declare const GROUP_ICON: IconComponent;
+/** The icon of a feature type */
+export declare function typeIcon(type: string): IconSource;
+/** The words for each built-in feature type, from the set of the interface */
+export declare function typeLabel(type: string, m: Messages): string;
+/**
+ * The name of a feature: `properties.name` (the name the interface shows and edits, by the
+ * convention of the interface; core has no name of its own for a feature), or the word of its
+ * type when it has none
+ */
+export declare function featureName(feature: Feature, m: Messages): string;
+/**
+ * The color of the mark of a feature: the color it is drawn with, of the part a style rule colors
+ * (the marker of a point, the line of a line, the fill of an area). An image has none
+ */
+export declare function featureColor(feature: Feature, style: FeatureStyleResolved | undefined): string | undefined;
+/**
+ * The nodes of the tree: the layers from the front, each with its groups and features from the
+ * front, and the features of each group from the front.
+ *
+ * An ID of the stacking order that is not a layer (a dataset placed among the layers) is left
+ * out, and so is an item of a layer that is neither a group nor a feature. A feature shows once,
+ * under its group when it is in one.
+ */
+export declare function buildNodes(source: TreeSource, m: Messages, options?: TreeOptions): LayerTreeNode[];
+/** Every node of the tree by its ID, with the ID of its parent */
+export declare function indexNodes(nodes: readonly LayerTreeNode[]): Map<string, {
+    node: LayerTreeNode;
+    parentId: string | null;
+}>;
+/** The rows the tree shows as selected: what draw has selected, of any of the three types */
+export declare function selectedIds(selection: Selection): string[];
+/**
+ * What a press in the tree selects in draw, which holds one type at a time: the IDs of the new
+ * selection that are of the kind of the node pressed last. With no node pressed (a key, a range
+ * without a pointer), the kind of the last ID.
+ *
+ * @returns The type and the IDs, or null to clear the selection
+ */
+export declare function selectionOf(ids: readonly string[], kindOf: (id: string) => NodeKind | undefined, pressed?: NodeKind): {
+    type: NodeKind;
+    ids: string[];
+} | null;
+/**
+ * Whether a node may be dropped into a parent (null for the root): a layer only at the root, a
+ * group only into a layer, a feature into a layer or a group
+ */
+export declare function canDropInto(node: TreeNode, parent: TreeNode | null): boolean;
+/**
+ * Whether the selected features can make a new group: two or more, all in one layer
+ */
+export declare function canGroup(selection: Selection, getFeature: (id: string) => Feature | undefined): boolean;

package/dist/locales/en.d.ts

@@ -0,0 +1,3 @@
+import type { Messages } from '../messages.js';
+/** The English words, the default */
+export declare const en: Readonly<Messages>;

package/dist/locales/ja.d.ts

@@ -0,0 +1,3 @@
+import type { Messages } from '../messages.js';
+/** The Japanese words */
+export declare const ja: Readonly<Messages>;