@sakuzu/maplibre-gl-draw 1.0.0

package/dist/shared/utils/feature-segments.js

@@ -0,0 +1,179 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * The edges of a feature
+ *
+ * Lists the edges (and the parts) of a feature with their vertex references. The snapping
+ * providers and the tracing graph (operations/trace-graph.ts) both enumerate edges this way,
+ * so the listing sits in shared/. It is pure: it reads only the coordinates of the feature.
+ */
+import { getSegmentGrid, querySegmentIndicesInBBox, SEGMENT_INDEX_THRESHOLD, } from '../math/segment-grid.js';
+/**
+ * Whether the feature type has edges (whether it is a target of edge snapping)
+ *
+ * It is aligned with the types that support vertex editing. Point has vertices only,
+ * and Circle / Image / Freehand are out of scope.
+ */
+export function hasSnapEdges(type) {
+    return (type === 'LineString' ||
+        type === 'Polygon' ||
+        type === 'MultiLineString' ||
+        type === 'MultiPolygon');
+}
+/**
+ * Whether the segment overlaps the bbox (a cheap preliminary test)
+ *
+ * The real test against the tolerance is done by SnapService using the distance to
+ * the nearest point, so all this guarantees is that nothing is missed.
+ */
+export function segmentIntersectsBBox(start, end, bbox) {
+    const minX = Math.min(start[0], end[0]);
+    const maxX = Math.max(start[0], end[0]);
+    const minY = Math.min(start[1], end[1]);
+    const maxY = Math.max(start[1], end[1]);
+    return minX <= bbox.maxX && maxX >= bbox.minX && minY <= bbox.maxY && maxY >= bbox.minY;
+}
+/**
+ * Whether the point is inside the bbox (the boundary included)
+ *
+ * @internal
+ */
+export function isInBBox(position, bbox) {
+    return (position[0] >= bbox.minX &&
+        position[0] <= bbox.maxX &&
+        position[1] >= bbox.minY &&
+        position[1] <= bbox.maxY);
+}
+/**
+ * Lists the parts of a feature per type
+ *
+ * A helper that lets the listing of edges and the listing of vertices share the
+ * branching on type. Types without edges (Point / MultiPoint / custom types) call
+ * nothing.
+ *
+ * @internal
+ */
+export function forEachPart(feature, visit) {
+    switch (feature.type) {
+        case 'LineString':
+            visit(feature.coordinates, 0, undefined, false);
+            break;
+        case 'Polygon': {
+            const rings = feature.coordinates;
+            for (let ring = 0; ring < rings.length; ring++) {
+                visit(rings[ring], ring, undefined, true);
+            }
+            break;
+        }
+        case 'MultiLineString': {
+            const parts = feature.coordinates;
+            for (let part = 0; part < parts.length; part++) {
+                visit(parts[part], 0, part, false);
+            }
+            break;
+        }
+        case 'MultiPolygon': {
+            const parts = feature.coordinates;
+            for (let part = 0; part < parts.length; part++) {
+                const rings = parts[part];
+                for (let ring = 0; ring < rings.length; ring++) {
+                    visit(rings[ring], ring, part, true);
+                }
+            }
+            break;
+        }
+    }
+}
+/**
+ * Builds a function that builds vertex references
+ *
+ * @internal
+ */
+export function makeRefFactory(ring, part) {
+    return (index) => part === undefined ? { ring, index } : { part, ring, index };
+}
+/**
+ * Whether the coordinate sequence is closed (whether the last item is a copy of the
+ * first one)
+ *
+ * @internal
+ */
+export function isClosedCoords(coords) {
+    if (coords.length === 0)
+        return false;
+    const first = coords[0];
+    const last = coords[coords.length - 1];
+    return first[0] === last[0] && first[1] === last[1];
+}
+/**
+ * Gathers the edges of one coordinate sequence (a line / a ring)
+ *
+ * In a ring where closed is true, the last item is a copy of the first one, so the
+ * vertex reference of the last item is normalized to index 0 (to make the test for
+ * exclusion match the vertex handles).
+ */
+function collectSegments(coords, ring, part, visit) {
+    if (coords.length < 2)
+        return;
+    const closed = isClosedCoords(coords);
+    const vertexCount = closed ? coords.length - 1 : coords.length;
+    const toRef = makeRefFactory(ring, part);
+    for (let i = 0; i < coords.length - 1; i++) {
+        const endIndex = closed && i + 1 === vertexCount ? 0 : i + 1;
+        visit(coords[i], coords[i + 1], toRef(i), toRef(endIndex));
+    }
+}
+/**
+ * Gathers only the edges of one coordinate sequence (a line / a ring) that fall
+ * within the bbox
+ *
+ * For a part whose vertex count is at or above the threshold, the candidates are
+ * narrowed down with a segment grid index. The values passed to visit are exactly the
+ * same as in collectSegments (the last item of a closed ring is normalized to index
+ * 0).
+ */
+function collectSegmentsInBBox(coords, ring, part, bbox, visit) {
+    if (coords.length < 2)
+        return;
+    const closed = isClosedCoords(coords);
+    const vertexCount = closed ? coords.length - 1 : coords.length;
+    const toRef = makeRefFactory(ring, part);
+    const visitSegment = (i) => {
+        if (!segmentIntersectsBBox(coords[i], coords[i + 1], bbox))
+            return;
+        const endIndex = closed && i + 1 === vertexCount ? 0 : i + 1;
+        visit(coords[i], coords[i + 1], toRef(i), toRef(endIndex));
+    };
+    // For a small part, building an index costs more, so it is scanned as it is
+    if (coords.length < SEGMENT_INDEX_THRESHOLD) {
+        for (let i = 0; i < coords.length - 1; i++) {
+            visitSegment(i);
+        }
+        return;
+    }
+    for (const i of querySegmentIndicesInBBox(getSegmentGrid(coords), bbox)) {
+        visitSegment(i);
+    }
+}
+/**
+ * Gathers the edges of a feature
+ *
+ * @internal
+ */
+export function collectFeatureSegments(feature, visit) {
+    forEachPart(feature, (coords, ring, part) => {
+        collectSegments(coords, ring, part, visit);
+    });
+}
+/**
+ * Gathers only the edges of a feature that fall within the bbox
+ *
+ * The result is the same as applying a preliminary bbox filter to
+ * collectFeatureSegments; only for a huge part is the listing narrowed down with a
+ * segment grid index.
+ */
+export function collectFeatureSegmentsInBBox(feature, bbox, visit) {
+    forEachPart(feature, (coords, ring, part) => {
+        collectSegmentsInBBox(coords, ring, part, bbox, visit);
+    });
+}

