@honua/sdk-esri-compat 0.1.12 → 0.1.13

package/query-planner/wfs-v1.js

@@ -0,0 +1,366 @@
+import { compileQueryFilterToFes } from "../contract/query-filter-fes.js";
+import { andQueryFilters, temporalFilterToExpression, } from "../contract/query-filter.js";
+import { UNSUPPORTED_FES, compileSpatialFilter, compileWhere, formatWfsBboxKvp, serializeFes, } from "../core/wfs-filter.js";
+import { queryIrAuthorityFingerprint } from "./ir.js";
+import { HonuaQueryPlanningError } from "./types.js";
+const WFS_GET_FILTER_BUDGET = 7000;
+/**
+ * Metadata-free planning fallback only. The live WFS adapter resolves the real
+ * geometry property per feature type (DescribeFeatureType, or an explicit
+ * `locator.geometryName`) and carries it on the IR source identity, so this
+ * legacy PostGIS-via-GeoServer default is used only when a caller compiles a
+ * plan without any geometry evidence at all.
+ */
+const DEFAULT_WFS_GEOMETRY_PROPERTY = "the_geom";
+/** Compile canonical query IR to the legacy deterministic WFS 2.0 GetFeature request. */
+export function compileWfsQuery(source, query) {
+    const typeName = requireWfsTypeName(source);
+    const geometryProperty = wfsGeometryProperty(source);
+    assertNoWfsAggregation(query);
+    if (query.spatialFilter && query.outSr !== undefined) {
+        throw new HonuaQueryPlanningError("unsupported-query", "WFS planning cannot use outSr to label input filter coordinates; stamp the input geometry through the typed WFS escape hatch");
+    }
+    const filter = compileWfsFes(typeName, query, geometryProperty);
+    const propertyName = compileWfsPropertyNames(query, geometryProperty);
+    return {
+        compiler: "wfs-2.0-get-feature-v1",
+        typeName,
+        ...(filter !== undefined ? { filter } : {}),
+        ...(propertyName ? { propertyName } : {}),
+        ...(query.orderBy && query.orderBy.length > 0
+            ? {
+                sortBy: query.orderBy.map((sort) => `${sort.field} ${sort.direction === "desc" ? "DESC" : "ASC"}`).join(","),
+            }
+            : {}),
+        ...(query.pagination?.offset !== undefined ? { startIndex: query.pagination.offset } : {}),
+        ...(query.pagination?.limit !== undefined ? { count: query.pagination.limit } : {}),
+        ...(query.outSr !== undefined ? { srsName: String(query.outSr) } : {}),
+    };
+}
+/**
+ * The exact deterministic compiler hook installed on the first-party WFS
+ * protocol module and used by planner dispatch.
+ */
+export const wfsProtocolQueryCompiler = Object.freeze({
+    kind: "wfs",
+    compile(input) {
+        const typeName = requireWfsTypeName(input.source);
+        if (!/^[A-Za-z_][A-Za-z0-9_.-]*(?::[A-Za-z_][A-Za-z0-9_.-]*)?$/.test(typeName)) {
+            throw new HonuaQueryPlanningError("invalid-query", `Source "${input.source.id}" has an invalid WFS typeName`);
+        }
+        assertNoWfsAggregation(input.query);
+        const endpoint = requireCredentialFreeWfsCompileEndpoint(input.source.endpoint);
+        const authorityFingerprint = input.source.authorityFingerprint ??
+            queryIrAuthorityFingerprint(input.source.endpoint, input.source.authorizationScope);
+        if (!/^sha256:[0-9a-f]{64}$/.test(authorityFingerprint)) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS source authority fingerprint is invalid");
+        }
+        if (typeof input.source.id !== "string" ||
+            input.source.id.length === 0 ||
+            containsControlCharacter(input.source.id)) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS source id is invalid");
+        }
+        const srsName = wfsSrsNameFromOutSr(input.query.outSr);
+        const filterSrsName = wfsSpatialFilterSrsName(input.source, input.query);
+        const geometryProperty = wfsGeometryProperty(input.source);
+        const bbox = wfsBboxKvp(input.query, filterSrsName);
+        const filter = bbox === undefined ? compileWfsFes(typeName, input.query, geometryProperty, filterSrsName) : undefined;
+        const method = wfsProtocolMethodForFilter(filter);
+        const propertyName = compileWfsPropertyNames(input.query, geometryProperty);
+        const sortBy = input.query.orderBy && input.query.orderBy.length > 0
+            ? input.query.orderBy.map((sort) => `${sort.field}${sort.direction === "desc" ? " D" : " A"}`).join(",")
+            : undefined;
+        const startIndex = input.query.pagination?.offset !== undefined && input.query.pagination.offset > 0
+            ? input.query.pagination.offset
+            : undefined;
+        return bindWfsProtocolQueryOperation({
+            sourceId: input.source.id,
+            endpoint,
+            authorityFingerprint,
+            typeName,
+            method,
+            ...(filter !== undefined ? { filter } : {}),
+            ...(bbox !== undefined ? { bbox } : {}),
+            ...(propertyName !== undefined ? { propertyName: Object.freeze([...propertyName]) } : {}),
+            ...(sortBy !== undefined ? { sortBy } : {}),
+            ...(startIndex !== undefined ? { startIndex } : {}),
+            ...(input.query.pagination?.limit !== undefined ? { count: input.query.pagination.limit } : {}),
+            ...(filterSrsName !== undefined ? { filterSrsName } : {}),
+            ...(srsName !== undefined ? { srsName } : {}),
+        }, input.operation);
+    },
+});
+/** Bind a WFS wire request to the exact operation authorized to execute it. */
+export function bindWfsProtocolQueryOperation(request, operation) {
+    if (operation !== "query" && operation !== "queryAll" && operation !== "queryAggregate") {
+        throw new HonuaQueryPlanningError("invalid-query", "WFS protocol operation is invalid");
+    }
+    let count = request.count;
+    if (operation === "queryAll" && count !== undefined) {
+        if (!Number.isSafeInteger(count) || count < 0 || count >= Number.MAX_SAFE_INTEGER) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS queryAll pagination.limit must leave room for one lookahead row");
+        }
+        count += 1;
+    }
+    return Object.freeze({
+        compiler: "wfs-2.0-protocol-query-v1",
+        operation,
+        sourceId: request.sourceId,
+        endpoint: request.endpoint,
+        authorityFingerprint: request.authorityFingerprint,
+        typeName: request.typeName,
+        method: request.method,
+        ...(request.filter !== undefined ? { filter: request.filter } : {}),
+        ...(request.bbox !== undefined ? { bbox: request.bbox } : {}),
+        ...(request.propertyName !== undefined ? { propertyName: Object.freeze([...request.propertyName]) } : {}),
+        ...(request.sortBy !== undefined ? { sortBy: request.sortBy } : {}),
+        ...(request.startIndex !== undefined ? { startIndex: request.startIndex } : {}),
+        ...(count !== undefined ? { count } : {}),
+        ...(request.filterSrsName !== undefined ? { filterSrsName: request.filterSrsName } : {}),
+        ...(request.srsName !== undefined ? { srsName: request.srsName } : {}),
+    });
+}
+/** Credential-free endpoint identity used to bind an executable artifact to a runtime handle. */
+export function wfsRuntimeEndpointIdentity(value) {
+    return normalizeWfsEndpoint(value, true);
+}
+/** Derive the only transport method authorized by the compiled filter budget. */
+export function wfsProtocolMethodForFilter(filter) {
+    return filter !== undefined && encodeURIComponent(filter).length > WFS_GET_FILTER_BUDGET ? "POST" : "GET";
+}
+function requireCredentialFreeWfsCompileEndpoint(value) {
+    return normalizeWfsEndpoint(value, false);
+}
+function normalizeWfsEndpoint(value, allowRuntimeAuthority) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value === "[invalid-endpoint]" ||
+        containsControlCharacter(value)) {
+        throw new HonuaQueryPlanningError("invalid-query", "WFS endpoint identity is invalid");
+    }
+    try {
+        const parsed = new URL(value);
+        if (!allowRuntimeAuthority && (parsed.username || parsed.password || parsed.search || parsed.hash)) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS compile endpoint must not contain credentials, query, or fragment");
+        }
+        parsed.username = "";
+        parsed.password = "";
+        parsed.search = "";
+        parsed.hash = "";
+        // Match queryIrSourceIdentity(): normalize the URL serializer's single
+        // terminal separator without collapsing a path that intentionally ends
+        // in multiple slashes.
+        return parsed.toString().replace(/\/$/, "");
+    }
+    catch (error) {
+        if (error instanceof HonuaQueryPlanningError)
+            throw error;
+        if (/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value) || value.startsWith("//") || value.includes("@")) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS endpoint identity is invalid");
+        }
+        const queryIndex = value.search(/[?#]/);
+        if (!allowRuntimeAuthority && queryIndex >= 0) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS compile endpoint must not contain credentials, query, or fragment");
+        }
+        const path = queryIndex >= 0 ? value.slice(0, queryIndex) : value;
+        const normalized = path.replace(/\/$/, "");
+        if (path === "/")
+            return "/";
+        if (normalized.length === 0) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS endpoint identity is invalid");
+        }
+        return normalized;
+    }
+}
+function wfsBboxKvp(query, filterSrsName) {
+    const envelope = wfsBboxShortcutEnvelope(query);
+    if (!envelope)
+        return undefined;
+    return formatWfsBboxKvp(envelope.xmin, envelope.ymin, envelope.xmax, envelope.ymax, filterSrsName);
+}
+function wfsBboxShortcutEnvelope(query) {
+    const filter = query.spatialFilter;
+    // The `bbox=` KVP is mutually exclusive with `FILTER=`, so any other
+    // constraint that has to be expressed as FES (source-native `where`, the
+    // typed filter, a temporal predicate) disables the shortcut.
+    if (query.where !== undefined || query.filter !== undefined || query.temporalFilter !== undefined)
+        return undefined;
+    if (!filter || filter.geometryType !== "esriGeometryEnvelope")
+        return undefined;
+    if (filter.spatialRel !== undefined &&
+        filter.spatialRel !== "esriSpatialRelIntersects" &&
+        filter.spatialRel !== "esriSpatialRelEnvelopeIntersects") {
+        return undefined;
+    }
+    const envelope = filter.geometry;
+    if (typeof envelope.xmin !== "number" ||
+        typeof envelope.ymin !== "number" ||
+        typeof envelope.xmax !== "number" ||
+        typeof envelope.ymax !== "number") {
+        return undefined;
+    }
+    return { xmin: envelope.xmin, ymin: envelope.ymin, xmax: envelope.xmax, ymax: envelope.ymax };
+}
+/**
+ * @internal True when the compiled request must name the geometry property in
+ * an FES spatial predicate. The `bbox=` KVP shortcut addresses the feature
+ * type's default geometry positionally, so it needs no name; every other
+ * spatial predicate emits `<fes:ValueReference>` and does. The live adapter
+ * uses this to resolve the property (and fail closed) only when the wire
+ * actually depends on it.
+ */
+export function wfsSpatialFilterNeedsGeometryProperty(query) {
+    if (query.filter !== undefined && queryFilterContainsSpatial(query.filter))
+        return true;
+    return query.spatialFilter !== undefined && wfsBboxShortcutEnvelope(query) === undefined;
+}
+/** True when the typed filter references the feature type's geometry property. */
+function queryFilterContainsSpatial(filter) {
+    if (filter.kind === "spatial")
+        return filter.property === undefined;
+    if (filter.kind === "boolean")
+        return filter.args.some(queryFilterContainsSpatial);
+    if (filter.kind === "not")
+        return queryFilterContainsSpatial(filter.arg);
+    return false;
+}
+/** Geometry property the compiled request references by name. */
+function wfsGeometryProperty(source) {
+    return source.geometryProperty ?? DEFAULT_WFS_GEOMETRY_PROPERTY;
+}
+/** @internal Shared with legacy non-query WFS drains to preserve CRS parity. */
+export function wfsSrsNameFromOutSr(outSr) {
+    if (typeof outSr === "string") {
+        if (outSr.length === 0)
+            return undefined;
+        if (outSr.trim() !== outSr || /[\s,]/.test(outSr) || containsControlCharacter(outSr)) {
+            throw new HonuaQueryPlanningError("invalid-query", "WFS CRS identifier is invalid");
+        }
+        return outSr;
+    }
+    if (typeof outSr === "number" && Number.isSafeInteger(outSr) && outSr > 0) {
+        return `urn:ogc:def:crs:EPSG::${outSr}`;
+    }
+    if (outSr === undefined)
+        return undefined;
+    throw new HonuaQueryPlanningError("invalid-query", "WFS CRS identifier is invalid");
+}
+function wfsSpatialFilterSrsName(source, query) {
+    const spatialFilter = query.spatialFilter;
+    if (!spatialFilter)
+        return undefined;
+    return wfsFilterSrsNameFromGeometry(spatialFilter.geometry, source.srsName);
+}
+/** @internal Resolve only the input geometry CRS; response `outSr` is separate. */
+export function wfsFilterSrsNameFromGeometry(geometry, fallback) {
+    const spatialReference = geometry.spatialReference;
+    if (spatialReference === undefined)
+        return wfsSrsNameFromOutSr(fallback);
+    if (spatialReference === null || typeof spatialReference !== "object" || Array.isArray(spatialReference)) {
+        throw new HonuaQueryPlanningError("invalid-query", "WFS spatial filter geometry has an invalid spatialReference");
+    }
+    const reference = spatialReference;
+    const keys = Object.keys(reference);
+    if (keys.some((key) => key !== "wkid" && key !== "latestWkid" && key !== "wkt")) {
+        throw new HonuaQueryPlanningError("invalid-query", "WFS spatial filter geometry has an unsupported spatialReference member");
+    }
+    if (reference.wkt !== undefined) {
+        throw new HonuaQueryPlanningError("unsupported-query", "WFS spatial filters require a WKID-backed CRS; WKT cannot be serialized as a portable srsName");
+    }
+    for (const [name, value] of [
+        ["wkid", reference.wkid],
+        ["latestWkid", reference.latestWkid],
+    ]) {
+        if (value !== undefined && (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)) {
+            throw new HonuaQueryPlanningError("invalid-query", `WFS spatial filter geometry has an invalid ${name}`);
+        }
+    }
+    const wkid = reference.latestWkid ?? reference.wkid;
+    if (typeof wkid !== "number") {
+        throw new HonuaQueryPlanningError("invalid-query", "WFS spatial filter geometry requires a positive WKID");
+    }
+    return wfsSrsNameFromOutSr(wkid);
+}
+function requireWfsTypeName(source) {
+    if (source.protocol !== "wfs") {
+        throw new HonuaQueryPlanningError("unsupported-compiler", `wfs-2.0-get-feature-v1 does not compile protocol "${source.protocol}"`);
+    }
+    if (!source.typeName) {
+        throw new HonuaQueryPlanningError("invalid-query", `Source "${source.id}" requires locator.typeName for WFS planning`);
+    }
+    return source.typeName;
+}
+function assertNoWfsAggregation(query) {
+    if (query.aggregation) {
+        throw new HonuaQueryPlanningError("unsupported-query", "WFS 2.0 has no portable remote aggregation; use degraded policy with an explicit bounded-local fallback");
+    }
+}
+function compileWfsFes(typeName, query, geometryProperty, srsName) {
+    const filters = [];
+    const typed = compileWfsTypedFilter(query, geometryProperty);
+    if (typed)
+        filters.push(typed);
+    if (query.where) {
+        const where = compileWhere(query.where.expression);
+        if (where === UNSUPPORTED_FES) {
+            throw new HonuaQueryPlanningError("unsupported-query", "The where clause is not expressible as FES 2.0");
+        }
+        if (where.kind !== "and" || where.operands.length > 0)
+            filters.push(where);
+    }
+    if (query.spatialFilter) {
+        const spatial = compileSpatialFilter({
+            geometry: query.spatialFilter.geometry,
+            geometryType: query.spatialFilter.geometryType,
+            ...(query.spatialFilter.spatialRel ? { spatialRel: query.spatialFilter.spatialRel } : {}),
+        }, {
+            geometryProperty,
+            ...(srsName !== undefined ? { srsName } : {}),
+        });
+        if (spatial === UNSUPPORTED_FES) {
+            throw new HonuaQueryPlanningError("unsupported-query", "The spatial predicate is not expressible as FES 2.0");
+        }
+        filters.push(spatial);
+    }
+    return filters.length > 0 ? serializeFes(filters, { typeName }) : undefined;
+}
+/**
+ * Compile the canonical typed filter (and a field-bound temporal filter) into
+ * FES 2.0. WFS has no protocol-level time parameter, so a temporal filter
+ * without a field is refused instead of being applied to a guessed column.
+ */
+function compileWfsTypedFilter(query, geometryProperty) {
+    const ctx = { protocol: "wfs", geometryProperty };
+    const temporalExpression = query.temporalFilter ? temporalFilterToExpression(query.temporalFilter, ctx) : undefined;
+    if (query.temporalFilter && temporalExpression === undefined) {
+        throw new HonuaQueryPlanningError("unsupported-query", "WFS has no protocol-level time parameter; Query.temporalFilter must name the temporal field");
+    }
+    const expression = andQueryFilters(query.filter, temporalExpression);
+    if (!expression)
+        return undefined;
+    return compileQueryFilterToFes(expression, ctx);
+}
+function compileWfsPropertyNames(query, geometryProperty) {
+    if (query.outFields && query.outFields.length > 0) {
+        const fields = [...query.outFields];
+        if (query.returnGeometry === false && fields.includes(geometryProperty)) {
+            throw new HonuaQueryPlanningError("unsupported-query", `WFS returnGeometry=false conflicts with outFields containing the geometry property "${geometryProperty}"`);
+        }
+        if (query.returnGeometry !== false && !fields.includes(geometryProperty)) {
+            fields.push(geometryProperty);
+        }
+        return fields;
+    }
+    if (query.returnGeometry === false) {
+        throw new HonuaQueryPlanningError("unsupported-query", "WFS returnGeometry=false requires explicit outFields because propertyName cannot otherwise suppress geometry exactly");
+    }
+    return undefined;
+}
+function containsControlCharacter(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code <= 0x1f || code === 0x7f)
+            return true;
+    }
+    return false;
+}

