leaflet-city-mapper 0.0.9 → 0.1.0

package/src/triangulation/on.js

@@ -1,3 +1,12 @@
+/**
+ * Check whether a point lies within a segment's axis-aligned bounding box.
+ *
+ * @param {Object} p First segment endpoint.
+ * @param {Object} q Second segment endpoint.
+ * @param {Object} r Point to test.
+ *
+ * @returns {boolean} Whether the point lies within the bounds.
+ */
 export function on(p, q, r) {
   return Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) &&
     Math.min(p.y, q.y) <= r.y && r.y <= Math.max(p.y, q.y);

package/src/triangulation/polygonRings.js

@@ -1,6 +1,14 @@
 import { clean } from './clean.js';
 import { isClockWise } from './isClockWise.js';
 
+/**
+ * Split indexed vertices into cleaned rings and normalize outer and hole winding.
+ *
+ * @param {Object[][]} paths Original polygon paths defining ring lengths.
+ * @param {Object[]} vertices Indexed vertices corresponding to the paths.
+ *
+ * @returns {Object[][]} Cleaned rings with normalized winding.
+ */
 export function polygonRings(paths, vertices) {
   const rings = /* alloc */ [];
   let offset = 0, index, path, ring;

package/src/triangulation/sortHoles.js

@@ -1,6 +1,13 @@
 import { minimumX } from './minimumX.js';
 import { mergeHoles } from './mergeHoles.js';
 
+/**
+ * Stably sort hole rings in place by their minimum x coordinate.
+ *
+ * @param {Object[][]} holes Hole rings.
+ *
+ * @returns {Object[][]} The supplied array of sorted holes.
+ */
 export function sortHoles(holes) {
   if (holes.length < 2) return holes;
   const buffer = /* alloc */ new Array(holes.length);

package/src/triangulation/triangulate.js

@@ -5,18 +5,19 @@ import { connectHole } from './connectHole.js';
 import { clipEars } from './clipEars.js';
 import { validateArea } from './validateArea.js';
 
-
 /**
  * Triangulates a polygon given as `{x, y}` points.
  * Rings omit the repeated closing point; winding is normalized internally.
  * Vertex indices remain relative to the original inputs after duplicate/collinear
  * cleanup. Hole bridges duplicate endpoints, not source vertices.
+ *
  * @param {Object[]} contour Outer boundary.
  * @param {Object[][]} [holes] Interior boundaries.
  *
  * @returns {number[][]} Triangles as indices in `[...contour, ...holes.flat()]`.
+ *
+ * @throws {Error} If a polygon coordinate is not finite.
  */
-
 export function triangulate(contour, holes = geometryEmpty) {
   const paths = /* alloc */ [contour, ...holes];
   const points = paths.flat();

package/src/triangulation/validateArea.js

@@ -1,6 +1,15 @@
 import { area } from './area.js';
 import { cross } from './cross.js';
 
+/**
+ * Check that triangle area matches the outer ring area minus its holes.
+ *
+ * @param {Object[][]} rings Outer ring followed by hole rings.
+ * @param {Object[]} vertices Indexed planar vertices.
+ * @param {number[][]} result Triangles of vertex indices.
+ *
+ * @throws {Error} If the expected area is nonpositive or the triangle area differs.
+ */
 export function validateArea(rings, vertices, result) {
   let holeArea = 0, actual = 0, i, triangle;
   for (i = 1; i < rings.length; i++) holeArea += area(rings[i]);

package/src/utils/README.md

@@ -0,0 +1,16 @@
+# Utilities
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Small shared helpers for ordering, wrapping values and yielding asynchronous work.
+
+## When to use these helpers
+
+`wrap` is specific to angles in radians, not arbitrary ranges. After
+`yieldTask`, callers must recheck cancellation or revisions.
+
+- [compareDistance.js](./compareDistance.js): compare items by distance.
+- [wrap.js](./wrap.js): wrap an angle between negative and positive pi.
+- [yieldTask.js](./yieldTask.js): yield to a timer.
+
+Related: [globals](../globals/README.md), [sources](../sources/README.md).

package/src/utils/compareDistance.js

@@ -1,3 +1,11 @@
+/**
+ * Compare objects by ascending distance.
+ *
+ * @param {Object} a First object with a distance.
+ * @param {Object} b Second object with a distance.
+ *
+ * @returns {number} Signed distance difference.
+ */
 export function compareDistance(a, b) {
   return a.distance - b.distance;
 }

package/src/utils/noOperation.js

@@ -1 +1,2 @@
+/** Do nothing when a callback is required. */
 export function noOperation() {}

package/src/utils/wrap.js

@@ -1,3 +1,10 @@
+/**
+ * Wrap an angle to the range from negative pi to pi.
+ *
+ * @param {number} angle Angle in radians.
+ *
+ * @returns {number} Wrapped angle in radians.
+ */
 export function wrap(angle) {
   return Math.atan2(Math.sin(angle), Math.cos(angle));
 }

package/src/utils/yieldTask.js

@@ -1,3 +1,10 @@
+/**
+ * Yield to a timer before continuing asynchronous work.
+ *
+ * @param {number} [delay=0] Timer delay in milliseconds.
+ *
+ * @returns {Promise<void>} Resolves when the timer fires.
+ */
 export function yieldTask(delay = 0) {
   const task = Promise.withResolvers();
   setTimeout(task.resolve, delay);

package/src/vector-style/README.md

@@ -0,0 +1,27 @@
+# Vector styles
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Parses and validates vector style layers, evaluates supported expressions and
+translates paint values for vector tile rendering.
+
+## Style input and evaluation
+
+```mermaid
+flowchart LR
+  Text["JSON / otm_layers text"] --> Clean["Remove comments + trailing commas"]
+  Clean --> Parse["JSON parse + validate layers"]
+  Parse --> Match["Match style and source layers"]
+  Match --> Evaluate["Evaluate expressions: properties + zoom"]
+  Evaluate --> Paint["Resolve fill / line paint"]
+  Paint --> Tile["Vector tile presentation"]
+```
+
+Parsing does not execute arbitrary JavaScript. Only supported expression
+operators are evaluated; non-array values pass through unchanged.
+
+- [parseVectorStyle.js](./parseVectorStyle.js): parse and validate style source.
+- [evaluateStyle.js](./evaluateStyle.js): evaluate style expressions.
+- [vectorPaint.js](./vectorPaint.js): derive paint values.
+
+Related: [vector-tiles](../vector-tiles/README.md), [colors](../colors/README.md), [mvt](../mvt/README.md).

package/src/vector-style/appendQuotedStyleCharacter.js

@@ -1,3 +1,11 @@
+/**
+ * Convert one quoted style character to JSON form while updating quote and escape state.
+ *
+ * @param {string} char Current character.
+ * @param {Object} state Mutable quoted and escaped state.
+ *
+ * @returns {string|undefined} Converted text, or undefined outside a quoted string.
+ */
 export function appendQuotedStyleCharacter(char, state) {
   if (state.quoted) {
     if (state.escaped) {

package/src/vector-style/arrayContainsRange.js

@@ -1,3 +1,13 @@
+/**
+ * Check a slice for a value, treating NaN as equal to NaN.
+ *
+ * @param {Array} values Input values.
+ * @param {number} start Inclusive start index.
+ * @param {number} end Exclusive end index.
+ * @param {*} target Value to find.
+ *
+ * @returns {boolean} Whether the value occurs in the slice.
+ */
 export function arrayContainsRange(values, start, end, target) {
   let i = 0, value = null;
   for (i = start; i < end; i++) {

package/src/vector-style/evaluateBoolean.js

@@ -1,5 +1,18 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate a short-circuiting all or any style expression.
+ *
+ * @param {string} op Expression operator.
+ * @param {Array} args Expression operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} legacy Whether to use legacy filter evaluation.
+ *
+ * @returns {boolean} Expression result.
+ *
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluateBoolean(op, args, properties, zoom, legacy) {
   let i = 0;
   if (op === 'all') {

package/src/vector-style/evaluateCoalesceOrCase.js

@@ -1,5 +1,18 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate a coalesce or case style expression.
+ *
+ * @param {string} op Expression operator.
+ * @param {Array} args Expression operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} legacy Legacy filter flag.
+ *
+ * @returns {*} Selected expression result.
+ *
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluateCoalesceOrCase(op, args, properties, zoom, legacy) {
   let i = 0, result = null;
   if (op === 'coalesce') {

package/src/vector-style/evaluateComparison.js

@@ -1,6 +1,19 @@
 import { evaluateInput } from './evaluateInput.js';
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate a comparison between style expression operands.
+ *
+ * @param {string} op Comparison operator.
+ * @param {Array} args Expression operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} legacy Whether the left operand is a legacy property name.
+ *
+ * @returns {boolean} Comparison result.
+ *
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluateComparison(op, args, properties, zoom, legacy) {
   const left = evaluateInput(args[0], properties, zoom, legacy);
   const right = evaluateStyle(args[1], properties, zoom);

package/src/vector-style/evaluateIExpression.js

@@ -1,6 +1,19 @@
 import { evaluateInterpolate } from './evaluateInterpolate.js';
 import { evaluateMembership } from './evaluateMembership.js';
 
+/**
+ * Dispatch an in or interpolate style expression.
+ *
+ * @param {string} op Expression operator.
+ * @param {Array} args Expression operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} legacy Whether to use legacy membership semantics.
+ *
+ * @returns {*} Expression result.
+ *
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluateIExpression(op, args, properties, zoom, legacy) {
   if (op === 'in') return evaluateMembership(op, args, properties, zoom, legacy);
   if (op === 'interpolate') return evaluateInterpolate(args, properties, zoom);

package/src/vector-style/evaluateInput.js

@@ -1,5 +1,15 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate an input or resolve a legacy string operand as a property name.
+ *
+ * @param {*} value Input value or expression.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} legacy Whether string values name properties.
+ *
+ * @returns {*} Evaluated input.
+ */
 export function evaluateInput(value, properties, zoom, legacy) {
   if (legacy && typeof value === 'string') return properties[value];
   return evaluateStyle(value, properties, zoom);

package/src/vector-style/evaluateInterpolate.js

@@ -1,6 +1,15 @@
 import { styleColor } from './styleColor.js';
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Interpolate numeric or color style outputs between expression stops.
+ *
+ * @param {Array} args Interpolation mode, input and stops.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {*} Interpolated or endpoint value.
+ */
 export function evaluateInterpolate(args, properties, zoom) {
   const result = evaluateStyle(args[1], properties, zoom);
   const base = args[0][0] === 'exponential' ? args[0][1] : 1;

package/src/vector-style/evaluateMatch.js

@@ -1,5 +1,14 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate a match expression against scalar or array labels.
+ *
+ * @param {Array} args Input, labels, outputs and fallback.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {*} Matched output or fallback.
+ */
 export function evaluateMatch(args, properties, zoom) {
   const result = evaluateStyle(args[0], properties, zoom);
   let i = 0, matched = false;

package/src/vector-style/evaluateMath.js

@@ -1,5 +1,17 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate addition or unary/binary subtraction in a style expression.
+ *
+ * @param {string} op Arithmetic operator.
+ * @param {Array} args Expression operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {number} Arithmetic result.
+ *
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluateMath(op, args, properties, zoom) {
   let i = 0, sum = 0;
   if (op === '+') {

package/src/vector-style/evaluateMembership.js

@@ -2,6 +2,17 @@ import { arrayContainsRange } from './arrayContainsRange.js';
 import { evaluateInput } from './evaluateInput.js';
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate membership or legacy negated membership in a style filter.
+ *
+ * @param {string} op Membership operator.
+ * @param {Array} args Target and candidate operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} legacy Whether to use legacy filter semantics.
+ *
+ * @returns {boolean} Membership result.
+ */
 export function evaluateMembership(op, args, properties, zoom, legacy) {
   let target = null;
   if (op === '!in') {

package/src/vector-style/evaluateNegation.js

@@ -2,6 +2,19 @@ import { evaluateInput } from './evaluateInput.js';
 import { evaluateMembership } from './evaluateMembership.js';
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate logical negation, inequality or negated membership.
+ *
+ * @param {string} op Expression operator.
+ * @param {Array} args Expression operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} legacy Whether to use legacy filter semantics.
+ *
+ * @returns {boolean} Expression result.
+ *
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluateNegation(op, args, properties, zoom, legacy) {
   if (op === '!') return !evaluateStyle(args[0], properties, zoom, legacy);
   if (op === '!=') {

package/src/vector-style/evaluatePrimitive.js

@@ -1,3 +1,15 @@
+/**
+ * Evaluate a literal, property lookup, property existence or zoom expression.
+ *
+ * @param {string} op Expression operator.
+ * @param {Array} args Expression operands.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {*} Expression result.
+ *
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluatePrimitive(op, args, properties, zoom) {
   switch (op) {
     case 'literal': return args[0];

package/src/vector-style/evaluateStep.js

@@ -1,5 +1,14 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate the output of the last step whose stop is reached.
+ *
+ * @param {Array} args Input, default output and stop/output pairs.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {*} Selected output.
+ */
 export function evaluateStep(args, properties, zoom) {
   const result = evaluateStyle(args[0], properties, zoom);
   let output = args[1], i = 0;

package/src/vector-style/evaluateStyle.js

@@ -9,6 +9,16 @@ import { evaluatePrimitive } from './evaluatePrimitive.js';
 import { evaluateStep } from './evaluateStep.js';
 import { evaluateToExpression } from './evaluateToExpression.js';
 
+/**
+ * Evaluate a supported vector style expression or return a non-array value unchanged.
+ *
+ * @param {*} value Style value or expression.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ * @param {boolean} [legacy] Whether to use legacy filter semantics.
+ *
+ * @returns {*} Evaluated value.
+ */
 export function evaluateStyle(value, properties, zoom, legacy = false) {
   if (!Array.isArray(value)) return value;
   const op = value[0];

package/src/vector-style/evaluateToExpression.js

@@ -1,5 +1,18 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate a boolean or numeric conversion expression.
+ *
+ * @param {string} op Conversion operator.
+ * @param {Array} args Candidate expressions.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {boolean|number} Converted value.
+ *
+ * @throws {Error} If no numeric candidate is finite.
+ * @throws {Error} If the operator is unsupported.
+ */
 export function evaluateToExpression(op, args, properties, zoom) {
   if (op === 'to-boolean') return Boolean(evaluateStyle(args[0], properties, zoom));
   if (op === 'to-number') {

package/src/vector-style/fillVectorPaint.js

@@ -1,6 +1,15 @@
 import { readPaintValue } from './readPaintValue.js';
 import { styleColor } from './styleColor.js';
 
+/**
+ * Resolve fill paint expressions to normalized colors and opacity.
+ *
+ * @param {Object} paint Vector style paint values.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {Object} Fill and outline rendering options.
+ */
 export function fillVectorPaint(paint, properties, zoom) {
   const fill = styleColor(readPaintValue(paint, 'fill-color', '#000', properties, zoom));
   const outline = readPaintValue(paint, 'fill-outline-color', null, properties, zoom);

package/src/vector-style/lineVectorPaint.js

@@ -2,6 +2,16 @@ import { readPaintValue } from './readPaintValue.js';
 import { scaleDashArray } from './scaleDashArray.js';
 import { styleColor } from './styleColor.js';
 
+/**
+ * Resolve line paint and layout to rendering options.
+ *
+ * @param {Object} layer Vector style layer.
+ * @param {Object} paint Vector style paint values.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {Object} Line color, opacity, width, dash, cap and join options.
+ */
 export function lineVectorPaint(layer, paint, properties, zoom) {
   const weight = readPaintValue(paint, 'line-width', 1, properties, zoom);
   const rgb = styleColor(readPaintValue(paint, 'line-color', '#000', properties, zoom));

package/src/vector-style/parseFunctionalColor.js

@@ -1,3 +1,12 @@
+/**
+ * Parse an rgb or rgba color into numeric components.
+ *
+ * @param {string} value Color text.
+ *
+ * @returns {Array<number>} Red, green, blue and alpha components.
+ *
+ * @throws {Error} If the color syntax or components are unsupported.
+ */
 export function parseFunctionalColor(value) {
   const match = /^rgba?\(([^)]+)\)$/.exec(value);
   if (match) {

package/src/vector-style/parseHexColor.js

@@ -1,3 +1,10 @@
+/**
+ * Parse a three- or six-digit hexadecimal color.
+ *
+ * @param {string} value Validated hexadecimal color text.
+ *
+ * @returns {Array<number>} Red, green, blue and opaque alpha.
+ */
 export function parseHexColor(value) {
   let i = 0, offset = 0;
   if (value.length === 4) {

package/src/vector-style/parseVectorStyle.js

@@ -2,6 +2,13 @@ import { removeTrailingCommas } from './removeTrailingCommas.js';
 import { stripStyleComments } from './stripStyleComments.js';
 import { validateVectorLayers } from './validateVectorLayers.js';
 
+/**
+ * Parse a vector style document or otm_layers assignment after removing comments and trailing commas.
+ *
+ * @param {string} text Style source text.
+ *
+ * @returns {Array<Object>} Validated style layers.
+ */
 export function parseVectorStyle(text) {
   const prefix = /^\s*(?:const|let|var)\s+otm_layers\s*=\s*/.exec(text);
   if (prefix) text = text.slice(prefix[0].length);

package/src/vector-style/readPaintValue.js

@@ -1,5 +1,16 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate a paint value or return its fallback when absent.
+ *
+ * @param {Object} paint Paint values.
+ * @param {string} key Paint property name.
+ * @param {*} fallback Default value.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {*} Evaluated paint value or fallback.
+ */
 export function readPaintValue(paint, key, fallback, properties, zoom) {
   if (paint[key] === undefined) return fallback;
   return evaluateStyle(paint[key], properties, zoom);

package/src/vector-style/removeTrailingCommas.js

@@ -1,3 +1,10 @@
+/**
+ * Remove trailing object and array commas outside quoted JSON strings.
+ *
+ * @param {string} json JSON-like source.
+ *
+ * @returns {string} Source without trailing commas.
+ */
 export function removeTrailingCommas(json) {
   let cleaned = '', quoted = false, escaped = false, i = 0, char = '';
   for (i = 0; i < json.length; i++) {

package/src/vector-style/scaleDashArray.js

@@ -1,5 +1,17 @@
 import { evaluateStyle } from './evaluateStyle.js';
 
+/**
+ * Evaluate and scale a style dash array by the line width.
+ *
+ * @param {Array} dash Dash pattern or expression, if present.
+ * @param {number} weight Line width.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {string|undefined} Space-separated scaled dashes, or undefined.
+ *
+ * @throws {TypeError} If the evaluated dash pattern is not an array.
+ */
 export function scaleDashArray(dash, weight, properties, zoom) {
   if (!dash) return undefined;
   let values = dash, i = 0, result = '';

package/src/vector-style/skipStyleComment.js

@@ -1,3 +1,14 @@
+/**
+ * Find the end of a line or block comment in style source text.
+ *
+ * @param {string} text Style source.
+ * @param {number} index Comment start index.
+ * @param {string} marker Character after the initial slash.
+ *
+ * @returns {number} Index at the end of the comment.
+ *
+ * @throws {Error} If a block comment is unterminated.
+ */
 export function skipStyleComment(text, index, marker) {
   if (marker === '/') {
     while (index < text.length && text[index] !== '\n') index++;

package/src/vector-style/stripStyleComments.js

@@ -1,6 +1,13 @@
 import { appendQuotedStyleCharacter } from './appendQuotedStyleCharacter.js';
 import { skipStyleComment } from './skipStyleComment.js';
 
+/**
+ * Strip style comments and normalize quoted strings to JSON form.
+ *
+ * @param {string} text Style source text.
+ *
+ * @returns {string} Comment-free JSON-like text.
+ */
 export function stripStyleComments(text) {
   let json = '', i = 0, char = '', next = '', converted = undefined;
   const state = /* alloc */ { quoted: '', escaped: false };

package/src/vector-style/styleColor.js

@@ -2,6 +2,13 @@ import { vectorStyleNamedColors } from '../globals/vectorStyleNamedColors.js';
 import { parseFunctionalColor } from './parseFunctionalColor.js';
 import { parseHexColor } from './parseHexColor.js';
 
+/**
+ * Resolve a supported named, hexadecimal or functional style color.
+ *
+ * @param {string} value Color text.
+ *
+ * @returns {Array<number>} Red, green, blue and alpha components.
+ */
 export function styleColor(value) {
   if (Object.hasOwn(vectorStyleNamedColors, value)) return vectorStyleNamedColors[value];
   if (/^#[0-9a-f]{3}$/i.test(value) || /^#[0-9a-f]{6}$/i.test(value)) {

package/src/vector-style/validateVectorLayers.js

@@ -1,3 +1,11 @@
+/**
+ * Validate that a vector style contains layers with string IDs and types.
+ *
+ * @param {*} layers Parsed style layers.
+ *
+ * @throws {Error} If layers is not an array.
+ * @throws {Error} If a layer lacks a string ID or type.
+ */
 export function validateVectorLayers(layers) {
   let i = 0, layer = null;
   if (!Array.isArray(layers)) throw /* alloc */ new Error('Invalid vector style layers');

package/src/vector-style/vectorPaint.js

@@ -1,6 +1,15 @@
 import { fillVectorPaint } from './fillVectorPaint.js';
 import { lineVectorPaint } from './lineVectorPaint.js';
 
+/**
+ * Resolve a vector style layer's fill or line paint for a feature.
+ *
+ * @param {Object} layer Vector style layer.
+ * @param {Object} properties Feature properties.
+ * @param {number} zoom Current zoom.
+ *
+ * @returns {Object} Resolved rendering options.
+ */
 export function vectorPaint(layer, properties, zoom) {
   const paint = layer.paint || /* alloc */ {};
   if (layer.type === 'fill') return fillVectorPaint(paint, properties, zoom);