package/dist/shared/utils/id.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/utils/id.js

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * The generation of the ids of features, groups, layers and files
+ *
+ * An id is a ULID (the time in milliseconds followed by 80 random bits, in Crockford's Base32), so
+ * ids of later milliseconds sort after earlier ones. The `ulid` package encodes it; the random
+ * bytes are taken from `crypto.getRandomValues` in batches and handed out one by one, where the
+ * package alone asks the crypto source once per character (16 calls per id, the larger part of
+ * the time of a large import).
+ */
+import { ulid } from 'ulid';
+/** The number of random bytes taken at once (256 ids) */
+const POOL_SIZE = 4096;
+let pool = new Uint8Array(POOL_SIZE);
+let cursor = POOL_SIZE;
+/**
+ * A random fraction in [0, 1) from the pool, of the same distribution as the source of the
+ * package (one byte divided by 256)
+ */
+function pooledRandom() {
+    if (cursor >= POOL_SIZE) {
+        pool = globalThis.crypto.getRandomValues(new Uint8Array(POOL_SIZE));
+        cursor = 0;
+    }
+    return pool[cursor++] / 256;
+}
+/**
+ * Creates a new ULID
+ *
+ * @internal
+ */
+export function createId() {
+    return ulid(undefined, pooledRandom);
+}

package/dist/shared/utils/image.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Image processing utilities
+ *
+ * Converts an image file into the WebP format, resizing it when necessary.
+ */
+export interface ProcessedImage {
+    dataUrl: string;
+    width: number;
+    height: number;
+    mimeType: string;
+}
+/**
+ * Maximum size of an image
+ * A value that accounts for the WebGL texture limit (modern GPUs support 4096 or more)
+ */
+export declare const MAX_IMAGE_SIZE = 4096;
+/**
+ * Converts a file into a DataURL in the WebP format
+ * A large image is resized automatically
+ */
+export declare function processImageFile(file: File): Promise<ProcessedImage>;
+/**
+ * Whether an image of this size has to be scaled down before it is used as a texture
+ */
+export declare function exceedsMaxImageSize(width: number, height: number): boolean;
+/**
+ * Converts an image DataURL into a DataURL in the WebP format
+ * A large image is resized automatically
+ */
+export declare function processImageDataUrl(originalDataUrl: string): Promise<ProcessedImage>;
+/**
+ * Tests whether it is an image file
+ */
+export declare function isImageFile(file: File): boolean;

package/dist/shared/utils/image.js

@@ -0,0 +1,106 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+const WEBP_QUALITY = 0.95;
+/**
+ * Maximum size of an image
+ * A value that accounts for the WebGL texture limit (modern GPUs support 4096 or more)
+ */
+export const MAX_IMAGE_SIZE = 4096;
+/**
+ * Tests whether the image needs to be resized and, when it does, computes the new size
+ */
+function calculateResizedDimensions(width, height, maxSize) {
+    if (width <= maxSize && height <= maxSize) {
+        return { width, height, needsResize: false };
+    }
+    const aspectRatio = width / height;
+    let newWidth;
+    let newHeight;
+    if (width > height) {
+        newWidth = maxSize;
+        newHeight = Math.round(maxSize / aspectRatio);
+    }
+    else {
+        newHeight = maxSize;
+        newWidth = Math.round(maxSize * aspectRatio);
+    }
+    return { width: newWidth, height: newHeight, needsResize: true };
+}
+/**
+ * Converts a file into a DataURL in the WebP format
+ * A large image is resized automatically
+ */
+export async function processImageFile(file) {
+    return processImageDataUrl(await fileToDataUrl(file));
+}
+/**
+ * Whether an image of this size has to be scaled down before it is used as a texture
+ */
+export function exceedsMaxImageSize(width, height) {
+    return width > MAX_IMAGE_SIZE || height > MAX_IMAGE_SIZE;
+}
+/**
+ * Converts an image DataURL into a DataURL in the WebP format
+ * A large image is resized automatically
+ */
+export async function processImageDataUrl(originalDataUrl) {
+    // 1. Load it as an Image (to get the dimensions)
+    const img = await loadImage(originalDataUrl);
+    // 2. Decide whether it needs to be resized
+    const { width, height } = calculateResizedDimensions(img.naturalWidth, img.naturalHeight, MAX_IMAGE_SIZE);
+    // 3. Draw it onto a Canvas and convert it into WebP
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to get canvas 2d context');
+    }
+    // Settings for a high-quality resize
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = 'high';
+    ctx.drawImage(img, 0, 0, width, height);
+    // 4. Convert into WebP
+    const webpDataUrl = canvas.toDataURL('image/webp', WEBP_QUALITY);
+    return {
+        dataUrl: webpDataUrl,
+        width,
+        height,
+        mimeType: 'image/webp',
+    };
+}
+/**
+ * Converts a File into a DataURL
+ */
+function fileToDataUrl(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            if (typeof reader.result === 'string') {
+                resolve(reader.result);
+            }
+            else {
+                reject(new Error('Failed to read file as data URL'));
+            }
+        };
+        reader.onerror = () => reject(reader.error);
+        reader.readAsDataURL(file);
+    });
+}
+/**
+ * Loads an image from a DataURL
+ */
+function loadImage(dataUrl) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve(img);
+        img.onerror = () => reject(new Error('Failed to load image'));
+        img.src = dataUrl;
+    });
+}
+/**
+ * Tests whether it is an image file
+ */
+export function isImageFile(file) {
+    return file.type.startsWith('image/');
+}