package/query-planner/wfs.d.ts

@@ -0,0 +1,4 @@
+export { compileWfsQuery } from "./wfs-v1.js";
+export { compileSemanticWfsQuery } from "./wfs-semantic.js";
+export type { SemanticWfsCompileOptions, SemanticWfsCompiledQueryV1, SemanticWfsSourceIdentity, Wfs20FilterCapabilitiesEvidence, } from "./wfs-semantic.js";
+//# sourceMappingURL=wfs.d.ts.map

package/query-planner/wfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfs.d.ts","sourceRoot":"","sources":["../../../src/query-planner/wfs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,YAAY,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,yBAAyB,EACzB,+BAA+B,GAChC,MAAM,mBAAmB,CAAC"}

package/query-planner/wfs.js

@@ -0,0 +1,2 @@
+export { compileWfsQuery } from "./wfs-v1.js";
+export { compileSemanticWfsQuery } from "./wfs-semantic.js";

package/widget-capabilities.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pure helpers behind sketch snapping, histogram bins, form expressions,
+ * multi-feature edits, and elevation samples.
+ */
+export interface SnapPoint {
+    x: number;
+    y: number;
+}
+export declare function snapVertex(pointer: SnapPoint, vertices: readonly SnapPoint[], enabled: boolean, tolerance?: number): SnapPoint;
+export interface HistogramStats {
+    count: number;
+    sum: number;
+    min: number;
+    max: number;
+    average: number;
+}
+export interface HistogramBin {
+    label: string;
+    min: number;
+    max: number;
+    value: number;
+}
+export declare function histogramBins(values: readonly number[], stats: HistogramStats, classes: number, method: "equal-interval" | "quantile"): HistogramBin[];
+export declare function histogramRangeFilter(min: number, max: number): string;
+export interface FormExpressionField {
+    name: string;
+    visibleExpression?: string;
+    valueExpression?: string;
+}
+export interface FormExpressionResult {
+    hidden: string[];
+    values: Record<string, unknown>;
+    errors: {
+        field: string;
+        message: string;
+    }[];
+}
+export declare function evaluateFormExpressions(fields: readonly FormExpressionField[], feature: {
+    attributes?: Record<string, unknown>;
+}): FormExpressionResult;
+export interface FeatureEdit {
+    attributes?: Record<string, unknown>;
+}
+export interface ApplyEditsResult {
+    error?: string;
+    reason?: string;
+}
+export declare function applyToFeatures(features: readonly FeatureEdit[], change: Record<string, unknown>, applyEdits: (edit: {
+    update: FeatureEdit;
+}) => Promise<ApplyEditsResult>): Promise<{
+    applied: FeatureEdit[];
+    rejected: {
+        feature: FeatureEdit;
+        reason: string;
+    }[];
+}>;
+export interface ElevationSample {
+    position: [number, number];
+    elevation: number;
+}
+export declare function sampleElevations(line: readonly [number, number][], terrain: {
+    elevationAt: (longitude: number, latitude: number) => number;
+} | undefined, spacing?: number): {
+    samples: ElevationSample[];
+    error?: string;
+};
+//# sourceMappingURL=widget-capabilities.d.ts.map

