@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/extension/renderers.d.ts

@@ -1,208 +1 @@
-/**
- * The renderer contracts of an extension
- *
- * The shapes an extension implements to draw with the WebGL context of a draw instance: the
- * renderer of a custom feature type and the overlay renderers. They are types only and sit low
- * in the layer order, so the view and snapping layers read them without reaching up into api.
- */
-import type { Map as MapLibreMap, ProjectionData } from 'maplibre-gl';
-import type { SDFLineRenderer } from '../view/renderers/line/sdf-line.js';
-import type { PointShapeRenderer } from '../view/renderers/point/point-shape.js';
-import type { FillShaderManager } from '../view/renderers/polygon/fill.js';
-import type { TerrainContext } from '../view/terrain/context.js';
-/**
- * Rendering context for custom renderers
- *
- * Provides the shader data and offset information needed when using QuadShader and the like.
- * It also holds references to the shared renderers, which makes high-quality rendering possible.
- */
-export interface CustomRendererDrawContext {
-    /** Shader data (vertexShaderPrelude, define, variantName) */
-    shaderData: {
-        vertexShaderPrelude: string;
-        define: string;
-        variantName: string;
-    };
-    /** Viewport center coordinate [lng, lat] */
-    centerLngLat: [number, number];
-    /** The mainMatrix converted into an array */
-    mainMatrixArray: number[];
-    /**
-     * The resolved rendering scale factor (the conversion factor from CSS pixels to device pixels)
-     *
-     * It is the value of `pixelRatio` in Options when one has been injected, and otherwise the
-     * `window.devicePixelRatio` read in that frame. Renderers on the extension side use this
-     * instead of reading `window.devicePixelRatio` directly.
-     */
-    pixelRatio: number;
-    /**
-     * The terrain state of the draw instance being drawn
-     *
-     * A renderer that owns a `ProjectionUniformManager` or a `QuadShader` passes it with
-     * `setTerrain(context.terrain)` before drawing, and the anchor functions (`projectAnchor`,
-     * `anchorElevationMeters`, `anchorGhostOpacity`, `drawQuadSurfaceOnTerrain` and so on) take
-     * it as their first argument. It is valid for this draw call only; a renderer shared between
-     * draw instances must not keep it.
-     */
-    terrain: TerrainContext;
-    /**
-     * The opacity of the layer being drawn, from 0 to 1 (`Layer.opacity`)
-     *
-     * Core multiplies it into everything it draws for the layer, and a renderer multiplies it
-     * into its own alpha, so that what it draws fades with the layer. It is the opacity of the
-     * layer of the feature for a {@link CustomFeatureRenderer} and a feature companion, and 1 for
-     * an overlay (which does not belong to a layer). The shared renderers of this context do not
-     * apply it by themselves. It changes nothing about hit testing: a feature in a layer at
-     * opacity 0 can still be selected.
-     */
-    opacity: number;
-    /** SDF line rendering (high-quality line rendering, anti-aliasing, dashes and so on) */
-    sdfLineRenderer: SDFLineRenderer;
-    /** Polygon fill rendering */
-    fillShaderManager: FillShaderManager;
-    /** Point shape rendering */
-    pointShapeRenderer: PointShapeRenderer;
-}
-/**
- * Draws the features of a custom feature type with the WebGL context of the map
- *
- * It is the `renderer` of a {@link CustomFeatureHandler}. `onAdd` runs when the draw layer is
- * added to the map (create the WebGL resources there), `draw` runs for each visible feature of
- * the type in stacking order on every frame, and `onRemove` runs when the layer is removed. The
- * shared renderers of the context draw lines, fills and point shapes the same way the built-in
- * types are drawn, terrain included.
- *
- * @example
- * ```ts
- * import type { CustomFeatureRenderer, PointStyle } from '@sakuzu/maplibre-gl-draw';
- *
- * const markerStyle: PointStyle = {
- *   shape: 'square',
- *   size: 14,
- *   fillColor: [0, 0.4, 1, 1],
- *   fillOpacity: 1,
- *   strokeColor: [1, 1, 1, 1],
- *   strokeWidth: 2,
- *   strokeOpacity: 1,
- * };
- *
- * const markerRenderer: CustomFeatureRenderer = {
- *   name: 'marker',
- *   onAdd() {}, // nothing to create: the shared point renderer does the drawing
- *   draw(feature, _projectionData, zoom, context) {
- *     const coordinate = feature.coordinates as [number, number];
- *     // Fade with the layer: the opacity of the layer is multiplied into the alpha
- *     const style = {
- *       ...markerStyle,
- *       fillOpacity: markerStyle.fillOpacity * context.opacity,
- *       strokeOpacity: markerStyle.strokeOpacity * context.opacity,
- *     };
- *     context.pointShapeRenderer.draw(coordinate, style, zoom, feature.id);
- *   },
- *   onRemove() {},
- * };
- * ```
- */
-export interface CustomFeatureRenderer {
-    /** Renderer name (for debugging) */
-    readonly name: string;
-    /**
-     * Initializes the WebGL resources
-     */
-    onAdd(gl: WebGL2RenderingContext, map: MapLibreMap): void;
-    /**
-     * Draws a feature
-     *
-     * @param feature The feature to draw
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context (shader data, offset information, and the opacity of
-     *   the layer of the feature, which the renderer multiplies into its own alpha)
-     */
-    draw(feature: {
-        id: string;
-        type: string;
-        coordinates: unknown;
-        properties: Record<string, unknown>;
-        style?: unknown;
-    }, projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-    /**
-     * Releases the WebGL resources
-     */
-    onRemove(): void;
-}
-/**
- * Custom renderer
- *
- * Responsible for overlay rendering (independent of features).
- */
-export interface CustomOverlayRenderer {
-    /** Renderer name (for debugging) */
-    readonly name: string;
-    /**
-     * The priority in the draw order
-     * - 'background': drawn behind the features
-     * - 'foreground': drawn in front of the features (behind the selection UI)
-     * - 'overlay': drawn in front of the selection UI
-     */
-    readonly order: 'background' | 'foreground' | 'overlay';
-    /**
-     * Initializes the WebGL resources
-     */
-    onAdd(gl: WebGL2RenderingContext, map: MapLibreMap): void;
-    /**
-     * Draws
-     *
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context (shared renderers, shader data and so on)
-     */
-    draw(projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-    /**
-     * Releases the WebGL resources
-     */
-    onRemove(): void;
-    /**
-     * Whether the renderer still has work that later frames finish on their own and that will
-     * change what it draws (resources it prepares over several frames, say). Optional: a renderer
-     * without it has none
-     *
-     * `MapLibreGLDraw.hasPendingWork` asks every overlay renderer, so a host that waits for a
-     * complete picture waits for this renderer too. A renderer that returns true requests the
-     * repaints that finish the work itself. With `timeSlicing: false` in the rendering settings,
-     * a renderer should finish in the frame what it would otherwise spread over frames.
-     */
-    hasPendingWork?(): boolean;
-}
-/**
- * Layer-aware overlay renderer
- *
- * An extension of CustomOverlayRenderer that supports rendering per layer.
- * Used for rendering that follows the layer order, such as Tentative.
- */
-export interface LayerAwareOverlayRenderer extends CustomOverlayRenderer {
-    /**
-     * Performs the rendering that corresponds to the given layer (lines and fills only)
-     *
-     * Called in the per-layer rendering loop, after the features of each layer have been drawn.
-     * When this method exists, it is used instead of draw().
-     * Vertices are drawn in the foreground, so they are not drawn here.
-     *
-     * @param layerId The ID of the target layer
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context
-     */
-    drawForLayer(layerId: string, projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-    /**
-     * Draws the vertices in the foreground
-     *
-     * Called after the selection UI, it draws the vertices of all layers in the foreground at once.
-     * This is needed so that the vertices stay visible even while drawing on a layer that is behind.
-     *
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context
-     */
-    drawVertices?(projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-}
+export {};

package/dist/geometry/angle.d.ts

@@ -35,13 +35,5 @@ import type { Coordinate } from './types.js';
  * @param radiusMeters The distance from the center in meters
  * @param angleDegrees The bearing in degrees, clockwise with north as 0
  * @returns The position `[lng, lat]` in degrees
- *
- * @example
- * ```ts
- * import { getPointAtAngle } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // 1 km due east of Tokyo Station, on the same parallel
- * getPointAtAngle([139.767, 35.681], 1000, 90); // [139.77807..., 35.681]
- * ```
  */
 export declare function getPointAtAngle(center: Coordinate, radiusMeters: number, angleDegrees: number): Coordinate;

package/dist/geometry/angle.js

@@ -21,14 +21,6 @@ import { EARTH_RADIUS_METERS, toRadians } from './units.js';
  * @param radiusMeters The distance from the center in meters
  * @param angleDegrees The bearing in degrees, clockwise with north as 0
  * @returns The position `[lng, lat]` in degrees
- *
- * @example
- * ```ts
- * import { getPointAtAngle } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // 1 km due east of Tokyo Station, on the same parallel
- * getPointAtAngle([139.767, 35.681], 1000, 90); // [139.77807..., 35.681]
- * ```
  */
 export function getPointAtAngle(center, radiusMeters, angleDegrees) {
     const earthRadius = EARTH_RADIUS_METERS;

package/dist/geometry/bbox.d.ts

@@ -9,14 +9,6 @@ import type { AreaCoordinates, BBox, Coordinate } from './types.js';
  * @param coordinates Positions `[lng, lat]` in degrees
  * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
  *   finite coordinate (an empty array included)
- *
- * @example
- * ```ts
- * import { coordinatesBBox } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * coordinatesBBox([[139.7, 35.6], [139.8, 35.7]]); // [139.7, 35.6, 139.8, 35.7]
- * coordinatesBBox([]); // null
- * ```
  */
 export declare function coordinatesBBox(coordinates: Coordinate[]): BBox | null;
 /**
@@ -33,16 +25,16 @@ export declare function boundingBox(coordinates: AreaCoordinates): BBox | null;
 /**
  * Determines whether two bounding boxes overlap, touching included.
  *
- * @param a A box `[minLng, minLat, maxLng, maxLat]`
- * @param b A box `[minLng, minLat, maxLng, maxLat]`
+ * @param a A box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param b A box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when the boxes share at least one point, an edge or a corner included
  */
 export declare function bboxIntersects(a: BBox, b: BBox): boolean;
 /**
  * Determines whether one bounding box contains another, coincident boundaries included.
  *
- * @param outer The containing box `[minLng, minLat, maxLng, maxLat]`
- * @param inner The contained box `[minLng, minLat, maxLng, maxLat]`
+ * @param outer The containing box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param inner The contained box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when every point of `inner` lies in `outer`. A box contains itself
  */
 export declare function bboxContains(outer: BBox, inner: BBox): boolean;

package/dist/geometry/bbox.js

@@ -17,14 +17,6 @@ import { flattenAreaCoordinates, isFiniteCoordinate } from './coords.js';
  * @param coordinates Positions `[lng, lat]` in degrees
  * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
  *   finite coordinate (an empty array included)
- *
- * @example
- * ```ts
- * import { coordinatesBBox } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * coordinatesBBox([[139.7, 35.6], [139.8, 35.7]]); // [139.7, 35.6, 139.8, 35.7]
- * coordinatesBBox([]); // null
- * ```
  */
 export function coordinatesBBox(coordinates) {
     let found = false;
@@ -64,8 +56,8 @@ export function boundingBox(coordinates) {
 /**
  * Determines whether two bounding boxes overlap, touching included.
  *
- * @param a A box `[minLng, minLat, maxLng, maxLat]`
- * @param b A box `[minLng, minLat, maxLng, maxLat]`
+ * @param a A box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param b A box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when the boxes share at least one point, an edge or a corner included
  */
 export function bboxIntersects(a, b) {
@@ -74,8 +66,8 @@ export function bboxIntersects(a, b) {
 /**
  * Determines whether one bounding box contains another, coincident boundaries included.
  *
- * @param outer The containing box `[minLng, minLat, maxLng, maxLat]`
- * @param inner The contained box `[minLng, minLat, maxLng, maxLat]`
+ * @param outer The containing box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param inner The contained box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when every point of `inner` lies in `outer`. A box contains itself
  */
 export function bboxContains(outer, inner) {

package/dist/geometry/boolean.d.ts

@@ -12,15 +12,6 @@ import type { AreaCoordinates, MultiPolygonCoordinates } from './types.js';
  *   the input has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { normalizeArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A self-intersecting bow tie becomes two triangles
- * normalizeArea([[[0, 0], [1, 1], [1, 0], [0, 1], [0, 0]]]);
- * // [[[[0, 0], [0.5, 0.5], [0, 1], [0, 0]]], [[[0.5, 0.5], [1, 0], [1, 1], [0.5, 0.5]]]]
- * ```
  */
 export declare function normalizeArea(coordinates: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -36,16 +27,6 @@ export declare function normalizeArea(coordinates: AreaCoordinates): MultiPolygo
  *   several parts. An empty array when neither input has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { union } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * union(a, b); // [[[[0, 0], [1.5, 0], [1.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export declare function union(a: AreaCoordinates, b: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -59,16 +40,6 @@ export declare function union(a: AreaCoordinates, b: AreaCoordinates): MultiPoly
  *   when `a` has no area or `b` covers it. `a` normalized when `b` has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { difference } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * difference(a, b); // [[[[0, 0], [0.5, 0], [0.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export declare function difference(a: AreaCoordinates, b: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -81,16 +52,6 @@ export declare function difference(a: AreaCoordinates, b: AreaCoordinates): Mult
  *   area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { intersection } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * intersection(a, b); // [[[[0.5, 0], [1, 0], [1, 1], [0.5, 1], [0.5, 0]]]]
- * ```
  */
 export declare function intersection(a: AreaCoordinates, b: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -120,18 +81,6 @@ export declare function clip(subject: AreaCoordinates, clipRegion: AreaCoordinat
  *   empty array and when no element has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { unionAll } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const merged = unionAll([
- *   [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
- *   [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]],
- *   [[[5, 5], [6, 5], [6, 6], [5, 5]]],
- * ]);
- * merged.length; // 2 (the overlapping squares fuse; the triangle stays apart)
- * ```
  */
 export declare function unionAll(geometries: AreaCoordinates[]): MultiPolygonCoordinates;
 /**

package/dist/geometry/boolean.js

@@ -106,15 +106,6 @@ function normalize(coordinates) {
  *   the input has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { normalizeArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A self-intersecting bow tie becomes two triangles
- * normalizeArea([[[0, 0], [1, 1], [1, 0], [0, 1], [0, 0]]]);
- * // [[[[0, 0], [0.5, 0.5], [0, 1], [0, 0]]], [[[0.5, 0.5], [1, 0], [1, 1], [0.5, 0.5]]]]
- * ```
  */
 export function normalizeArea(coordinates) {
     return normalize(sanitize(coordinates));
@@ -132,16 +123,6 @@ export function normalizeArea(coordinates) {
  *   several parts. An empty array when neither input has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { union } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * union(a, b); // [[[[0, 0], [1.5, 0], [1.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export function union(a, b) {
     const left = sanitize(a);
@@ -165,16 +146,6 @@ export function union(a, b) {
  *   when `a` has no area or `b` covers it. `a` normalized when `b` has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { difference } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * difference(a, b); // [[[[0, 0], [0.5, 0], [0.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export function difference(a, b) {
     const left = sanitize(a);
@@ -197,16 +168,6 @@ export function difference(a, b) {
  *   area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { intersection } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * intersection(a, b); // [[[[0.5, 0], [1, 0], [1, 1], [0.5, 1], [0.5, 0]]]]
- * ```
  */
 export function intersection(a, b) {
     const left = sanitize(a);
@@ -245,18 +206,6 @@ export function clip(subject, clipRegion) {
  *   empty array and when no element has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { unionAll } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const merged = unionAll([
- *   [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
- *   [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]],
- *   [[[5, 5], [6, 5], [6, 6], [5, 5]]],
- * ]);
- * merged.length; // 2 (the overlapping squares fuse; the triangle stays apart)
- * ```
  */
 export function unionAll(geometries) {
     const parts = geometries.map(sanitize).filter((part) => part.length > 0);

package/dist/geometry/buffer.d.ts

@@ -42,31 +42,5 @@ export interface BufferOptions {
  *   shrunk polygon vanishes. `null` when the operation is not defined for the input
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { buffer } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // The area within 100 m of a line
- * const corridor = buffer(
- *   { type: 'LineString', coordinates: [[139.76, 35.68], [139.77, 35.69]] },
- *   100,
- *   { segments: 32 },
- * );
- *
- * // Shrink a polygon by 50 m
- * const shrunk = buffer(
- *   {
- *     type: 'Polygon',
- *     coordinates: [[[139.76, 35.68], [139.77, 35.68], [139.77, 35.69], [139.76, 35.68]]],
- *   },
- *   -50,
- * );
- * if (shrunk === null) {
- *   // Not defined for the input
- * } else if (shrunk.length === 0) {
- *   // The whole area vanished
- * }
- * ```
  */
 export declare function buffer(geometry: GeometryInput, meters: number, options?: BufferOptions): MultiPolygonCoordinates | null;

package/dist/geometry/buffer.js

@@ -161,32 +161,6 @@ function isAreaGeometry(geometry) {
  *   shrunk polygon vanishes. `null` when the operation is not defined for the input
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { buffer } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // The area within 100 m of a line
- * const corridor = buffer(
- *   { type: 'LineString', coordinates: [[139.76, 35.68], [139.77, 35.69]] },
- *   100,
- *   { segments: 32 },
- * );
- *
- * // Shrink a polygon by 50 m
- * const shrunk = buffer(
- *   {
- *     type: 'Polygon',
- *     coordinates: [[[139.76, 35.68], [139.77, 35.68], [139.77, 35.69], [139.76, 35.68]]],
- *   },
- *   -50,
- * );
- * if (shrunk === null) {
- *   // Not defined for the input
- * } else if (shrunk.length === 0) {
- *   // The whole area vanished
- * }
- * ```
  */
 export function buffer(geometry, meters, options) {
     if (!Number.isFinite(meters)) {

package/dist/geometry/circle.d.ts

@@ -26,15 +26,6 @@ export declare function normalizeCircleSegments(segments: number | undefined, fa
  * @returns The ring, `segments + 1` positions `[lng, lat]` with the first repeated at the
  *   end. An empty array for a center that is not finite and for a radius that is negative
  *   or not finite
- *
- * @example
- * ```ts
- * import { generateCirclePolygon } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const ring = generateCirclePolygon([139.767, 35.681], 500, 32);
- * ring.length; // 33
- * const polygon = [ring]; // Polygon coordinates
- * ```
  */
 export declare function generateCirclePolygon(center: Coordinate, radiusMeters: number, segments?: number): Coordinate[];
 /**

package/dist/geometry/circle.js

@@ -48,15 +48,6 @@ export function normalizeCircleSegments(segments, fallback = DEFAULT_CIRCLE_SEGM
  * @returns The ring, `segments + 1` positions `[lng, lat]` with the first repeated at the
  *   end. An empty array for a center that is not finite and for a radius that is negative
  *   or not finite
- *
- * @example
- * ```ts
- * import { generateCirclePolygon } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const ring = generateCirclePolygon([139.767, 35.681], 500, 32);
- * ring.length; // 33
- * const polygon = [ring]; // Polygon coordinates
- * ```
  */
 export function generateCirclePolygon(center, radiusMeters, segments = DEFAULT_CIRCLE_SEGMENTS) {
     if (!isFiniteCoordinate(center) || !Number.isFinite(radiusMeters) || radiusMeters < 0) {

package/dist/geometry/coords.d.ts

@@ -18,15 +18,6 @@ import type { AreaCoordinates, Coordinate, MultiPolygonCoordinates, Ring } from
  * @param coordinates Polygon or MultiPolygon coordinates
  * @returns `true` for MultiPolygon coordinates (a type guard). `false` for Polygon
  *   coordinates and for coordinates with no position
- *
- * @example
- * ```ts
- * import { isMultiPolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const ring: [number, number][] = [[0, 0], [1, 0], [1, 1], [0, 0]];
- * isMultiPolygonCoordinates([ring]); // false (Polygon)
- * isMultiPolygonCoordinates([[ring]]); // true (MultiPolygon)
- * ```
  */
 export declare function isMultiPolygonCoordinates(coordinates: AreaCoordinates): coordinates is MultiPolygonCoordinates;
 /**
@@ -75,13 +66,6 @@ export declare function isRingClosed(ring: Ring): boolean;
  *
  * @param ring A coordinate sequence
  * @returns A new closed array. The input itself when it is already closed or empty
- *
- * @example
- * ```ts
- * import { closeRing } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * closeRing([[0, 0], [1, 0], [1, 1]]); // [[0, 0], [1, 0], [1, 1], [0, 0]]
- * ```
  */
 export declare function closeRing(ring: Ring): Ring;
 /**

package/dist/geometry/coords.js

@@ -13,15 +13,6 @@
  * @param coordinates Polygon or MultiPolygon coordinates
  * @returns `true` for MultiPolygon coordinates (a type guard). `false` for Polygon
  *   coordinates and for coordinates with no position
- *
- * @example
- * ```ts
- * import { isMultiPolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const ring: [number, number][] = [[0, 0], [1, 0], [1, 1], [0, 0]];
- * isMultiPolygonCoordinates([ring]); // false (Polygon)
- * isMultiPolygonCoordinates([[ring]]); // true (MultiPolygon)
- * ```
  */
 export function isMultiPolygonCoordinates(coordinates) {
     for (const element of coordinates) {
@@ -112,13 +103,6 @@ export function isRingClosed(ring) {
  *
  * @param ring A coordinate sequence
  * @returns A new closed array. The input itself when it is already closed or empty
- *
- * @example
- * ```ts
- * import { closeRing } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * closeRing([[0, 0], [1, 0], [1, 1]]); // [[0, 0], [1, 0], [1, 1], [0, 0]]
- * ```
  */
 export function closeRing(ring) {
     if (ring.length === 0 || isRingClosed(ring)) {