package/dist/shared/utils/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Utilities module
+ *
+ * Shared utility functions and helpers.
+ */
+export { getContrastColor, hexToColor, interpolateHexColor } from './color.js';
+export { flattenCoordinatesDeep, forEachCoordinateDeep, isCoordinate, isMultiFeatureType, MULTI_FEATURE_TYPES, mapCoordinatesDeep, } from './coordinates.js';
+export type { EventEmitter, EventListener, EventMap, FeaturesChangePayload, GeometryAppliedPayload, GeometryOperationName, LoadErrorPayload, } from './event-emitter.js';
+export { EventEmitterImpl } from './event-emitter.js';
+export { isImageFile, type ProcessedImage, processImageFile } from './image.js';
+export { getTileSize } from './map.js';
+export { type AutoNameConfig, AutoNameGenerator, type AutoNameType, normalizeAutoNameConfig, } from './name-generator.js';
+export { createPixelRatioSource, type PixelRatioInput, type PixelRatioProvider, type PixelRatioSource, resolveContentPixelRatio, resolvePixelRatio, } from './pixel-ratio.js';
+export { getCircleRadius, getCreatedZoom, getFeatureDescription, getFeatureName, getImageProperties, getRadiusHandleAngle, getRotation, getScale, setCreatedZoom, setFeatureDescription, setFeatureName, setRotation, setScale, } from './property.js';
+export { getVertexPart, hasVertexRef, isSameVertexRef } from './vertex-ref.js';