package/widget-capabilities.js

@@ -0,0 +1,152 @@
+/**
+ * Pure helpers behind sketch snapping, histogram bins, form expressions,
+ * multi-feature edits, and elevation samples.
+ */
+export function snapVertex(pointer, vertices, enabled, tolerance = 1) {
+    if (!enabled || vertices.length === 0)
+        return { ...pointer };
+    let nearest = vertices[0];
+    let nearestDistance = distance(pointer, nearest);
+    for (const vertex of vertices.slice(1)) {
+        const candidate = distance(pointer, vertex);
+        if (candidate < nearestDistance) {
+            nearest = vertex;
+            nearestDistance = candidate;
+        }
+    }
+    return nearestDistance <= tolerance ? { x: nearest.x, y: nearest.y } : { ...pointer };
+}
+function distance(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+export function histogramBins(values, stats, classes, method) {
+    if (classes < 1)
+        throw new Error("histogram classes must be at least 1");
+    assertStats(values, stats);
+    const breaks = method === "quantile" ? quantileEdges(values, classes) : equalIntervalEdges(stats.min, stats.max, classes);
+    const bins = [];
+    for (let index = 0; index < breaks.length - 1; index += 1) {
+        const min = breaks[index] ?? stats.min;
+        const max = breaks[index + 1] ?? stats.max;
+        const last = index === breaks.length - 2;
+        const value = values.filter((item) => (last ? item >= min && item <= max : item >= min && item < max)).length;
+        bins.push({ label: `${min}–${max}`, min, max, value });
+    }
+    return bins;
+}
+export function histogramRangeFilter(min, max) {
+    return `value >= ${min} AND value <= ${max}`;
+}
+function assertStats(values, stats) {
+    const count = values.length;
+    const sum = values.reduce((total, value) => total + value, 0);
+    const min = values.length === 0 ? Number.NaN : Math.min(...values);
+    const max = values.length === 0 ? Number.NaN : Math.max(...values);
+    const average = count === 0 ? Number.NaN : sum / count;
+    if (stats.count !== count ||
+        stats.sum !== sum ||
+        stats.min !== min ||
+        stats.max !== max ||
+        stats.average !== average) {
+        throw new Error("histogram statistics do not match the feature values");
+    }
+}
+function equalIntervalEdges(min, max, classes) {
+    const width = classes === 0 ? 0 : (max - min) / classes;
+    return Array.from({ length: classes + 1 }, (_, index) => min + width * index);
+}
+function quantileEdges(values, classes) {
+    const sorted = [...values].sort((a, b) => a - b);
+    if (sorted.length === 0)
+        return [0, 0];
+    const edges = [sorted[0] ?? 0];
+    for (let index = 1; index < classes; index += 1) {
+        const position = (index * (sorted.length - 1)) / classes;
+        const lower = Math.floor(position);
+        const upper = Math.ceil(position);
+        const weight = position - lower;
+        const left = sorted[lower] ?? sorted[0] ?? 0;
+        const right = sorted[upper] ?? left;
+        edges.push(left + (right - left) * weight);
+    }
+    edges.push(sorted[sorted.length - 1] ?? edges[0] ?? 0);
+    return edges;
+}
+export function evaluateFormExpressions(fields, feature) {
+    const hidden = [];
+    const values = {};
+    const errors = [];
+    for (const field of fields) {
+        if (field.visibleExpression) {
+            const visible = evaluateExpression(field.visibleExpression, feature.attributes ?? {}, field.name, errors);
+            if (visible === false)
+                hidden.push(field.name);
+        }
+        if (field.valueExpression) {
+            const value = evaluateExpression(field.valueExpression, feature.attributes ?? {}, field.name, errors);
+            if (value !== undefined &&
+                !errors.some((error) => error.field === field.name && error.message.includes(field.valueExpression ?? ""))) {
+                values[field.name] = value;
+            }
+        }
+    }
+    return { hidden, values, errors };
+}
+function evaluateExpression(expression, attributes, field, errors) {
+    const call = expression.match(/^([A-Za-z_][A-Za-z0-9_]*)\(/);
+    if (call && call[1] !== "Number") {
+        errors.push({ field, message: `unknown function ${call[1]} in ${expression}` });
+        return undefined;
+    }
+    const equality = expression.match(/^\$feature\.([A-Za-z0-9_]+)\s*==\s*'([^']*)'$/);
+    if (equality)
+        return attributes[equality[1] ?? ""] === equality[2];
+    const sum = expression.match(/^\$feature\.([A-Za-z0-9_]+)\s*\+\s*\$feature\.([A-Za-z0-9_]+)$/);
+    if (sum)
+        return Number(attributes[sum[1] ?? ""]) + Number(attributes[sum[2] ?? ""]);
+    const reference = expression.match(/^\$feature\.([A-Za-z0-9_]+)$/);
+    if (reference)
+        return attributes[reference[1] ?? ""];
+    errors.push({ field, message: `unsupported expression ${expression}` });
+    return undefined;
+}
+export async function applyToFeatures(features, change, applyEdits) {
+    const applied = [];
+    const rejected = [];
+    for (const feature of features) {
+        const update = { attributes: { ...(feature.attributes ?? {}), ...change } };
+        const result = await applyEdits({ update });
+        if (result.error || result.reason)
+            rejected.push({ feature, reason: result.reason ?? result.error ?? "rejected" });
+        else
+            applied.push(update);
+    }
+    return { applied, rejected };
+}
+export function sampleElevations(line, terrain, spacing = 1) {
+    if (!terrain)
+        return { samples: [], error: "terrain-missing" };
+    const densified = densify(line, spacing);
+    return {
+        samples: densified.map((position) => ({
+            position,
+            elevation: terrain.elevationAt(position[0], position[1]),
+        })),
+    };
+}
+function densify(line, spacing) {
+    if (line.length === 0)
+        return [];
+    const points = [line[0]];
+    for (let index = 1; index < line.length; index += 1) {
+        const start = line[index - 1];
+        const end = line[index];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+        const steps = Math.max(1, Math.ceil(length / spacing));
+        for (let step = 1; step <= steps; step += 1) {
+            const t = step / steps;
+            points.push([start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t]);
+        }
+    }
+    return points;
+}