@honua/app-platform 0.1.12 → 0.1.13

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;
+}