package/dist/shared/utils/index.js

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Utilities module
+ *
+ * Shared utility functions and helpers.
+ */
+// Color conversion
+export { getContrastColor, hexToColor, interpolateHexColor } from './color.js';
+// Coordinate traversal
+export { flattenCoordinatesDeep, forEachCoordinateDeep, isCoordinate, isMultiFeatureType, MULTI_FEATURE_TYPES, mapCoordinatesDeep, } from './coordinates.js';
+export { EventEmitterImpl } from './event-emitter.js';
+// Image processing
+export { isImageFile, processImageFile } from './image.js';
+// Map utilities
+export { getTileSize } from './map.js';
+// Automatic name generation
+export { AutoNameGenerator, normalizeAutoNameConfig, } from './name-generator.js';
+// Resolution of the rendering pixel ratio
+export { createPixelRatioSource, resolveContentPixelRatio, resolvePixelRatio, } from './pixel-ratio.js';
+// Property manipulation
+export { getCircleRadius, getCreatedZoom, getFeatureDescription, getFeatureName, getImageProperties, getRadiusHandleAngle, getRotation, getScale, setCreatedZoom, setFeatureDescription, setFeatureName, setRotation, setScale, } from './property.js';
+// Comparison of vertex references
+export { getVertexPart, hasVertexRef, isSameVertexRef } from './vertex-ref.js';

package/dist/shared/utils/map.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Map utilities
+ *
+ * Utility functions related to the MapLibre GL JS map instance.
+ */
+import type { Map as MapLibreMap } from 'maplibre-gl';
+/**
+ * Gets the tile size of the map
+ *
+ * Accesses an internal property of MapLibre GL JS to get the tile size.
+ * Returns the default value (512) when it cannot be obtained.
+ *
+ * @param map MapLibre map instance
+ * @returns Tile size (pixels)
+ */
+export declare function getTileSize(map: MapLibreMap): number;
+/**
+ * Whether the map is set to a projection other than Web Mercator (the globe)
+ *
+ * The globe projection switches to Mercator as the map zooms in, but the setting stays, so
+ * this is true at every zoom of a globe map. A map whose style is not loaded yet counts as
+ * Mercator.
+ *
+ * @param map MapLibre map instance
+ */
+export declare function isGlobeProjection(map: MapLibreMap): boolean;

package/dist/shared/utils/map.js

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { DEFAULT_TILE_SIZE } from '../math/index.js';
+/**
+ * Gets the tile size of the map
+ *
+ * Accesses an internal property of MapLibre GL JS to get the tile size.
+ * Returns the default value (512) when it cannot be obtained.
+ *
+ * @param map MapLibre map instance
+ * @returns Tile size (pixels)
+ */
+export function getTileSize(map) {
+    return (map.transform?.tileSize ??
+        DEFAULT_TILE_SIZE);
+}
+/**
+ * Whether the map is set to a projection other than Web Mercator (the globe)
+ *
+ * The globe projection switches to Mercator as the map zooms in, but the setting stays, so
+ * this is true at every zoom of a globe map. A map whose style is not loaded yet counts as
+ * Mercator.
+ *
+ * @param map MapLibre map instance
+ */
+export function isGlobeProjection(map) {
+    let type;
+    try {
+        type = map.getProjection?.()?.type;
+    }
+    catch {
+        return false;
+    }
+    return type !== undefined && type !== 'mercator';
+}

package/dist/shared/utils/name-generator.d.ts

@@ -0,0 +1,197 @@
+/**
+ * AutoNameGenerator
+ *
+ * A utility that automatically generates a name with a sequential number when a Feature is
+ * newly created.
+ *
+ * Every word of a name the library gives a feature, a layer or a group comes from here: from
+ * the host's `typeNames`, or from the English defaults below. Nothing else in the library
+ * writes such a word inline.
+ */
+import type { Feature, FeatureType, Group, Layer, StateChanges } from '../types/model.js';
+/**
+ * What automatic naming names: a feature type, a layer or a group
+ */
+export type AutoNameType = FeatureType | 'Layer' | 'Group';
+/**
+ * How new features, layers and groups are named automatically ("Point 1", "Layer 2")
+ *
+ * Give it through the `autoName` option of `createMapLibreGLDraw` (`true`, the default, turns
+ * it on with these defaults, and `false` turns it off). Each type counts on its own, and a
+ * number is never reused: after "Point 1" and "Point 2" are created and "Point 2" is deleted,
+ * the next point is "Point 3". Existing names of the form "<word> <number>" move the count on
+ * as well, however they arrived (a load, an import).
+ *
+ * This is the one place the words of generated names come from, and the words are the host's
+ * to translate: the defaults are English, so a host that shows another language passes a
+ * word for each type it uses in `typeNames`. The keys are the type ids: the built-in feature
+ * types (`Point`, `LineString`, `Polygon`, `Circle`, `Freehand`, `Image`), `Layer`, `Group`,
+ * and the type id of every custom feature type an extension draws (a type without a word is
+ * named with its id).
+ *
+ * A layer or a group always has a name. When one is created without a name while `enabled`
+ * is false, it gets the word of its type alone, without a number ("Layer", or the
+ * `typeNames.Layer` of the host); features get no name then.
+ *
+ * @example
+ * ```ts
+ * const draw = createMapLibreGLDraw(map, {
+ *   autoName: {
+ *     enabled: true,
+ *     typeNames: { Point: 'Pin', Layer: 'Sheet' },
+ *     formatter: (typeName, n) => `${typeName} #${n}`,
+ *   },
+ * });
+ * // The first point is named "Pin #1"
+ * ```
+ */
+export interface AutoNameConfig {
+    /**
+     * Whether names are generated. When false, features get no name, and a layer or a group
+     * created without a name gets the word of its type alone
+     *
+     * @defaultValue `true`
+     */
+    enabled: boolean;
+    /**
+     * The word used for each type in the name, keyed by the type id (a built-in feature type,
+     * `Layer`, `Group`, or a custom feature type)
+     *
+     * @defaultValue English: `'Point'`, `'LineString'`, `'Polygon'`, `'Circle'`, `'Freehand'`,
+     *   `'Image'`, `'Layer'`, `'Group'`, and the id itself for any other type
+     */
+    typeNames?: Partial<Record<AutoNameType, string>>;
+    /**
+     * Builds the name from the word of the type and the number
+     *
+     * @defaultValue `` (typeName, number) => `${typeName} ${number}` ``
+     */
+    formatter?: (typeName: string, number: number) => string;
+}
+/**
+ * Normalizes an AutoNameConfig
+ */
+export declare function normalizeAutoNameConfig(config: AutoNameConfig | boolean | undefined): AutoNameConfig;
+/**
+ * AutoNameGenerator
+ *
+ * A class that generates sequential numbers per Feature type.
+ * It accounts for the numbers of existing Features and starts from the next number.
+ * A number that has been used once is not reused even after deletion (it leaves gaps).
+ *
+ * The existing numbers are taken in with a single full scan per type, and after that only the
+ * increments are taken in by subscribing to the Store. Scanning everything on every call would
+ * make the case of generating one at a time, as in a bulk import, O(n^2).
+ *
+ * With this incremental approach, the number of a name that was added and then deleted before
+ * any generation happened is also recorded (with the old approach it could be reused after the
+ * deletion). This is an extension of the "a number used once is not reused" policy, and it can
+ * only work in the direction of increasing the gaps.
+ */
+export declare class AutoNameGenerator {
+    private readonly store;
+    private readonly config;
+    /** Counter that remembers the largest number already generated per type */
+    private readonly counters;
+    /** Counter keys whose full scan is done (Layer/Group go into the same Set) */
+    private readonly scannedTypes;
+    /** Unsubscribe function of the Store subscription (null when not subscribed) */
+    private unsubscribe;
+    constructor(store: {
+        getAllFeatures(): Feature[];
+        getAllLayers(): Layer[];
+        getAllGroups(): Group[];
+        subscribe(listener: (changes: StateChanges) => void): () => void;
+    }, config?: AutoNameConfig | boolean);
+    /**
+     * Returns whether it is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Unsubscribes from the Store
+     */
+    dispose(): void;
+    /**
+     * Generates an automatic name for the given type
+     *
+     * @returns The generated name, or undefined when it is disabled
+     */
+    generateName(featureType: FeatureType): string | undefined;
+    /**
+     * Gets the type name
+     */
+    private getTypeName;
+    /**
+     * Gets the next number
+     *
+     * Increments the counter by 1 and returns it. The counter holds the largest existing number
+     * (the first full scan plus the increments after it), so the number of a deleted Feature is
+     * not reused and a gap appears.
+     */
+    private findNextNumber;
+    /**
+     * Takes in the largest existing number only the first time a generation happens for that
+     * counter key
+     *
+     * From the second time onward the counter is maintained incrementally, so it does not scan.
+     */
+    private scanOnce;
+    /**
+     * Raises the counter up to number (a smaller value does not lower it)
+     */
+    private recordNumber;
+    /**
+     * Takes in the numbers of names from the changes of the Store
+     *
+     * The path that keeps the cost proportional to the number of changes and avoids scanning
+     * everything on every generation.
+     * Deletions are ignored (because a number used once is not reused).
+     */
+    private observeChanges;
+    /**
+     * Takes in the number from the name of a Feature
+     */
+    private observeFeatureName;
+    /**
+     * Extracts the number from a name and takes it into the counter
+     */
+    private observeName;
+    /**
+     * Gets the type name of Layer
+     */
+    private getLayerTypeName;
+    /**
+     * Gets the type name of Group
+     */
+    private getGroupTypeName;
+    /**
+     * Gets the largest number from the existing Features
+     */
+    private getMaxNumberFromFeatures;
+    /**
+     * Generates the name of a new Layer
+     *
+     * A layer always has a name, so this never gives up: when naming is disabled it returns the
+     * word of Layer alone, without a number.
+     *
+     * @returns The generated name ("Layer 2"), or the word of Layer when it is disabled
+     */
+    generateLayerName(): string;
+    /**
+     * Gets the next Layer number
+     */
+    private findNextLayerNumber;
+    /**
+     * Generates the name of a new Group
+     *
+     * A group always has a name, so this never gives up: when naming is disabled it returns the
+     * word of Group alone, without a number.
+     *
+     * @returns The generated name ("Group 2"), or the word of Group when it is disabled
+     */
+    generateGroupName(): string;
+    /**
+     * Gets the next Group number
+     */
+    private findNextGroupNumber;
+}